☰

rx-util

rxliuli 在浏览器上使用的 js 工具集

当前为 2019-11-06 提交的版本，查看 最新版本。

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.cn-greasyfork.org/scripts/382120/747202/rx-util.js 

  1. (function (global, factory) {
  2.   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  3.   typeof define === 'function' && define.amd ? define(['exports'], factory) :
  4.   (global = global || self, factory(global.rx = {}));
  5. }(this, function (exports) { 'use strict';
  6.  
  7.   /**
  8.    * 在浏览器上下载二进制资源
  9.    * @param blob 要下载的二进制资源
  10.    * @param filename 文件名
  11.    */
  12.   function download(blob, filename = 'unknown') {
  13.       // 创建隐藏的可下载链接
  14.       const eleLink = document.createElement('a');
  15.       eleLink.download = filename;
  16.       eleLink.style.display = 'none';
  17.       // 为 link 赋值
  18.       eleLink.href = URL.createObjectURL(blob);
  19.       // 触发点击
  20.       document.body.appendChild(eleLink);
  21.       eleLink.click();
  22.       // 然后移除
  23.       document.body.removeChild(eleLink);
  24.   }
  25.  
  26.   /*! *****************************************************************************
  27.   Copyright (c) Microsoft Corporation. All rights reserved.
  28.   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  29.   this file except in compliance with the License. You may obtain a copy of the
  30.   License at http://www.apache.org/licenses/LICENSE-2.0
  31.  
  32.   THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  33.   KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  34.   WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  35.   MERCHANTABLITY OR NON-INFRINGEMENT.
  36.  
  37.   See the Apache Version 2.0 License for specific language governing permissions
  38.   and limitations under the License.
  39.   ***************************************************************************** */
  40.  
  41.   function __awaiter(thisArg, _arguments, P, generator) {
  42.       return new (P || (P = Promise))(function (resolve, reject) {
  43.           function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  44.           function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  45.           function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
  46.           step((generator = generator.apply(thisArg, _arguments || [])).next());
  47.       });
  48.   }
  49.  
  50.   /**
  51.    * 将字符串转化为 Blob 类型
  52.    * @param str 字符串
  53.    * @returns Blob 数据
  54.    */
  55.   function strToBlob(str) {
  56.       return new Blob([str], {
  57.           type: 'text/plain',
  58.       });
  59.   }
  60.  
  61.   /**
  62.    * 在浏览器上下载文本内容
  63.    * @param str 字符串内容
  64.    * @param filename 下载文件名，没有则默认为链接中的文件名
  65.    */
  66.   function downloadString(str, filename = 'unknown.txt') {
  67.       return __awaiter(this, void 0, void 0, function* () {
  68.           download(strToBlob(str), filename);
  69.       });
  70.   }
  71.  
  72.   /**
  73.    * 根据 url 下载二进制资源
  74.    * @param url 下载请求信息
  75.    * @param filename 下载文件名，没有则默认为链接中的文件名
  76.    */
  77.   function downloadUrl(url, filename = url.substr(url.lastIndexOf('/'))) {
  78.       return __awaiter(this, void 0, void 0, function* () {
  79.           // 创建隐藏的可下载链接
  80.           const eleLink = document.createElement('a');
  81.           eleLink.download = filename;
  82.           eleLink.style.display = 'none';
  83.           // 为 link 赋值
  84.           eleLink.href = url;
  85.           // 触发点击
  86.           document.body.appendChild(eleLink);
  87.           eleLink.click();
  88.           // 然后移除
  89.           document.body.removeChild(eleLink);
  90.       });
  91.   }
  92.  
  93.   /**
  94.    * 获取 cookie 键值映射 Map
  95.    * @returns cookie 键值映射 Map
  96.    */
  97.   function getCookies() {
  98.       return document.cookie.split(';').reduce((res, str) => {
  99.           const [k, v] = str.split('=');
  100.           res.set(k, v);
  101.           return res;
  102.       }, new Map());
  103.   }
  104.  
  105.   /**
  106.    * 将 url 中的内容加载到元素上
  107.    * 注：domSelector 必须有 src 属性用以将加载完成的资源赋值给其，加载默认是异步的
  108.    * @param url url 资源
  109.    * @param dom dom 元素
  110.    * @param init 初始化参数, 实为 fetch() 的参数以及一些自定义的参数，默认 {}
  111.    * 关于 fetch 具体可以参考 <https://developer.mozilla.org/zh-CN/docs/Web/API/Fetch_API/Using_Fetch>
  112.    */
  113.   function loadResource(url, dom, init = {}) {
  114.       return __awaiter(this, void 0, void 0, function* () {
  115.           const res = yield fetch(url, init);
  116.           const blob = yield res.blob();
  117.           // 生成一个本地的 url 并赋值给 src 属性
  118.           dom.src = window.URL.createObjectURL(blob);
  119.       });
  120.   }
  121.  
  122.   /**
  123.    * 协议与默认端口映射表
  124.    */
  125.   const protocolPortMap = new Map()
  126.       .set('http', 80)
  127.       .set('https', 443)
  128.       .set('ssh', 22)
  129.       .set('ftp', 21);
  130.   /**
  131.    * 解析 url 字符串
  132.    * @param url url 字符串，不能为空
  133.    * @returns url 对象
  134.    * @deprecated 请使用原生 API URL 类，可以通过 new URL(url) 将 URL 字符串转换为 URL 对象，并获取指定的信息
  135.    */
  136.   function parseUrl(url) {
  137.       if (!url) {
  138.           throw new Error('Url cannot be empty');
  139.       }
  140.       const regexp = new RegExp('^((\\w+)://([\\w\\.]*)(:(\\d+))?)(.*)');
  141.       const temps = regexp.exec(url);
  142.       if (temps === null) {
  143.           return null;
  144.       }
  145.       const website = temps[1];
  146.       const protocol = temps[2];
  147.       const domain = temps[3];
  148.       const portStr = temps[5];
  149.       const href = temps[6];
  150.       // 截取域名之后的内容
  151.       const temp = url.substr(website.length);
  152.       const markIndex = temp.indexOf('?');
  153.       // 如果没有携带参数则直接返回
  154.       if (markIndex === -1) {
  155.           const accessPath = temp;
  156.           return {
  157.               url,
  158.               website,
  159.               protocol,
  160.               domain,
  161.               // tslint:disable-next-line:radix
  162.               port: parseInt(portStr),
  163.               href,
  164.               accessPath,
  165.               params: new Map(),
  166.           };
  167.       }
  168.       let accessPath = temp.substr(0, markIndex);
  169.       if (accessPath.endsWith('/')) {
  170.           accessPath = accessPath.substring(0, accessPath.length - 1);
  171.       }
  172.       const port = portStr || protocolPortMap.get(protocol) || 0;
  173.       // 解析参数列表
  174.       const params = temp
  175.           .substr(markIndex + 1)
  176.           .split('&')
  177.           .map(str => str.split('='))
  178.           .filter(arr => arr[0] !== '')
  179.           .reduce((params, arr) => {
  180.           const k = decodeURIComponent(arr[0]);
  181.           const v = decodeURIComponent(arr.length === 1 ? '' : arr[1]);
  182.           // 如果已经存在了就认为是数组参数
  183.           const vs = params.get(k);
  184.           if (vs === undefined) {
  185.               params.set(k, v);
  186.           }
  187.           else {
  188.               if (!Array.isArray(vs)) {
  189.                   params.set(k, [vs]);
  190.               }
  191.               if (params.get(k).length !== undefined) {
  192.                   params.get(k).push(v);
  193.               }
  194.           }
  195.           return params;
  196.       }, new Map());
  197.       return {
  198.           url,
  199.           website,
  200.           protocol,
  201.           domain,
  202.           port,
  203.           href,
  204.           accessPath,
  205.           params,
  206.       };
  207.   }
  208.  
  209.   /**
  210.    * 读取文件类型
  211.    */
  212.   var ReadType;
  213.   (function (ReadType) {
  214.       /**
  215.        * 以 data url 读取
  216.        */
  217.       ReadType["DataURL"] = "readAsDataURL";
  218.       /**
  219.        * 以文本读取
  220.        */
  221.       ReadType["Text"] = "readAsText";
  222.       /**
  223.        * 以二进制文件读取
  224.        */
  225.       ReadType["BinaryString"] = "readAsBinaryString";
  226.       /**
  227.        * 以 ArrayBuffer 读取
  228.        */
  229.       ReadType["ArrayBuffer"] = "readAsArrayBuffer";
  230.   })(ReadType || (ReadType = {}));
  231.   /**
  232.    * 读取本地浏览器选择的文件
  233.    * @param file 选择的文件
  234.    * @param option 可选项参数
  235.    * @param option.type 读取的类型，默认按照二进制 url 读取
  236.    * @param option.encoding 读取的编码格式，默认为 UTF-8
  237.    * @returns 返回了读取到的内容（异步）
  238.    */
  239.   function readLocal(file, { type = readLocal.DataURL, encoding = 'UTF-8', } = {}) {
  240.       return new Promise((resolve, reject) => {
  241.           if (!file) {
  242.               reject(new Error('file not exists'));
  243.           }
  244.           const fr = new FileReader();
  245.           fr.onload = () => {
  246.               resolve(fr.result);
  247.           };
  248.           fr.onerror = error => {
  249.               reject(error);
  250.           };
  251.           new Map()
  252.               .set(ReadType.DataURL, () => fr.readAsDataURL(file))
  253.               .set(ReadType.Text, () => fr.readAsText(file, encoding))
  254.               .set(ReadType.BinaryString, () => fr.readAsBinaryString(file))
  255.               .set(ReadType.ArrayBuffer, () => fr.readAsArrayBuffer(file))
  256.               .get(type)();
  257.       });
  258.   }
  259.   /**
  260.    * 以 data url 读取
  261.    * @deprecated 已废弃，请使用枚举类 ReadType
  262.    */
  263.   readLocal.DataURL = ReadType.DataURL;
  264.   /**
  265.    * 以文本读取
  266.    * @deprecated 已废弃，请使用枚举类 ReadType
  267.    */
  268.   readLocal.Text = ReadType.Text;
  269.   /**
  270.    * 以二进制文件读取
  271.    * @deprecated 已废弃，请使用枚举类 ReadType
  272.    */
  273.   readLocal.BinaryString = ReadType.BinaryString;
  274.   /**
  275.    * 以 ArrayBuffer 读取
  276.    * @deprecated 已废弃，请使用枚举类 ReadType
  277.    */
  278.   readLocal.ArrayBuffer = ReadType.ArrayBuffer;
  279.  
  280.   /**
  281.    * 为 js 中的 Date 对象原型添加 format 格式化方法
  282.    * @param date 要进行格式化的日期
  283.    * @param fmt 日期的格式
  284.    * @returns 格式化得到的结果
  285.    */
  286.   function dateFormat(date, fmt) {
  287.       const timeFormatDefaults = {
  288.           'Y+|y+': date.getFullYear(),
  289.           'M+': date.getMonth() + 1,
  290.           'D+|d+': date.getDate(),
  291.           'h+': date.getHours(),
  292.           'm+': date.getMinutes(),
  293.           's+': date.getSeconds(),
  294.           'q+': Math.floor((date.getMonth() + 3) / 3),
  295.           'S+': date.getMilliseconds(),
  296.       };
  297.       for (const k in timeFormatDefaults) {
  298.           if (!new RegExp('(' + k + ')').test(fmt)) {
  299.               continue;
  300.           }
  301.           if (k === 'Y+|y+') {
  302.               fmt = fmt.replace(RegExp.$1, ('' + timeFormatDefaults[k]).substr(4 - RegExp.$1.length));
  303.           }
  304.           else if (k === 'S+') {
  305.               let lens = RegExp.$1.length;
  306.               lens = lens === 1 ? 3 : lens;
  307.               fmt = fmt.replace(RegExp.$1, ('00' + timeFormatDefaults[k]).substr(('' + timeFormatDefaults[k]).length - 1, lens));
  308.           }
  309.           else {
  310.               const v = Reflect.get(timeFormatDefaults, k);
  311.               fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? v : ('00' + v).substr(('' + v).length));
  312.           }
  313.       }
  314.       return fmt;
  315.   }
  316.  
  317.   /**
  318.    * 默认的日期格式
  319.    * 不加 Z 为本地日期时间，避免出现时区的问题
  320.    */
  321.   const dateFormatter = 'yyyy-MM-ddThh:mm:ss.SSS';
  322.   /**
  323.    * 将参数 key 与 value 进行 url 编码
  324.    * @param k 参数的名字
  325.    * @param v 参数的值
  326.    * @returns 编码后的字符串
  327.    */
  328.   const encode = (k, v) => encodeURIComponent(k) + '=' + encodeURIComponent(v);
  329.   /**
  330.    * 拼接参数字符串
  331.    * @param params 参数对象
  332.    * @returns 拼接后的字符串
  333.    */
  334.   function spliceParams(params = {}) {
  335.       return Array.from(Object.entries(params)).reduce((res, [k, v]) => {
  336.           if (v === undefined || v === null) {
  337.               return res;
  338.           }
  339.           else if (v instanceof Date) {
  340.               res += encode(k, dateFormat(v, dateFormatter));
  341.           }
  342.           else if (v instanceof Array) {
  343.               res += v
  344.                   .map(item => encode(k, item instanceof Date ? dateFormat(item, dateFormatter) : item))
  345.                   .join('&');
  346.           }
  347.           else {
  348.               res += encode(k, v);
  349.           }
  350.           return (res += '&');
  351.       }, '');
  352.   }
  353.  
  354.   /**
  355.    * 等待指定的时间/等待指定表达式成立
  356.    * 如果未指定等待条件则立刻执行
  357.    * 注: 此实现在 nodejs 10- 会存在宏任务与微任务的问题，切记 async-await 本质上还是 Promise 的语法糖，实际上并非真正的同步函数！！！即便在浏览器，也不要依赖于这种特性。
  358.    * @param param 等待时间/等待条件
  359.    * @returns Promise 对象
  360.    */
  361.   function wait(param) {
  362.       return new Promise(resolve => {
  363.           if (typeof param === 'number') {
  364.               setTimeout(resolve, param);
  365.           }
  366.           else if (typeof param === 'function') {
  367.               const timer = setInterval(() => {
  368.                   if (param()) {
  369.                       clearInterval(timer);
  370.                       resolve();
  371.                   }
  372.               }, 100);
  373.           }
  374.           else {
  375.               resolve();
  376.           }
  377.       });
  378.   }
  379.  
  380.   /**
  381.    * 为 fetch 请求添加超时选项
  382.    * 注：超时选项并非真正意义上的超时即取消请求，请求依旧正常执行完成，但会提前返回 reject 结果
  383.    * @param fetchPromise fetch 请求的 Promise
  384.    * @param timeout 超时时间
  385.    * @returns 如果超时就提前返回 reject, 否则正常返回 fetch 结果
  386.    */
  387.   function fetchTimeout(fetchPromise, timeout) {
  388.       return Promise.race([
  389.           fetchPromise,
  390.           wait(timeout).then(() => {
  391.               throw new Error('timeout');
  392.           }),
  393.       ]);
  394.   }
  395.  
  396.   /**
  397.    * 将字符串转为字符流
  398.    * @param str 字符串
  399.    * @returns 字符流对象
  400.    */
  401.   function strToArrayBuffer(str) {
  402.       const buf = new ArrayBuffer(str.length);
  403.       const view = new Uint8Array(buf);
  404.       for (let i = 0; i < str.length; ++i) {
  405.           view[i] = str.charCodeAt(i) & 0xff;
  406.       }
  407.       return buf;
  408.   }
  409.  
  410.   /**
  411.    * 限制并发请求数量的 fetch 封装
  412.    * @class FetchLimiting
  413.    * @example
  414.    * const fetchLimiting = new FetchLimiting()
  415.    * fetchLimiting._fetch('/')
  416.    *   .then(res => res.json())
  417.    *   .then(json => console.log(json))
  418.    * @deprecated 已废弃，请使用 {@link asyncLimiting} 函数
  419.    */
  420.   class FetchLimiting {
  421.       /**
  422.        * 构造函数
  423.        * @param option 可选配置项
  424.        * @param option.timeout 超时毫秒数
  425.        * @param option.limit 最大并发数限制
  426.        */
  427.       constructor({ timeout = 10000, limit = 10, } = {}) {
  428.           /**
  429.            * @field timeout 超时毫秒数
  430.            */
  431.           this.timeout = timeout;
  432.           /**
  433.            * @field limit 最大并发数限制
  434.            */
  435.           this.limit = limit;
  436.           /**
  437.            * @field execCount 当前正在执行异步的数量
  438.            */
  439.           this.execCount = 0;
  440.           /**
  441.            * @field waitArr 等待的队列
  442.            * @type {Array.<IArguments>}
  443.            */
  444.           this.waitArr = [];
  445.       }
  446.       /**
  447.        * 执行一个请求
  448.        * 如果到达最大并发限制时就进行等待
  449.        * @param url 请求 url 信息
  450.        * @param init 请求的其他可选项，默认为 undefined
  451.        * @returns 如果超时就提前返回 reject, 否则正常返回 fetch 结果
  452.        */
  453.       fetch(input, init) {
  454.           return __awaiter(this, void 0, void 0, function* () {
  455.               const _innerFetch = () => __awaiter(this, void 0, void 0, function* () {
  456.                   this.execCount++;
  457.                   const args = this.waitArr.shift();
  458.                   try {
  459.                       // 这里的 args 实际上就是 arguments 对象，即上面的 url 和 init
  460.                       return yield fetchTimeout(fetch(args[0], args[1]), this.timeout);
  461.                   }
  462.                   finally {
  463.                       this.execCount--;
  464.                   }
  465.               });
  466.               this.waitArr.push([input, init]);
  467.               yield wait(() => this.execCount < this.limit);
  468.               // 尝试启动等待队列
  469.               return _innerFetch();
  470.           });
  471.       }
  472.   }
  473.  
  474.   /**
  475.    * 将一个 Iterator 迭代器转换为一个 Array
  476.    * @param iterator Iterator 迭代器
  477.    * @return Iterator 中每一项元素转换而得到的 Array
  478.    * @deprecated 已废弃，请使用 ES6 原生函数 {@see Array.from} 替代
  479.    */
  480.   function asIterator(iterator) {
  481.       const arr = [];
  482.       while (true) {
  483.           const next = iterator.next();
  484.           if (next.done) {
  485.               break;
  486.           }
  487.           arr.push(next.value);
  488.       }
  489.       return arr;
  490.   }
  491.  
  492.   /**
  493.    * 判断一个对象是否是无效的
  494.    * 无效的值仅包含 null/undefined
  495.    * @param object 任何一个对象
  496.    * @returns 是否无效的值
  497.    */
  498.   function isNullOrUndefined(object) {
  499.       return object === undefined || object === null;
  500.   }
  501.  
  502.   /**
  503.    * 返回第一个参数的函数
  504.    * 注: 一般可以当作返回参数自身的函数，如果你只关注第一个参数的话
  505.    * @param obj 任何对象
  506.    * @typeparam T 传入参数的类型
  507.    * @typeparam R 返回结果的类型，默认为 T，只是为了兼容该函数当参数被传递时可能出现需要类型不一致的问题
  508.    * @returns 传入的第一个参数
  509.    */
  510.   function returnItself(obj) {
  511.       return obj;
  512.   }
  513.  
  514.   /**
  515.    * 兼容异步函数的返回值
  516.    * @param res 返回值
  517.    * @param callback 同步/异步结果的回调函数
  518.    * @typeparam T 处理参数的类型，如果是 Promise 类型，则取出其泛型类型
  519.    * @typeparam Param 处理参数具体的类型，如果是 Promise 类型，则指定为原类型
  520.    * @typeparam R 返回值具体的类型，如果是 Promise 类型，则指定为 Promise 类型，否则为原类型
  521.    * @returns 处理后的结果，如果是同步的，则返回结果是同步的，否则为异步的
  522.    */
  523.   function compatibleAsync(res, callback) {
  524.       return (res instanceof Promise
  525.           ? res.then(callback)
  526.           : callback(res));
  527.   }
  528.  
  529.   /**
  530.    * 内部使用的函数
  531.    * 注: 如果谓词中包含任意一个异步(返回 Promise)函数,则整个返回结果将变成异步的,否则默认为同步操作.
  532.    * @param fns 谓词数组
  533.    * @param args 谓词应用的参数列表
  534.    * @param condition 临界条件
  535.    * @returns 返回结果
  536.    */
  537.   function _inner(fns, args, condition) {
  538.       const fn = fns[0];
  539.       const res = fn(...args);
  540.       function _call(res) {
  541.           if (condition(res)) {
  542.               return res;
  543.           }
  544.           const others = fns.slice(1);
  545.           if (others.length === 0) {
  546.               return res;
  547.           }
  548.           return _inner(others, args, condition);
  549.       }
  550.       return compatibleAsync(res, _call);
  551.   }
  552.   /**
  553.    * 连接谓词函数
  554.    */
  555.   class CombinedPredicate {
  556.       /**
  557.        * 使用 && 进行连接
  558.        * @param fns 连接任意多个谓词
  559.        * @returns 连接后的新谓词
  560.        */
  561.       static and(...fns) {
  562.           return function (...args) {
  563.               return _inner(fns, args, res => !res);
  564.           };
  565.       }
  566.       /**
  567.        * 使用 || 进行连接
  568.        * @param fns 连接任意多个谓词
  569.        * @returns 连接后的新谓词
  570.        */
  571.       static or(...fns) {
  572.           return function (...args) {
  573.               return _inner(fns, args, res => res);
  574.           };
  575.       }
  576.       /**
  577.        * 对谓词进行取反
  578.        * @param fn 谓词
  579.        * @returns 取反后的谓词
  580.        */
  581.       static not(fn) {
  582.           return new Proxy(fn, {
  583.               apply(_, _this, args) {
  584.                   return compatibleAsync(Reflect.apply(_, this, args), res => !res);
  585.               },
  586.           });
  587.       }
  588.   }
  589.   const and = CombinedPredicate.and;
  590.   const or = CombinedPredicate.or;
  591.   const not = CombinedPredicate.not;
  592.  
  593.   /**
  594.    * 操作类型
  595.    */
  596.   var ActionType;
  597.   (function (ActionType) {
  598.       ActionType["forEach"] = "forEach";
  599.       ActionType["filter"] = "filter";
  600.       ActionType["map"] = "map";
  601.       ActionType["flatMap"] = "flatMap";
  602.       ActionType["sort"] = "sort";
  603.       ActionType["reduce"] = "reduce";
  604.       ActionType["reduceRight"] = "reduceRight";
  605.       ActionType["findIndex"] = "findIndex";
  606.       ActionType["find"] = "find";
  607.       ActionType["every"] = "every";
  608.       ActionType["some"] = "some";
  609.       ActionType["parallel"] = "parallel";
  610.       ActionType["serial"] = "serial";
  611.   })(ActionType || (ActionType = {}));
  612.   /**
  613.    * 保存高阶函数传入的异步操作
  614.    * @field 异步操作的类型
  615.    * @field 异步操作
  616.    */
  617.   class Action {
  618.       constructor(type, args) {
  619.           this.type = type;
  620.           this.args = args;
  621.           this.type = type;
  622.           this.args = args;
  623.       }
  624.   }
  625.   Action.Type = ActionType;
  626.   /**
  627.    * 抽象异步数组，实现了一些公共的函数
  628.    */
  629.   class InnerBaseAsyncArray {
  630.       /**
  631.        * 构造函数
  632.        * @param args 数组初始元素
  633.        */
  634.       constructor(args = []) {
  635.           this._arr = args;
  636.       }
  637.       /**
  638.        * 将整个数组排序
  639.        * @param fn 比较函数
  640.        * @returns 排序后的数组
  641.        */
  642.       sort(fn) {
  643.           return __awaiter(this, void 0, void 0, function* () {
  644.               if (fn === undefined) {
  645.                   return new InnerAsyncArray(this._arr.sort());
  646.               }
  647.               // TODO 此处为了让 type-doc 能生成文档而不得不加上类型
  648.               const arr = this._arr.map((v, i) => [v, i]);
  649.               function _sort(arr, fn) {
  650.                   return __awaiter(this, void 0, void 0, function* () {
  651.                       // 边界条件，如果传入数组的值
  652.                       if (arr.length <= 1) {
  653.                           return arr;
  654.                       }
  655.                       // 根据中间值对数组分治为两个数组
  656.                       const medianIndex = Math.floor(arr.length / 2);
  657.                       const medianValue = arr[medianIndex];
  658.                       const left = [];
  659.                       const right = [];
  660.                       for (let i = 0, len = arr.length; i < len; i++) {
  661.                           if (i === medianIndex) {
  662.                               continue;
  663.                           }
  664.                           const v = arr[i];
  665.                           if ((yield fn(v, medianValue)) <= 0) {
  666.                               left.push(v);
  667.                           }
  668.                           else {
  669.                               right.push(v);
  670.                           }
  671.                       }
  672.                       return (yield _sort(left, fn))
  673.                           .concat([medianValue])
  674.                           .concat(yield _sort(right, fn));
  675.                   });
  676.               }
  677.               return new InnerAsyncArray(yield (yield _sort(arr, ([t1], [t2]) => fn(t1, t2))).map(([_v, i]) => this._arr[i]));
  678.           });
  679.       }
  680.       /**
  681.        * 异步的 find
  682.        * @param fn 异步查询函数
  683.        * @returns 查询到的第一个值
  684.        */
  685.       find(fn) {
  686.           return __awaiter(this, void 0, void 0, function* () {
  687.               const i = yield this.findIndex(fn);
  688.               return i === -1 ? null : this._arr[i];
  689.           });
  690.       }
  691.       /**
  692.        * 异步的 every
  693.        * @param fn 异步匹配函数
  694.        * @returns 是否全部匹配
  695.        */
  696.       every(fn) {
  697.           return __awaiter(this, void 0, void 0, function* () {
  698.               return (yield this.findIndex(CombinedPredicate.not(fn))) === -1;
  699.           });
  700.       }
  701.       /**
  702.        * 异步的 some
  703.        * @param fn 异步匹配函数
  704.        * @returns 是否有任意一个匹配
  705.        */
  706.       some(fn) {
  707.           return __awaiter(this, void 0, void 0, function* () {
  708.               return (yield this.findIndex(fn)) !== -1;
  709.           });
  710.       }
  711.       /**
  712.        * 转换为并发异步数组
  713.        */
  714.       parallel() {
  715.           return new InnerAsyncArrayParallel(this._arr);
  716.       }
  717.       /**
  718.        * 转换为顺序异步数组
  719.        */
  720.       serial() {
  721.           return new InnerAsyncArray(this._arr);
  722.       }
  723.       /**
  724.        * 获取内部数组的值，将返回一个浅复制的数组
  725.        */
  726.       value() {
  727.           return this._arr.slice();
  728.       }
  729.   }
  730.   /**
  731.    * 串行的异步数组
  732.    */
  733.   class InnerAsyncArray extends InnerBaseAsyncArray {
  734.       constructor(args) {
  735.           super(args);
  736.       }
  737.       forEach(fn) {
  738.           return __awaiter(this, void 0, void 0, function* () {
  739.               for (let i = 0, len = this._arr.length; i < len; i++) {
  740.                   yield fn.call(this, this._arr[i], i, this);
  741.               }
  742.           });
  743.       }
  744.       filter(fn) {
  745.           return __awaiter(this, void 0, void 0, function* () {
  746.               const res = new InnerAsyncArray();
  747.               for (let i = 0, len = this._arr.length; i < len; i++) {
  748.                   if (yield fn.call(this, this._arr[i], i, this)) {
  749.                       res._arr.push(this._arr[i]);
  750.                   }
  751.               }
  752.               return res;
  753.           });
  754.       }
  755.       map(fn) {
  756.           return __awaiter(this, void 0, void 0, function* () {
  757.               const res = new InnerAsyncArray();
  758.               for (let i = 0, len = this._arr.length; i < len; i++) {
  759.                   res._arr.push(yield fn.call(this, this._arr[i], i, this));
  760.               }
  761.               return res;
  762.           });
  763.       }
  764.       flatMap(fn) {
  765.           return __awaiter(this, void 0, void 0, function* () {
  766.               const res = new InnerAsyncArray();
  767.               for (let i = 0, len = this._arr.length; i < len; i++) {
  768.                   res._arr.push(...(yield fn.call(this, this._arr[i], i, this)));
  769.               }
  770.               return res;
  771.           });
  772.       }
  773.       reduce(fn, res) {
  774.           return __awaiter(this, void 0, void 0, function* () {
  775.               for (let i = 0, len = this._arr.length; i < len; i++) {
  776.                   if (res) {
  777.                       res = yield fn.call(this, res, this._arr[i], i, this);
  778.                   }
  779.                   else {
  780.                       res = this._arr[i];
  781.                   }
  782.               }
  783.               return res;
  784.           });
  785.       }
  786.       reduceRight(fn, res) {
  787.           return __awaiter(this, void 0, void 0, function* () {
  788.               for (let i = this._arr.length - 1; i >= 0; i--) {
  789.                   if (res) {
  790.                       res = yield fn.apply(this, [res, this._arr[i], i, this]);
  791.                   }
  792.                   else {
  793.                       res = this._arr[i];
  794.                   }
  795.               }
  796.               return res;
  797.           });
  798.       }
  799.       findIndex(fn) {
  800.           return __awaiter(this, void 0, void 0, function* () {
  801.               for (let i = 0, len = this._arr.length; i < len; i++) {
  802.                   const res = yield fn.call(this, this._arr[i], i, this);
  803.                   if (res) {
  804.                       return i;
  805.                   }
  806.               }
  807.               return -1;
  808.           });
  809.       }
  810.   }
  811.   /**
  812.    * 并发的异步数组
  813.    */
  814.   class InnerAsyncArrayParallel extends InnerBaseAsyncArray {
  815.       constructor(args) {
  816.           super(args);
  817.       }
  818.       forEach(fn) {
  819.           return __awaiter(this, void 0, void 0, function* () {
  820.               yield this._all(fn);
  821.           });
  822.       }
  823.       filter(fn) {
  824.           return __awaiter(this, void 0, void 0, function* () {
  825.               const res = yield this._all(fn);
  826.               const result = new InnerAsyncArrayParallel();
  827.               for (let i = 0, len = res.length; i < len; i++) {
  828.                   if (res[i]) {
  829.                       result._arr.push(this._arr[i]);
  830.                   }
  831.               }
  832.               return result;
  833.           });
  834.       }
  835.       map(fn) {
  836.           return __awaiter(this, void 0, void 0, function* () {
  837.               return new InnerAsyncArrayParallel(yield this._all(fn));
  838.           });
  839.       }
  840.       flatMap(fn) {
  841.           return __awaiter(this, void 0, void 0, function* () {
  842.               const res = yield this._all(fn);
  843.               return new InnerAsyncArrayParallel(res.flat());
  844.           });
  845.       }
  846.       sort(fn) {
  847.           throw new Error('Method not implemented.');
  848.       }
  849.       reduce(fn, res) {
  850.           return __awaiter(this, void 0, void 0, function* () {
  851.               for (let i = 0, len = this._arr.length; i < len; i++) {
  852.                   if (res) {
  853.                       res = yield fn.call(this, res, this._arr[i], i, this);
  854.                   }
  855.                   else {
  856.                       res = this._arr[i];
  857.                   }
  858.               }
  859.               return res;
  860.           });
  861.       }
  862.       reduceRight(fn, res) {
  863.           return __awaiter(this, void 0, void 0, function* () {
  864.               for (let i = this._arr.length - 1; i >= 0; i--) {
  865.                   if (res) {
  866.                       res = yield fn.apply(this, [res, this._arr[i], i, this]);
  867.                   }
  868.                   else {
  869.                       res = this._arr[i];
  870.                   }
  871.               }
  872.               return res;
  873.           });
  874.       }
  875.       findIndex(fn) {
  876.           return __awaiter(this, void 0, void 0, function* () {
  877.               return (yield this._all(fn)).findIndex(returnItself);
  878.           });
  879.       }
  880.       _all(fn) {
  881.           return __awaiter(this, void 0, void 0, function* () {
  882.               return yield Promise.all(this._arr.map((v, i) => fn.apply(this, [v, i, this])));
  883.           });
  884.       }
  885.   }
  886.   /**
  887.    * 异步数组
  888.    */
  889.   class AsyncArray {
  890.       /**
  891.        * 构造函数
  892.        * @param args 任意个参数
  893.        */
  894.       constructor(...args) {
  895.           /**
  896.            * 内部数组的长度，用于让 {@link AsyncArray} 的实例能作为 {@link Array.from} 的参数
  897.            */
  898.           this.length = 0;
  899.           this._arr = Array.from(args);
  900.           /**
  901.            * @field 保存异步任务
  902.            * @type {Action[]}
  903.            */
  904.           this._tasks = [];
  905.       }
  906.       /**
  907.        * 为内置数组赋值
  908.        * 此处自动重新计算 length 属性
  909.        */
  910.       set _arr(arr) {
  911.           this.__arr = arr;
  912.           this.length = this.__arr.length;
  913.       }
  914.       get _arr() {
  915.           return this.__arr;
  916.       }
  917.       /**
  918.        * 提供一个函数方便根据已有的数组或类数组（Set/Map）创建 {@link AsyncArray}
  919.        * @param arr 一个可迭代元素
  920.        * @returns 创建一个新的异步数组包装
  921.        */
  922.       static from(arr) {
  923.           const result = new AsyncArray();
  924.           if (isNullOrUndefined(arr)) {
  925.               return result;
  926.           }
  927.           result._arr = Array.from(arr);
  928.           return result;
  929.       }
  930.       filter(fn) {
  931.           return this._addTask(new Action(Action.Type.filter, [fn]));
  932.       }
  933.       map(fn) {
  934.           return this._addTask(new Action(Action.Type.map, [fn]));
  935.       }
  936.       flatMap(fn) {
  937.           return this._addTask(new Action(Action.Type.flatMap, [fn]));
  938.       }
  939.       sort(fn) {
  940.           return this._addTask(new Action(Action.Type.sort, [fn]));
  941.       }
  942.       parallel() {
  943.           return this._addTask(new Action(Action.Type.parallel, []));
  944.       }
  945.       serial() {
  946.           return this._addTask(new Action(Action.Type.serial, []));
  947.       }
  948.       forEach(fn) {
  949.           return this._addTask(new Action(Action.Type.forEach, [fn])).then();
  950.       }
  951.       some(fn) {
  952.           return this._addTask(new Action(Action.Type.some, [fn])).then();
  953.       }
  954.       every(fn) {
  955.           return this._addTask(new Action(Action.Type.every, [fn])).then();
  956.       }
  957.       find(fn) {
  958.           return this._addTask(new Action(Action.Type.find, [fn])).then();
  959.       }
  960.       findIndex(fn) {
  961.           return this._addTask(new Action(Action.Type.findIndex, [fn])).then();
  962.       }
  963.       reduce(fn, res) {
  964.           return this._addTask(new Action(Action.Type.reduce, [fn, res])).then();
  965.       }
  966.       reduceRight(fn, res) {
  967.           return this._addTask(new Action(Action.Type.reduceRight, [fn, res])).then();
  968.       }
  969.       /**
  970.        * 终结整个链式操作并返回结果，可以使用 await 等待当前实例开始计算
  971.        */
  972.       then(onfulfilled, onrejected) {
  973.           return __awaiter(this, void 0, void 0, function* () {
  974.               try {
  975.                   let asyncArray = new InnerAsyncArray(this._arr);
  976.                   let result = this._arr;
  977.                   for (const task of this._tasks) {
  978.                       asyncArray = yield Reflect.apply(Reflect.get(asyncArray, task.type), asyncArray, task.args);
  979.                       if (asyncArray instanceof InnerBaseAsyncArray) {
  980.                           result = asyncArray.value();
  981.                       }
  982.                       else {
  983.                           if (!isNullOrUndefined(onfulfilled)) {
  984.                               onfulfilled(result);
  985.                           }
  986.                           return asyncArray;
  987.                       }
  988.                   }
  989.                   if (!isNullOrUndefined(onfulfilled)) {
  990.                       onfulfilled(result);
  991.                   }
  992.                   return result;
  993.               }
  994.               catch (err) {
  995.                   if (!isNullOrUndefined(onrejected)) {
  996.                       onrejected(err);
  997.                   }
  998.               }
  999.           });
  1000.       }
  1001.       /**
  1002.        * @deprecated 已废弃，请直接使用 await 进行等待获取结果值即可
  1003.        */
  1004.       value() {
  1005.           return this.then();
  1006.       }
  1007.       /**
  1008.        * 允许使用 for-of 遍历内部的 _arr
  1009.        */
  1010.       *[Symbol.iterator]() {
  1011.           for (const kv of this._arr) {
  1012.               yield kv;
  1013.           }
  1014.       }
  1015.       _addTask(task) {
  1016.           const result = new AsyncArray(...this._arr);
  1017.           result._tasks = [...this._tasks, task];
  1018.           return result;
  1019.       }
  1020.   }
  1021.  
  1022.   function asyncFlatMap(arr, fn) {
  1023.       return __awaiter(this, void 0, void 0, function* () {
  1024.           return new AsyncArray(...arr).flatMap(fn);
  1025.       });
  1026.   }
  1027.  
  1028.   /**
  1029.    * 校验变量的类型
  1030.    */
  1031.   class TypeValidator {
  1032.       /**
  1033.        * 判断是否为字符串
  1034.        * @param val 需要判断的值
  1035.        * @returns 是否为字符串
  1036.        */
  1037.       static isString(val) {
  1038.           return typeof val === 'string';
  1039.       }
  1040.       /**
  1041.        * 判断是否为数字
  1042.        * @param val 需要判断的值
  1043.        * @returns 是否为数字
  1044.        */
  1045.       static isNumber(val) {
  1046.           return typeof val === 'number';
  1047.       }
  1048.       /**
  1049.        * 判断是否为布尔值
  1050.        * @param val 需要判断的值
  1051.        * @returns 是否为布尔值
  1052.        */
  1053.       static isBoolean(val) {
  1054.           return typeof val === 'boolean';
  1055.       }
  1056.       /**
  1057.        * 判断是否为 undefined
  1058.        * @param val 需要判断的值
  1059.        * @returns 是否为 undefined
  1060.        */
  1061.       static isUndefined(val) {
  1062.           return val === undefined;
  1063.       }
  1064.       /**
  1065.        * 判断是否为 null
  1066.        * @param val 需要判断的值
  1067.        * @returns 是否为 null
  1068.        */
  1069.       static isNull(val) {
  1070.           return val === null;
  1071.       }
  1072.       /**
  1073.        * 判断是否为 Symbol
  1074.        * @param val 需要判断的值
  1075.        * @returns 是否为 Symbol
  1076.        */
  1077.       static isSymbol(val) {
  1078.           return typeof val === 'symbol';
  1079.       }
  1080.       /**
  1081.        * 判断是否可以作为对象的属性
  1082.        * @param val 需要判断的值
  1083.        * @returns 是否为对象属性
  1084.        */
  1085.       static isPropertyKey(val) {
  1086.           return (TypeValidator.isString(val) ||
  1087.               TypeValidator.isNumber(val) ||
  1088.               TypeValidator.isSymbol(val));
  1089.       }
  1090.       /**
  1091.        * 判断是否为对象
  1092.        * 注: 函数（包括 ES6 箭头函数）将不被视为对象
  1093.        * @param val 需要判断的值
  1094.        * @returns 是否为对象
  1095.        */
  1096.       static isObject(val) {
  1097.           return (!TypeValidator.isNull(val) &&
  1098.               !TypeValidator.isUndefined(val) &&
  1099.               typeof val === 'object');
  1100.       }
  1101.       /**
  1102.        * 判断是否为数组
  1103.        * @param val 需要判断的值
  1104.        * @returns 是否为数组
  1105.        */
  1106.       static isArray(val) {
  1107.           return Array.isArray(val);
  1108.       }
  1109.       /**
  1110.        * 判断是否为数组
  1111.        * @param val 需要判断的值
  1112.        * @returns 是否为数组
  1113.        */
  1114.       static isFunction(val) {
  1115.           return toString.call(val) === '[object Function]';
  1116.       }
  1117.       /**
  1118.        * 判断是否为日期
  1119.        * @param val 需要判断的值
  1120.        * @returns 是否为日期
  1121.        */
  1122.       static isDate(val) {
  1123.           return toString.call(val) === '[object Date]';
  1124.       }
  1125.       /**
  1126.        * 判断是否为浏览器文件类型
  1127.        * @param val 需要判断的值
  1128.        * @returns 是否为浏览器文件类型
  1129.        */
  1130.       static isFile(val) {
  1131.           return toString.call(val) === '[object File]';
  1132.       }
  1133.       /**
  1134.        * 判断是否为浏览器二进制类型
  1135.        * @param val 需要判断的值
  1136.        * @returns 是否为浏览器二进制类型
  1137.        */
  1138.       static isBlob(val) {
  1139.           return toString.call(val) === '[object Blob]';
  1140.       }
  1141.       /**
  1142.        * 判断是否为浏览器流类型
  1143.        * @param val 需要判断的值
  1144.        * @returns 是否为浏览器流类型
  1145.        */
  1146.       static isStream(val) {
  1147.           return TypeValidator.isObject(val) && TypeValidator.isFunction(val.pipe);
  1148.       }
  1149.       /**
  1150.        * 判断是否为浏览器 ArrayBuffer 类型
  1151.        * @param val 需要判断的值
  1152.        * @returns 是否为浏览器 ArrayBuffer 类型
  1153.        */
  1154.       static isArrayBuffer(val) {
  1155.           return toString.call(val) === '[object ArrayBuffer]';
  1156.       }
  1157.       /**
  1158.        * 判断是否为浏览器 ArrayBufferView 类型
  1159.        * @param val 需要判断的值
  1160.        * @returns 是否为浏览器 ArrayBufferView 类型
  1161.        */
  1162.       static isArrayBufferView(val) {
  1163.           return typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView
  1164.               ? ArrayBuffer.isView(val)
  1165.               : val && val.buffer && val.buffer instanceof ArrayBuffer;
  1166.       }
  1167.       /**
  1168.        * 判断是否为浏览器 URLSearchParams 类型
  1169.        * @param val 需要判断的值
  1170.        * @returns 是否为浏览器 URLSearchParams 类型
  1171.        */
  1172.       static isURLSearchParams(val) {
  1173.           return !TypeValidator.isUndefined(val) && val instanceof URLSearchParams;
  1174.       }
  1175.       /**
  1176.        * 判断是否为浏览器 FormData 类型
  1177.        * @param val 需要判断的值
  1178.        * @returns 是否为浏览器 FormData 类型
  1179.        */
  1180.       static isFormData(val) {
  1181.           return !TypeValidator.isUndefined(val) && val instanceof FormData;
  1182.       }
  1183.   }
  1184.  
  1185.   /**
  1186.    * 安全执行某个函数
  1187.    * 支持异步函数
  1188.    * @param fn 需要执行的函数
  1189.    * @param defaultVal 发生异常后的默认返回值，默认为 null
  1190.    * @param args 可选的函数参数
  1191.    * @returns 函数执行的结果，或者其默认值
  1192.    */
  1193.   function safeExec(fn, defaultVal, ...args) {
  1194.       const defRes = (defaultVal === undefined ? null : defaultVal);
  1195.       try {
  1196.           const res = fn(...args);
  1197.           return res instanceof Promise ? res.catch(() => defRes) : res;
  1198.       }
  1199.       catch (err) {
  1200.           return defRes;
  1201.       }
  1202.   }
  1203.  
  1204.   /**
  1205.    * 提取对象中的字段并封装为函数
  1206.    * @param k 提取的字段，深度获取使用 . 分割不同的字段
  1207.    * @returns 获取对象中指定字段的函数
  1208.    */
  1209.   function extractField(k) {
  1210.       const fields = TypeValidator.isString(k) ? k.split('.') : [k];
  1211.       return fields.reduceRight((fn, field) => {
  1212.           return function (obj) {
  1213.               return safeExec(() => fn(Reflect.get(obj, field)));
  1214.           };
  1215.       }, returnItself);
  1216.   }
  1217.  
  1218.   /**
  1219.    * 获取提取对象属性的函数
  1220.    * @param k 提取对象属性的函数或者是属性名（允许使用 . 进行分割）
  1221.    * @returns 提取对象属性的函数
  1222.    */
  1223.   function getKFn(k) {
  1224.       return k instanceof Function ? k : extractField(k);
  1225.   }
  1226.  
  1227.   /**
  1228.    * 自行实现 flatMap，将数组压平一层
  1229.    * @param arr 数组
  1230.    * @param k 映射方法，将一个元素映射为一个数组
  1231.    * @returns 压平一层的数组
  1232.    */
  1233.   function flatMap(arr, k = (v) => Array.from(v)) {
  1234.       const fn = getKFn(k);
  1235.       return arr.reduce((res, v, i, arr) => {
  1236.           res.push(...fn(v, i, arr));
  1237.           return res;
  1238.       }, new Array());
  1239.   }
  1240.  
  1241.   function groupBy(arr, k, 
  1242.   /**
  1243.    * 默认的值处理函数
  1244.    * @param res 最终 V 集合
  1245.    * @param item 当前迭代的元素
  1246.    * @returns 将当前元素合并后的最终 V 集合
  1247.    */
  1248.   vFn = ((res, item) => {
  1249.       res.push(item);
  1250.       return res;
  1251.   }), init = () => []) {
  1252.       const kFn = getKFn(k);
  1253.       // 将元素按照分组条件进行分组得到一个 条件 -> 数组 的对象
  1254.       return arr.reduce((res, item, index, arr) => {
  1255.           const k = kFn(item, index, arr);
  1256.           // 如果已经有这个键了就直接追加, 否则先将之初始化再追加元素
  1257.           if (!res.has(k)) {
  1258.               res.set(k, init());
  1259.           }
  1260.           res.set(k, vFn(res.get(k), item, index, arr));
  1261.           return res;
  1262.       }, new Map());
  1263.   }
  1264.  
  1265.   /**
  1266.    * 创建一个等差数列数组
  1267.    * @param start 开始（包含）
  1268.    * @param end 结束（不包含）
  1269.    * @param sep 步长，默认为 1
  1270.    * @returns 等差数列数组
  1271.    */
  1272.   function range(start, end, sep = 1) {
  1273.       const arr = [];
  1274.       for (let i = start; i < end; i += sep) {
  1275.           arr.push(i);
  1276.       }
  1277.       return arr;
  1278.   }
  1279.  
  1280.   /**
  1281.    * 将数组转化为一个 Object 对象
  1282.    * @deprecated 已废弃，请使用更好的 {@link arrayToMap} 替代
  1283.    * @param arr 需要进行转换的数组
  1284.    * @param k 生成对象属性名的函数
  1285.    * @param v 生成对象属性值的函数，默认为数组中的迭代元素
  1286.    * @returns 转化得到的对象
  1287.    */
  1288.   function toObject(arr, k, v = returnItself) {
  1289.       const kFn = getKFn(k);
  1290.       const vFn = getKFn(v);
  1291.       return arr.reduce((res, item, i, arr) => {
  1292.           const k = kFn(item, i, arr);
  1293.           if (!Reflect.has(res, k)) {
  1294.               Reflect.set(res, k, vFn(item, i, arr));
  1295.           }
  1296.           return res;
  1297.       }, {});
  1298.   }
  1299.  
  1300.   /**
  1301.    * js 的数组去重方法
  1302.    * @param arr 要进行去重的数组
  1303.    * @param k 唯一标识元素的方法，默认使用 {@link returnItself}
  1304.    * @returns 进行去重操作之后得到的新的数组 (原数组并未改变)
  1305.    */
  1306.   function uniqueBy(arr, k = returnItself) {
  1307.       const kFn = getKFn(k);
  1308.       const set = new Set();
  1309.       return arr.filter((v, ...args) => {
  1310.           const k = kFn(v, ...args);
  1311.           if (set.has(k)) {
  1312.               return false;
  1313.           }
  1314.           set.add(k);
  1315.           return true;
  1316.       });
  1317.   }
  1318.  
  1319.   /**
  1320.    * 将数组映射为 Map
  1321.    * @param arr 数组
  1322.    * @param k 产生 Map 元素唯一标识的函数，或者对象元素中的一个属性名
  1323.    * @param v 产生 Map 值的函数，默认为返回数组的元素，或者对象元素中的一个属性名
  1324.    * @returns 映射产生的 map 集合
  1325.    */
  1326.   function arrayToMap(arr, k, v = returnItself) {
  1327.       const kFn = getKFn(k);
  1328.       const vFn = getKFn(v);
  1329.       return arr.reduce((res, item, index, arr) => res.set(kFn(item, index, arr), vFn(item, index, arr)), new Map());
  1330.   }
  1331.  
  1332.   /**
  1333.    * 判断数字是否在指定区间之中
  1334.    * @param num 指定数字
  1335.    * @param min 最小值
  1336.    * @param max 最大值（不包含）
  1337.    */
  1338.   function isRange(num, min, max) {
  1339.       return num >= min && num < max;
  1340.   }
  1341.  
  1342.   /**
  1343.    * 日期格式化类
  1344.    */
  1345.   class DateFormat {
  1346.       /**
  1347.        * 构造函数
  1348.        * @param name 日期格式的名称
  1349.        * @param format 日期的格式值
  1350.        * @param value 格式化得到的值
  1351.        * @param index 需要替换位置的索引
  1352.        */
  1353.       constructor(name, format, value, index) {
  1354.           this.name = name;
  1355.           this.format = format;
  1356.           this.value = value;
  1357.           this.index = index;
  1358.       }
  1359.   }
  1360.   /**
  1361.    * 日期时间的正则表达式
  1362.    */
  1363.   const dateFormats = new Map()
  1364.       .set('year', 'Y{4}|Y{2}|y{4}|y{2}')
  1365.       .set('month', 'M{1,2}')
  1366.       .set('day', 'D{1,2}|d{1,2}')
  1367.       .set('hour', 'h{1,2}')
  1368.       .set('minute', 'm{1,2}')
  1369.       .set('second', 's{1,2}')
  1370.       .set('millieSecond', 'S{1,3}');
  1371.   /**
  1372.    * 如果没有格式化某项的话则设置为默认时间
  1373.    */
  1374.   const defaultDateValues = new Map()
  1375.       .set('month', '01')
  1376.       .set('day', '01')
  1377.       .set('hour', '00')
  1378.       .set('minute', '00')
  1379.       .set('second', '00')
  1380.       .set('millieSecond', '000');
  1381.   /**
  1382.    * 月份日期校验
  1383.    */
  1384.   const monthDayValidate = {
  1385.       1: 31,
  1386.       3: 31,
  1387.       5: 31,
  1388.       7: 31,
  1389.       8: 31,
  1390.       10: 31,
  1391.       12: 31,
  1392.       4: 30,
  1393.       6: 30,
  1394.       9: 30,
  1395.       11: 30,
  1396.       2: 28,
  1397.   };
  1398.   /**
  1399.    * 解析字符串为 Date 对象
  1400.    * @param str 日期字符串
  1401.    * @param fmt 日期字符串的格式，目前仅支持使用 y(年),M(月),d(日),h(时),m(分),s(秒),S(毫秒)
  1402.    * @returns 解析得到的 Date 对象
  1403.    */
  1404.   function dateParse(str, fmt) {
  1405.       const now = new Date();
  1406.       defaultDateValues.set('year', now.getFullYear().toString());
  1407.       // 保存对传入的日期字符串进行格式化的全部信息数组列表
  1408.       const dateUnits = [];
  1409.       for (const [fmtName, regex] of dateFormats) {
  1410.           const regExp = new RegExp(regex);
  1411.           if (regExp.test(fmt)) {
  1412.               const matchStr = regExp.exec(fmt)[0];
  1413.               const regexStr = '`'.repeat(matchStr.length);
  1414.               const index = fmt.indexOf(matchStr);
  1415.               fmt = fmt.replace(matchStr, regexStr);
  1416.               dateUnits.push(new DateFormat(fmtName, '\\d'.repeat(matchStr.length), null, index));
  1417.           }
  1418.           else {
  1419.               dateUnits.push(new DateFormat(fmtName, null, defaultDateValues.get(fmtName), -1));
  1420.           }
  1421.       }
  1422.       // 进行验证是否真的是符合传入格式的字符串
  1423.       fmt = fmt.replace(new RegExp('`', 'g'), '\\d');
  1424.       if (!new RegExp(`^${fmt}$`).test(str)) {
  1425.           return null;
  1426.       }
  1427.       // 进行一次排序, 依次对字符串进行截取
  1428.       dateUnits
  1429.           // 过滤掉没有得到格式化的对象
  1430.           .filter(({ format }) => format)
  1431.           // 按照字符串中日期片段的索引进行排序
  1432.           .sort(function (a, b) {
  1433.           return a.index - b.index;
  1434.       })
  1435.           // 获取到匹配的日期片段的值
  1436.           .map(format => {
  1437.           const matchDateUnit = new RegExp(format.format).exec(str);
  1438.           if (matchDateUnit !== null && matchDateUnit.length > 0) {
  1439.               str = str.replace(matchDateUnit[0], '');
  1440.               format.value = matchDateUnit[0];
  1441.           }
  1442.           return format;
  1443.       })
  1444.           // 覆写到 dateStr 上面
  1445.           .forEach(({ format }, i) => {
  1446.           const matchDateUnit = new RegExp(format).exec(str);
  1447.           if (matchDateUnit !== null && matchDateUnit.length > 0) {
  1448.               str = str.replace(matchDateUnit[0], '');
  1449.               dateUnits[i].value = matchDateUnit[0];
  1450.           }
  1451.       });
  1452.       // 将截取完成的信息封装成对象并格式化标准的日期字符串
  1453.       const map = arrayToMap(dateUnits, item => item.name, item => item.value);
  1454.       if (map.get('year').length === 2) {
  1455.           map.set('year', defaultDateValues
  1456.               .get('year')
  1457.               .substr(0, 2)
  1458.               .concat(map.get('year')));
  1459.       }
  1460.       // 注意：此处使用的是本地时间而非 UTC 时间
  1461.       const get = (unit) => parseInt(map.get(unit));
  1462.       const year = get('year');
  1463.       const month = get('month');
  1464.       const day = get('day');
  1465.       const hour = get('hour');
  1466.       const minute = get('minute');
  1467.       const second = get('second');
  1468.       const millieSecond = get('millieSecond');
  1469.       if (!isRange(month, 1, 12 + 1)) {
  1470.           return null;
  1471.       }
  1472.       if (!isRange(day, 1, Reflect.get(monthDayValidate, month) +
  1473.           (month === 2 && year % 4 === 0 ? 1 : 0) +
  1474.           1)) {
  1475.           return null;
  1476.       }
  1477.       if (!isRange(hour, 0, 24 + 1) ||
  1478.           !isRange(minute, 0, 60 + 1) ||
  1479.           !isRange(second, 0, 60 + 1) ||
  1480.           !isRange(millieSecond, 0, 999 + 1)) {
  1481.           return null;
  1482.       }
  1483.       return new Date(year, month - 1, day, hour, minute, second, millieSecond);
  1484.   }
  1485.  
  1486.   /**
  1487.    * 解析字符串为 Date 对象
  1488.    * @deprecated 已弃用，请使用可读性更好的 {@link dateParse} 代替
  1489.    * @param dateStr 日期字符串
  1490.    * @param fmt 日期字符串的格式
  1491.    * 目前仅支持使用 y(年),M(月),d(日),h(时),m(分),s(秒),S(毫秒)
  1492.    * @returns 解析得到的 Date 对象
  1493.    */
  1494.   function strToDate(dateStr, fmt) {
  1495.       return dateParse(dateStr, fmt);
  1496.   }
  1497.  
  1498.   /**
  1499.    * 复制一段文本内容
  1500.    * @param text 要进行复制的文本
  1501.    * @returns 是否复制成功
  1502.    */
  1503.   function copyText(text) {
  1504.       const input = document.createElement('input');
  1505.       document.body.appendChild(input);
  1506.       input.setAttribute('value', text);
  1507.       input.select();
  1508.       const res = document.execCommand('copy');
  1509.       document.body.removeChild(input);
  1510.       return res;
  1511.   }
  1512.  
  1513.   /**
  1514.    * 根据 html 字符串创建 Element 元素
  1515.    * @param str html 字符串
  1516.    * @returns 创建的 Element 元素
  1517.    */
  1518.   function createElByString(str) {
  1519.       const root = document.createElement('div');
  1520.       root.innerHTML = str;
  1521.       return root.querySelector('*');
  1522.   }
  1523.  
  1524.   /**
  1525.    * 获取输入框中光标所在位置
  1526.    * @param  {HTMLFormElement} el 需要获取的输入框元素
  1527.    * @returns 光标所在位置的下标
  1528.    */
  1529.   function getCursorPosition(el) {
  1530.       return el.selectionStart;
  1531.   }
  1532.  
  1533.   /**
  1534.    * 获取输入框中光标所在位置
  1535.    * @param  {HTMLFormElement} el 需要获取的输入框元素
  1536.    * @returns 光标所在位置的下标
  1537.    * @deprecated 已废弃，请使用正确更名后的 {@link getCursorPosition} 函数
  1538.    */
  1539.   function getCusorPostion(el) {
  1540.       return getCursorPosition(el);
  1541.   }
  1542.  
  1543.   /**
  1544.    * 设置输入框中选中的文本/光标所在位置
  1545.    * @param el 需要设置的输入框元素
  1546.    * @param start 光标所在位置的下标
  1547.    * @param end 结束位置，默认为输入框结束
  1548.    */
  1549.   function setCursorPosition(el, start, end = start) {
  1550.       el.focus();
  1551.       el.setSelectionRange(start, end);
  1552.   }
  1553.  
  1554.   /**
  1555.    * 在指定位置后插入文本
  1556.    * @param el 需要设置的输入框元素
  1557.    * @param text 要插入的值
  1558.    * @param start 开始位置，默认为当前光标处
  1559.    */
  1560.   function insertText(el, text, start = getCursorPosition(el)) {
  1561.       const value = el.value;
  1562.       el.value = value.substr(0, start) + text + value.substr(start);
  1563.       setCursorPosition(el, start + text.length);
  1564.   }
  1565.  
  1566.   /**
  1567.    * 字符串安全的转换为小写
  1568.    * @param str 字符串
  1569.    * @returns 转换后得到的全小写字符串
  1570.    */
  1571.   function toLowerCase(str) {
  1572.       if (isNullOrUndefined(str) || typeof str !== 'string') {
  1573.           return str;
  1574.       }
  1575.       return str.toLowerCase();
  1576.   }
  1577.  
  1578.   /**
  1579.    * 判断指定元素是否是可编辑元素
  1580.    * 注：可编辑元素并不一定能够进行编辑，例如只读的 input 元素
  1581.    * @param el 需要进行判断的元素
  1582.    * @returns 是否为可编辑元素
  1583.    */
  1584.   function isEditable(el) {
  1585.       const inputEls = ['input', 'date', 'datetime', 'select', 'textarea'];
  1586.       return (
  1587.       // 此处需要判断是否存在属性 isContentEditable
  1588.       // @ts-ignore
  1589.       el && (el.isContentEditable || inputEls.includes(toLowerCase(el.tagName))));
  1590.   }
  1591.  
  1592.   let lastFocusEl;
  1593.   document.addEventListener('focus', event => {
  1594.       lastFocusEl = event.target;
  1595.   }, true);
  1596.   document.addEventListener('blur', () => {
  1597.       lastFocusEl = null;
  1598.   }, true);
  1599.   /**
  1600.    * 获取到最后一个获得焦点的元素
  1601.    * @returns 最后一个获取到焦点的元素
  1602.    */
  1603.   function lastFocus() {
  1604.       return lastFocusEl;
  1605.   }
  1606.  
  1607.   /**
  1608.    * 直接删除指定元素
  1609.    * @param el 需要删除的元素
  1610.    * @returns 返回被删除的元素
  1611.    */
  1612.   function removeEl(el) {
  1613.       const parent = el.parentElement;
  1614.       if (parent == null) {
  1615.           return null;
  1616.       }
  1617.       return parent.removeChild(el);
  1618.   }
  1619.  
  1620.   /**
  1621.    * 在指定范围内删除文本
  1622.    * @param el 需要设置的输入框元素
  1623.    * @param start 开始位置，默认为当前选中开始位置
  1624.    * @param end 结束位置，默认为当前选中结束位置
  1625.    */
  1626.   function removeText(el, start = el.selectionStart, end = el.selectionEnd) {
  1627.       // 删除之前必须要 [记住] 当前光标的位置
  1628.       const index = getCursorPosition(el);
  1629.       const value = el.value;
  1630.       el.value = value.substr(0, start) + value.substr(end, value.length);
  1631.       setCursorPosition(el, index);
  1632.   }
  1633.  
  1634.   /**
  1635.    * 设置输入框中选中的文本/光标所在位置
  1636.    * @param el 需要设置的输入框元素
  1637.    * @param start 光标所在位置的下标
  1638.    * @param end 结束位置，默认为输入框结束
  1639.    * @deprecated 已废弃，请使用正确更名后的 {@link setCursorPosition} 函数
  1640.    */
  1641.   function setCusorPostion(el, start, end = start) {
  1642.       return setCursorPosition(el, start, end);
  1643.   }
  1644.  
  1645.   /**
  1646.    * 监听 event 的添加/删除，使 DOM 事件是可撤销的
  1647.    * 注：必须及早运行，否则无法监听之前添加的事件
  1648.    */
  1649.   function watchEventListener() {
  1650.       /**
  1651.        * 用来保存监听到的事件信息
  1652.        */
  1653.       class Event {
  1654.           constructor(el, type, listener, useCapture) {
  1655.               this.el = el;
  1656.               this.type = type;
  1657.               this.listener = listener;
  1658.               this.useCapture = useCapture;
  1659.           }
  1660.       }
  1661.       /**
  1662.        * 监听所有的 addEventListener, removeEventListener 事件
  1663.        */
  1664.       const documentAddEventListener = document.addEventListener;
  1665.       const eventTargetAddEventListener = EventTarget.prototype.addEventListener;
  1666.       const documentRemoveEventListener = document.removeEventListener;
  1667.       const eventTargetRemoveEventListener = EventTarget.prototype.removeEventListener;
  1668.       const events = [];
  1669.       /**
  1670.        * 自定义的添加事件监听函数
  1671.        * @param type 事件类型
  1672.        * @param listener 事件监听函数
  1673.        * @param [useCapture] 是否需要捕获事件冒泡，默认为 false
  1674.        */
  1675.       function addEventListener(type, listener, useCapture = false) {
  1676.           const $addEventListener = 
  1677.           // @ts-ignore
  1678.           this === document ? documentAddEventListener : eventTargetAddEventListener;
  1679.           // @ts-ignore
  1680.           events.push(new Event(this, type, listener, useCapture));
  1681.           // @ts-ignore
  1682.           $addEventListener.apply(this, arguments);
  1683.       }
  1684.       /**
  1685.        * 自定义的根据类型删除事件函数
  1686.        * 该方法会删除这个类型下面全部的监听函数，不管数量
  1687.        * @param type 事件类型
  1688.        */
  1689.       function removeEventListenerByType(type) {
  1690.           const $removeEventListener = 
  1691.           // @ts-ignore
  1692.           this === document
  1693.               ? documentRemoveEventListener
  1694.               : eventTargetRemoveEventListener;
  1695.           const removeIndexList = events
  1696.               // @ts-ignore
  1697.               .map((e, i) => (e.el === this || e.type === arguments[0] ? i : -1))
  1698.               .filter(i => i !== -1);
  1699.           removeIndexList.forEach(i => {
  1700.               const e = events[i];
  1701.               $removeEventListener.apply(e.el, [e.type, e.listener, e.useCapture]);
  1702.           });
  1703.           removeIndexList.sort((a, b) => b - a).forEach(i => events.splice(i, 1));
  1704.       }
  1705.       document.addEventListener = EventTarget.prototype.addEventListener = addEventListener;
  1706.       // @ts-ignore
  1707.       document.removeEventListenerByType = EventTarget.prototype.removeEventListenerByType = removeEventListenerByType;
  1708.   }
  1709.  
  1710.   /**
  1711.    * 将任意对象转换为 String
  1712.    * 主要避免原生 Object toString 遇到某些空值的时候抛异常的问题
  1713.    * @param object 任意对象
  1714.    * @returns 字符串
  1715.    */
  1716.   function toString$1(object) {
  1717.       if (isNullOrUndefined(object)) {
  1718.           return '';
  1719.       }
  1720.       if (object instanceof Date) {
  1721.           return object.toISOString();
  1722.       }
  1723.       return object.toString();
  1724.   }
  1725.  
  1726.   /**
  1727.    * FormData 批量添加方法
  1728.    * 注：该方法不会覆盖掉原本的属性
  1729.    * @param fd FormData 对象
  1730.    * @param obj 键值对对象
  1731.    * @returns 添加完成后的 FormData 对象
  1732.    */
  1733.   function appends(fd, obj) {
  1734.       for (const k in obj) {
  1735.           const v = obj[k];
  1736.           fd.append(k, toString$1(v));
  1737.       }
  1738.       return fd;
  1739.   }
  1740.  
  1741.   /**
  1742.    * FormData 批量删除方法
  1743.    * @param fd FormData 对象
  1744.    * @param keys  删除的 key 列表
  1745.    * @returns 返回删除后的 FormData 对象
  1746.    */
  1747.   function deletes(fd, keys) {
  1748.       keys.forEach(key => fd.delete(key));
  1749.       return fd;
  1750.   }
  1751.  
  1752.   /**
  1753.    * FormData 批量设置方法
  1754.    * 注：该方法会覆盖掉原本的属性
  1755.    * @param fd 表单对象
  1756.    * @param obj 键值对对象
  1757.    * @returns 设置完成后的 FormData 对象
  1758.    */
  1759.   function sets(fd, obj) {
  1760.       for (const k in obj) {
  1761.           fd.set(k, obj[k]);
  1762.       }
  1763.       return fd;
  1764.   }
  1765.  
  1766.   /**
  1767.    * FormData 转换为包含所有键值数组的二维数组函数
  1768.    *
  1769.    * @param fd 需要转换的 FormData 对象
  1770.    * @returns 转换后的数组
  1771.    * @deprecated 已被原生函数 Array.from 取代
  1772.    */
  1773.   function formDataToArray(fd) {
  1774.       // @ts-ignore
  1775.       return Array.from(fd);
  1776.   }
  1777.  
  1778.   /**
  1779.    * 将参数对象转换为 FormData，只转换一层
  1780.    * @param data 参数对象
  1781.    * @return {FormData} 转换后的表单对象
  1782.    */
  1783.   function objToFormData(data) {
  1784.       return Object.entries(data).reduce((res, [k, v]) => {
  1785.           if (v instanceof Blob) {
  1786.               res.append(k, v);
  1787.           }
  1788.           else {
  1789.               res.append(k, v && v.toString());
  1790.           }
  1791.           return res;
  1792.       }, new FormData());
  1793.   }
  1794.  
  1795.   /**
  1796.    * 函数去抖
  1797.    * 去抖 (debounce) 去抖就是对于一定时间段的连续的函数调用，只让其执行一次
  1798.    * 注: 包装后的函数如果两次操作间隔小于 delay 则不会被执行, 如果一直在操作就会一直不执行, 直到操作停止的时间大于 delay 最小间隔时间才会执行一次, 不管任何时间调用都需要停止操作等待最小延迟时间
  1799.    * 应用场景主要在那些连续的操作, 例如页面滚动监听, 包装后的函数只会执行最后一次
  1800.    * 注: 该函数第一次调用一定不会执行，第一次一定拿不到缓存值，后面的连续调用都会拿到上一次的缓存值。如果需要在第一次调用获取到的缓存值，则需要传入第三个参数 {@param init}，默认为 {@code undefined} 的可选参数
  1801.    * 注: 返回函数结果的高阶函数需要使用 {@see Proxy} 实现，以避免原函数原型链上的信息丢失
  1802.    *
  1803.    * @param delay 最小延迟时间，单位为 ms
  1804.    * @param action 真正需要执行的操作
  1805.    * @param init 初始的缓存值，不填默认为 {@see undefined}
  1806.    * @return 包装后有去抖功能的函数。该函数是异步的，与需要包装的函数 {@see action} 是否异步没有太大关联
  1807.    */
  1808.   function debounce(delay, action, init = null) {
  1809.       let flag;
  1810.       let result = init;
  1811.       return new Proxy(action, {
  1812.           apply(_, _this, args) {
  1813.               return new Promise(resolve => {
  1814.                   if (flag)
  1815.                       clearTimeout(flag);
  1816.                   flag = setTimeout(() => resolve((result = Reflect.apply(_, _this, args))), delay);
  1817.                   setTimeout(() => resolve(result), delay);
  1818.               });
  1819.           },
  1820.       });
  1821.   }
  1822.  
  1823.   /**
  1824.    * 使用 Proxy 实现通用的单例模式
  1825.    * @param clazz 需要包装为单例的类型
  1826.    * @returns 包装后的单例模式类，使用 {@code new} 创建将只在第一次有效
  1827.    */
  1828.   function singleModel(clazz) {
  1829.       let instance;
  1830.       return new Proxy(clazz, {
  1831.           construct(target, args, newTarget) {
  1832.               if (instance === undefined) {
  1833.                   instance = Reflect.construct(target, args, newTarget);
  1834.               }
  1835.               return instance;
  1836.           },
  1837.       });
  1838.   }
  1839.  
  1840.   /**
  1841.    * 状态机
  1842.    * 用于避免使用 if-else 的一种方式
  1843.    * @typeparam K 状态的类型，默认为 any
  1844.    * @typeparam V 构造函数返回值的类型，一般为实现子类的基类，默认为 any
  1845.    * @deprecated 该类将在下个大版本进行重构，使用函数而非类作为基本单元
  1846.    */
  1847.   class StateMachine {
  1848.       constructor() {
  1849.           this.classMap = new Map();
  1850.       }
  1851.       /**
  1852.        * 获取到一个状态工厂
  1853.        * @deprecated 已废弃，请直接创建一个 StateMachine 实例
  1854.        */
  1855.       static getFactory() {
  1856.           /**
  1857.            * 状态注册器
  1858.            * 更好的有限状态机，分离子类与构建的关系，无论子类如何增删该都不影响基类及工厂类
  1859.            */
  1860.           return new StateMachine();
  1861.       }
  1862.       /**
  1863.        * 注册一个 class，创建子类时调用，用于记录每一个 [状态 => 子类] 对应
  1864.        * 注: 此处不再默认使用单例模式，如果需要，请自行对 class 进行包装
  1865.        * @param state 作为键的状态
  1866.        * @param clazz 对应的子类型
  1867.        * @returns 返回 clazz 本身
  1868.        */
  1869.       register(state, clazz) {
  1870.           this.classMap.set(state, clazz);
  1871.           return clazz;
  1872.       }
  1873.       /**
  1874.        * 获取一个标签子类对象
  1875.        * @param state 状态索引
  1876.        * @param args 构造函数的参数
  1877.        * @returns 子类对象
  1878.        */
  1879.       getInstance(state, ...args) {
  1880.           const Class = this.classMap.get(state);
  1881.           if (!Class) {
  1882.               return null;
  1883.           }
  1884.           // 构造函数的参数
  1885.           return new Class(...args);
  1886.       }
  1887.       /**
  1888.        * 允许使用 for-of 遍历整个状态机
  1889.        */
  1890.       *[Symbol.iterator]() {
  1891.           for (const kv of this.classMap.entries()) {
  1892.               yield kv;
  1893.           }
  1894.       }
  1895.   }
  1896.  
  1897.   /**
  1898.    * 函数节流
  1899.    * 节流 (throttle) 让一个函数不要执行的太频繁，减少执行过快的调用，叫节流
  1900.    * 类似于上面而又不同于上面的函数去抖, 包装后函数在上一次操作执行过去了最小间隔时间后会直接执行, 否则会忽略该次操作
  1901.    * 与上面函数去抖的明显区别在连续操作时会按照最小间隔时间循环执行操作, 而非仅执行最后一次操作
  1902.    * 注: 该函数第一次调用一定会执行，不需要担心第一次拿不到缓存值，后面的连续调用都会拿到上一次的缓存值
  1903.    * 注: 返回函数结果的高阶函数需要使用 {@see Proxy} 实现，以避免原函数原型链上的信息丢失
  1904.    *
  1905.    * @param delay 最小间隔时间，单位为 ms
  1906.    * @param action 真正需要执行的操作
  1907.    * @return {Function} 包装后有节流功能的函数。该函数是异步的，与需要包装的函数 {@link action} 是否异步没有太大关联
  1908.    */
  1909.   function throttle(delay, action) {
  1910.       let last = 0;
  1911.       let result;
  1912.       return new Proxy(action, {
  1913.           apply(target, thisArg, args) {
  1914.               return new Promise(resolve => {
  1915.                   const curr = Date.now();
  1916.                   if (curr - last > delay) {
  1917.                       result = Reflect.apply(target, thisArg, args);
  1918.                       last = curr;
  1919.                       resolve(result);
  1920.                       return;
  1921.                   }
  1922.                   resolve(result);
  1923.               });
  1924.           },
  1925.       });
  1926.   }
  1927.  
  1928.   /**
  1929.    * 测试函数的执行时间
  1930.    * 注：如果函数返回 Promise，则该函数也会返回 Promise，否则直接返回执行时间
  1931.    * @param fn 需要测试的函数
  1932.    * @returns 执行的毫秒数
  1933.    */
  1934.   function timing(fn) {
  1935.       const begin = performance.now();
  1936.       const res = fn();
  1937.       return compatibleAsync(res, () => performance.now() - begin);
  1938.   }
  1939.  
  1940.   /**
  1941.    * 轮询等待指定资源加载完毕再执行操作
  1942.    * 使用 Promises 实现，可以使用 ES7 的 {@see async} 和 {@see await} 调用
  1943.    * @param fn 判断必须的资源是否存在的方法
  1944.    * @param option 可配置项
  1945.    * @returns Promise 对象
  1946.    */
  1947.   function waitResource(fn, { interval = 100, max = 10 } = {}) {
  1948.       let current = 0;
  1949.       return new Promise((resolve, reject) => {
  1950.           const timer = setInterval(() => {
  1951.               if (fn()) {
  1952.                   clearInterval(timer);
  1953.                   resolve();
  1954.               }
  1955.               current++;
  1956.               if (current >= max) {
  1957.                   clearInterval(timer);
  1958.                   reject(new Error('waitResource call timeout'));
  1959.               }
  1960.           }, interval);
  1961.       });
  1962.   }
  1963.  
  1964.   /**
  1965.    * 监视指定函数返回值的变化
  1966.    * @param fn 需要监视的函数
  1967.    * @param callback 回调函数
  1968.    * @param interval 每次检查的间隔时间，默认为 100ms
  1969.    * @returns 关闭这个监视函数
  1970.    */
  1971.   function watch(fn, callback, interval = 100) {
  1972.       let oldVal = fn();
  1973.       const timer = setInterval(() => {
  1974.           const newVal = fn();
  1975.           if (oldVal !== newVal) {
  1976.               callback(newVal, oldVal);
  1977.               oldVal = newVal;
  1978.           }
  1979.       }, interval);
  1980.       return () => clearInterval(timer);
  1981.   }
  1982.  
  1983.   /**
  1984.    * 深度监听指定对象属性的变化
  1985.    * 注：指定对象不能是原始类型，即不可变类型，而且对象本身的引用不能改变，最好使用 const 进行声明
  1986.    * @param object 需要监视的对象
  1987.    * @param callback 当代理对象发生改变时的回调函数，回调函数有三个参数，分别是对象，修改的 key，修改的 v
  1988.    * @returns 返回源对象的一个代理
  1989.    */
  1990.   function watchObject(object, callback) {
  1991.       const handler = {
  1992.           get(target, k) {
  1993.               try {
  1994.                   // 注意: 这里很关键，它为对象的字段也添加了代理
  1995.                   return new Proxy(Reflect.get(target, k), handler);
  1996.               }
  1997.               catch (err) {
  1998.                   return Reflect.get(target, k);
  1999.               }
  2000.           },
  2001.           set(target, k, v) {
  2002.               callback(target, k, v);
  2003.               return Reflect.set(target, k, v);
  2004.           },
  2005.       };
  2006.       return new Proxy(object, handler);
  2007.   }
  2008.  
  2009.   /**
  2010.    * 填充字符串到指定长度
  2011.    * @param item 填充的字符串
  2012.    * @param len 填充的长度
  2013.    * @returns 填充完成的字符串
  2014.    * @deprecated 已废弃，请使用 ES6 {@link String.prototype.repeat} 函数
  2015.    * 具体请参考 MDN {@url(https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/repeat)}
  2016.    */
  2017.   function fill(item, len) {
  2018.       if (len <= 0) {
  2019.           return '';
  2020.       }
  2021.       return item + fill(item, len - 1);
  2022.   }
  2023.  
  2024.   /**
  2025.    * 字符串格式化
  2026.    *
  2027.    * @param str 要进行格式化的值
  2028.    * @param args 格式化参数值，替换字符串中的 {} 的值
  2029.    * @returns 替换完成的字符串
  2030.    * @deprecated 已废弃，请使用 ES6 模板字符串 {@url(https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/template_strings)}
  2031.    */
  2032.   function format(str, args) {
  2033.       return Object.keys(args).reduce((res, k) => res.replace(new RegExp(`{${k}}`, 'g'), toString$1(args[k])), str);
  2034.   }
  2035.  
  2036.   /**
  2037.    * 判断是否为小数的正则表达式
  2038.    */
  2039.   const FloatRule = /^(-?\d+)(.\d+)?$/;
  2040.   /**
  2041.    * 判断是否为整数的正则表达式
  2042.    */
  2043.   const IntegerRule = /^-?\d+$/;
  2044.   /**
  2045.    * 判断是否为邮箱的正则表达式
  2046.    */
  2047.   const EmailRule = /^\w+((-\w+)|(\.\w+))*@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z]+$/;
  2048.   /**
  2049.    * 判断是否为 ipv4 地址的正则表达式
  2050.    */
  2051.   const Ipv4Rule = /^((25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(25[0-5]|2[0-4]\d|1?\d?\d)$/;
  2052.   /**
  2053.    * 判断是否为固定电话的正则表达式
  2054.    */
  2055.   const TelephoneRule = /^0[1-9][0-9]{1,2}-[2-8][0-9]{6,7}$/;
  2056.   /**
  2057.    * 判断是否为移动电话的正则表达式
  2058.    */
  2059.   const MobileRule = /^(((13[0-9]{1})|15[0-9]{1}|18[0-9]{1}|)+\d{8})$/;
  2060.   /**
  2061.    * 判断是否为域名的正则表达式
  2062.    */
  2063.   const DomainRule = /^(?=^.{3,255}$)[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+$/;
  2064.   /**
  2065.    * 判断是否为邮政编码的正则表达式
  2066.    */
  2067.   const PostcodeRule = /^\d{6}$/;
  2068.   /**
  2069.    * 字符串校验
  2070.    * TODO 使用 any 可能是个严重的错误。。。
  2071.    */
  2072.   class StringValidator {
  2073.       /**
  2074.        * 判断一个字符串是否为空字符串
  2075.        * @param str 字符串
  2076.        * @returns 是否为空字符串
  2077.        */
  2078.       static isEmpty(str) {
  2079.           return isNullOrUndefined(str) || str === '';
  2080.       }
  2081.       /**
  2082.        * 判断一个字符串是否为空白的字符串
  2083.        * @param str 字符串
  2084.        * @returns 是否为空字符串
  2085.        */
  2086.       static isBlank(str) {
  2087.           return StringValidator.isEmpty(str) || str.trim() === '';
  2088.       }
  2089.       /**
  2090.        * 判断字符串是否位小数
  2091.        * @param str 需要进行判断的字符串
  2092.        * @returns 是否为小数
  2093.        */
  2094.       static isFloat(str) {
  2095.           if (isNullOrUndefined(str)) {
  2096.               return false;
  2097.           }
  2098.           return FloatRule.test(str);
  2099.       }
  2100.       /**
  2101.        * 判断字符串是否位整数
  2102.        * @param str 需要进行判断的字符串
  2103.        * @returns 是否为小数
  2104.        */
  2105.       static isInteger(str) {
  2106.           return !isNullOrUndefined(str) && IntegerRule.test(str);
  2107.       }
  2108.       /**
  2109.        * 判断邮箱的格式是否正确
  2110.        * @param str 邮箱字符串
  2111.        * @returns 是否是邮箱
  2112.        */
  2113.       static isEmail(str) {
  2114.           return !isNullOrUndefined(str) && EmailRule.test(str);
  2115.       }
  2116.       /**
  2117.        * 判断 ipv4 地址的格式是否正确
  2118.        * @param str ipv4 字符串
  2119.        * @returns 是否是 ipv4 地址
  2120.        */
  2121.       static isIpv4(str) {
  2122.           return !isNullOrUndefined(str) && Ipv4Rule.test(str);
  2123.       }
  2124.       /**
  2125.        * 判断字符串是否为正确的端口号
  2126.        * 正确的端口号是 1-65535
  2127.        * @param str 字符串
  2128.        * @returns 是否为端口号
  2129.        */
  2130.       static isPort(str) {
  2131.           // tslint:disable-next-line:radix
  2132.           return StringValidator.isInteger(str) && isRange(parseInt(str), 1, 65535);
  2133.       }
  2134.       /**
  2135.        * 判断是否为固定电话
  2136.        * @param str 字符串
  2137.        * @returns 是否为固定电话
  2138.        */
  2139.       static isTelephone(str) {
  2140.           return !isNullOrUndefined(str) && TelephoneRule.test(str);
  2141.       }
  2142.       /**
  2143.        * 判断是否为移动电话
  2144.        * @param str 字符串
  2145.        * @returns 是否为移动电话
  2146.        */
  2147.       static isMobile(str) {
  2148.           return !isNullOrUndefined(str) && MobileRule.test(str);
  2149.       }
  2150.       /**
  2151.        * 判断是否为域名
  2152.        * @param str 字符串
  2153.        * @returns 是否为域名
  2154.        */
  2155.       static isDomain(str) {
  2156.           return !isNullOrUndefined(str) && DomainRule.test(str);
  2157.       }
  2158.       /**
  2159.        * 判断是否为邮政编码
  2160.        * @param str 字符串
  2161.        * @returns 是否为邮政编码
  2162.        */
  2163.       static isPostcode(str) {
  2164.           return !isNullOrUndefined(str) && PostcodeRule.test(str);
  2165.       }
  2166.   }
  2167.   /**
  2168.    * 导出一个字符串校验的对象
  2169.    * @deprecated 已废弃，请直接使用类的静态函数
  2170.    */
  2171.   const stringValidator = StringValidator;
  2172.  
  2173.   /**
  2174.    * 判断字符串是否位小数
  2175.    * @param str 需要进行判断的字符串
  2176.    * @returns 是否为小数
  2177.    * @deprecated 已废弃，请使用 {@link stringValidator#isFloat}
  2178.    */
  2179.   function isFloat(str) {
  2180.       return stringValidator.isFloat(str);
  2181.   }
  2182.  
  2183.   /**
  2184.    * 判断字符串是否位整数
  2185.    * @param str 需要进行判断的字符串
  2186.    * @returns 是否为小数
  2187.    * @deprecated 已废弃，请使用 {@link stringValidator#isInteger}
  2188.    */
  2189.   function isNumber(str) {
  2190.       return stringValidator.isInteger(str);
  2191.   }
  2192.  
  2193.   /**
  2194.    * 字符串安全的转换为大写
  2195.    * @param str 字符串
  2196.    * @returns 转换后得到的全大写字符串
  2197.    */
  2198.   function toUpperCase(str) {
  2199.       if (isNullOrUndefined(str) || typeof str !== 'string') {
  2200.           return str;
  2201.       }
  2202.       return str.toUpperCase();
  2203.   }
  2204.  
  2205.   /**
  2206.    * 将空白字符串转换为 null
  2207.    *
  2208.    * @param str 将空字符串转换为 {@code null}
  2209.    * @returns 可能为 {@code null}
  2210.    */
  2211.   function blankToNull(str) {
  2212.       return StringValidator.isBlank(str) ? null : str;
  2213.   }
  2214.  
  2215.   /**
  2216.    * 置空对象所有空白的属性
  2217.    * @param obj 对象
  2218.    * @returns 将所有的空白属性全部转换为 null 的新对象
  2219.    */
  2220.   function blankToNullField(obj) {
  2221.       return Object.keys(obj).reduce((res, k) => {
  2222.           const v = Reflect.get(obj, k);
  2223.           Reflect.set(res, k, typeof v === 'string' ? blankToNull(v) : v);
  2224.           return res;
  2225.       }, {});
  2226.   }
  2227.  
  2228.   /**
  2229.    * 将对象的所有属性置空
  2230.    * @param obj 需要置空属性的对象
  2231.    * @returns 返回一个新的对象
  2232.    */
  2233.   function emptyAllField(obj) {
  2234.       return Object.keys(obj).reduce((res, k) => {
  2235.           Reflect.set(res, k, null);
  2236.           return res;
  2237.       }, {});
  2238.   }
  2239.  
  2240.   /**
  2241.    * 排除对象中的指定字段
  2242.    * 注: 此处将获得一个浅拷贝对象
  2243.    * @param obj 排除对象
  2244.    * @param fields 要排除的多个字段
  2245.    * @returns 排除完指定字段得到的新的对象
  2246.    */
  2247.   function excludeFields(obj, ...fields) {
  2248.       const set = new Set(fields);
  2249.       return Object.keys(obj).reduce((res, k) => {
  2250.           if (!set.has(k)) {
  2251.               Reflect.set(res, k, Reflect.get(obj, k));
  2252.           }
  2253.           return res;
  2254.       }, {});
  2255.   }
  2256.  
  2257.   /**
  2258.    * 将 Map 转换为 Object 对象
  2259.    * @param map Map 键值表
  2260.    * @returns 转换得到的 Object 对象
  2261.    */
  2262.   function mapToObject(map) {
  2263.       const res = {};
  2264.       for (const [k, v] of map) {
  2265.           Reflect.set(res, k, v);
  2266.       }
  2267.       return res;
  2268.   }
  2269.  
  2270.   /**
  2271.    * 生成一个随机的数字
  2272.    * 如果没有参数，则会抛出异常
  2273.    * @param num1 第一个参数，如果只有一个参数，则认为是最大值，最小值为 0
  2274.    * @param num2 第二个参数，如果该参数存在，则认为第二个是最大值，忽略剩余的参数
  2275.    * @returns 生成的随机整数
  2276.    */
  2277.   function randomInt(num1, num2) {
  2278.       const min = num2 ? num1 : 0;
  2279.       const max = num2 ? num2 : num1;
  2280.       return min + Math.floor(Math.random() * (max - min));
  2281.   }
  2282.  
  2283.   /**
  2284.    * 计算月有多少天
  2285.    * @param date 日期
  2286.    * @returns 月的总天数
  2287.    */
  2288.   function calcMonEndDay(date) {
  2289.       const monthToDay = [
  2290.           [new Set([1, 3, 5, 7, 8, 10, 12]), 30],
  2291.           [new Set([4, 6, 9, 11]), 30],
  2292.           [new Set([2]), 28],
  2293.       ];
  2294.       const year = date.getFullYear();
  2295.       const month = date.getMonth() + 1;
  2296.       const days = monthToDay.find(([monthSet]) => monthSet.has(month))[1];
  2297.       return days + (month === 2 && year % 4 === 0 ? 1 : 0);
  2298.   }
  2299.   /**
  2300.    * 日期固定时间点
  2301.    */
  2302.   class DateConstants {
  2303.       /**
  2304.        * 获取指定日期一天的开始时间
  2305.        * @param date 指定的时间，默认为当前日期
  2306.        * @returns 一天的开始时间
  2307.        */
  2308.       static dayStart(date = new Date()) {
  2309.           return new Date(`${dateFormat(date, 'yyyy-MM-dd')}T00:00:00.000`);
  2310.       }
  2311.       /**
  2312.        * 获取指定日期一天的结束时间
  2313.        * @param date 指定的时间，默认为当前日期
  2314.        * @returns 一天的结束时间
  2315.        */
  2316.       static dayEnd(date = new Date()) {
  2317.           return new Date(`${dateFormat(date, 'yyyy-MM-dd')}T23:59:59.999`);
  2318.       }
  2319.       /**
  2320.        * 获取指定日期所在月的开始时间
  2321.        * @param date 指定的时间，默认为当前日期
  2322.        * @returns 月的开始时间
  2323.        */
  2324.       static monthStart(date = new Date()) {
  2325.           return new Date(`${dateFormat(date, 'yyyy-MM')}-01T00:00:00.000`);
  2326.       }
  2327.       /**
  2328.        * 获取指定日期所在月的结束时间
  2329.        * @param date 指定的时间，默认为当前日期
  2330.        * @returns 月的结束时间
  2331.        */
  2332.       static monthEnd(date = new Date()) {
  2333.           return new Date(`${dateFormat(date, 'yyyy-MM')}-${calcMonEndDay(date)}T23:59:59.999`);
  2334.       }
  2335.       /**
  2336.        * 获取指定日期所在年份的新年开始时间
  2337.        * @param date 指定的时间，默认为当前日期
  2338.        * @returns 新年开始时间
  2339.        */
  2340.       static yearStart(date = new Date()) {
  2341.           return new Date(`${date.getFullYear()}-01-01T00:00:00.000`);
  2342.       }
  2343.       /**
  2344.        * 获取指定日期所在年份的旧年结束时间
  2345.        * @param date 指定的时间，默认为当前日期
  2346.        * @returns 旧年结束时间
  2347.        */
  2348.       static yearEnd(date = new Date()) {
  2349.           return new Date(`${date.getFullYear()}-12-31T23:59:59.999`);
  2350.       }
  2351.   }
  2352.   /**
  2353.    * 导出一个日期固定时间点的对象
  2354.    * @deprecated 已废弃，请直接使用类的静态函数
  2355.    */
  2356.   const dateConstants = DateConstants;
  2357.  
  2358.   /**
  2359.    * 一天标准的毫秒数
  2360.    */
  2361.   const DAY_UNIT_TIME = 1000 * 60 * 60 * 24;
  2362.   /**
  2363.    * 日期增强
  2364.    */
  2365.   class DateEnhance {
  2366.       /**
  2367.        * 构造函数
  2368.        * @param date 要增强的日期
  2369.        */
  2370.       constructor(date) {
  2371.           this.date = date;
  2372.       }
  2373.       /**
  2374.        * 获取到年份
  2375.        * @returns
  2376.        */
  2377.       year() {
  2378.           return this.date.getFullYear();
  2379.       }
  2380.       /**
  2381.        * 获取月份
  2382.        * @returns
  2383.        * @deprecated 已废弃，请使用 {@link this#monthOfYear} 函数
  2384.        */
  2385.       month() {
  2386.           return this.date.getMonth();
  2387.       }
  2388.       /**
  2389.        * 获取今年的第几个月份
  2390.        * 和 {@link this#month} 不同的是不再从 0 计算月份
  2391.        */
  2392.       monthOfYear() {
  2393.           return this.date.getMonth() + 1;
  2394.       }
  2395.       /**
  2396.        * 获取一年内的第多少天
  2397.        * 注: 这个天数指定的在第几天而非过去了多少天，例如 2018-01-10 的结果会是 10
  2398.        * @returns
  2399.        */
  2400.       dayOfYear() {
  2401.           return Math.ceil((this.date.getTime() - dateConstants.yearStart(this.date).getTime()) /
  2402.               DAY_UNIT_TIME);
  2403.       }
  2404.       /**
  2405.        * 获取一个月内的第多少天
  2406.        * 注: 这个天数指的是在第几天而非过去了多少天，例如 2018-01-10 的结果会是 10
  2407.        * @returns
  2408.        */
  2409.       dayOfMonth() {
  2410.           return this.date.getDate();
  2411.       }
  2412.       /**
  2413.        * 获取一个星期内的第多少天
  2414.        * @returns
  2415.        */
  2416.       dayOfWeek() {
  2417.           return this.date.getDay();
  2418.       }
  2419.       /**
  2420.        * 获取一年内的第多少星期
  2421.        * 注: 这个星期指定的在第几天而非过去了多少天，例如 2018-01-10 的结果会是 10
  2422.        * @returns
  2423.        */
  2424.       weekOfYear() {
  2425.           return Math.ceil(this.dayOfYear() / 7);
  2426.       }
  2427.       /**
  2428.        * 获取一个月内的第多少星期
  2429.        * @returns
  2430.        */
  2431.       weekOfMonth() {
  2432.           return Math.ceil(this.dayOfMonth() / 7);
  2433.       }
  2434.       /**
  2435.        * 获取季度
  2436.        * @returns
  2437.        */
  2438.       quarter() {
  2439.           const month = this.month();
  2440.           if (isRange(month, 0, 3)) {
  2441.               return 1;
  2442.           }
  2443.           else if (isRange(month, 3, 6)) {
  2444.               return 2;
  2445.           }
  2446.           else if (isRange(month, 6, 9)) {
  2447.               return 3;
  2448.           }
  2449.           else {
  2450.               return 4;
  2451.           }
  2452.       }
  2453.       /**
  2454.        * 获取小时
  2455.        * @returns
  2456.        */
  2457.       hour() {
  2458.           return this.date.getHours();
  2459.       }
  2460.       /**
  2461.        * 获取分钟
  2462.        * @returns
  2463.        */
  2464.       minute() {
  2465.           return this.date.getMinutes();
  2466.       }
  2467.       /**
  2468.        * 获取秒
  2469.        * @returns
  2470.        */
  2471.       second() {
  2472.           return this.date.getSeconds();
  2473.       }
  2474.       /**
  2475.        * 获取毫秒
  2476.        * @returns
  2477.        */
  2478.       milliSecond() {
  2479.           return this.date.getMilliseconds();
  2480.       }
  2481.   }
  2482.   /**
  2483.    * 获取一个增强的日期
  2484.    * @param date 要增强的日期
  2485.    * @returns 增强日期
  2486.    */
  2487.   function dateEnhance(date) {
  2488.       return new DateEnhance(date);
  2489.   }
  2490.  
  2491.   /**
  2492.    * 获取一年内的第多少星期
  2493.    * @param date 日期
  2494.    * @returns 这个日期第多少个星期
  2495.    * @deprecated 不推荐使用，请使用 {@see dateEnhance} 代替
  2496.    */
  2497.   function getYearWeek(date) {
  2498.       return dateEnhance(date).weekOfYear();
  2499.   }
  2500.  
  2501.   /**
  2502.    * 时间日期间隔
  2503.    */
  2504.   class DateBetween {
  2505.       /**
  2506.        * 构造函数
  2507.        * @param start 开始时间
  2508.        * @param end 结束时间
  2509.        */
  2510.       constructor(start, end) {
  2511.           this.start = start;
  2512.           this.end = end;
  2513.       }
  2514.       /**
  2515.        * 获取毫秒差值
  2516.        * @returns 毫秒差值
  2517.        */
  2518.       milliSecond() {
  2519.           return this.end.getTime() - this.start.getTime();
  2520.       }
  2521.       /**
  2522.        * 获取秒差值
  2523.        * @returns 秒差值
  2524.        */
  2525.       second() {
  2526.           return Math.floor(this.milliSecond() / 1000);
  2527.       }
  2528.       /**
  2529.        * 获取分钟差值
  2530.        * @returns 分钟差值
  2531.        */
  2532.       minute() {
  2533.           return Math.floor(this.second() / 60);
  2534.       }
  2535.       /**
  2536.        * 获取小时差值
  2537.        * @returns 小时差值
  2538.        */
  2539.       hour() {
  2540.           return Math.floor(this.minute() / 60);
  2541.       }
  2542.       /**
  2543.        * 获取天数差值
  2544.        * @returns 天数差值
  2545.        */
  2546.       day() {
  2547.           return Math.floor(this.hour() / 24);
  2548.       }
  2549.       /**
  2550.        * 获取月份差值
  2551.        * 注: 此处获取的差值是按月计算的，即 2018-12-31 => 2019-01-01 也被认为相差一个月
  2552.        * @returns 月份差值
  2553.        */
  2554.       month() {
  2555.           const year = this.year();
  2556.           const month = this.end.getMonth() - this.start.getMonth();
  2557.           return year * 12 + month;
  2558.       }
  2559.       /**
  2560.        * 获取年份差值
  2561.        * 注: 此处获取的差值是按年计算的，即 2018-12-31 => 2019-01-01 也被认为相差一年
  2562.        * @returns 年份差值
  2563.        */
  2564.       year() {
  2565.           return this.end.getFullYear() - this.start.getFullYear();
  2566.       }
  2567.   }
  2568.   /**
  2569.    * 获取两个时间的差值
  2570.    * @param start 开始时间
  2571.    * @param end 结束时间
  2572.    * @returns 差值对象
  2573.    */
  2574.   function dateBetween(start, end) {
  2575.       return new DateBetween(start, end);
  2576.   }
  2577.  
  2578.   /**
  2579.    * 返回合理参数本身的函数
  2580.    * 1. 如果没有参数则返回 undefined
  2581.    * 2. 如果只有一个参数则返回参数本身
  2582.    * 3. 如果有两个以上的参数则返回参数列表
  2583.    * @param args 任何对象
  2584.    * @returns 传入的参数
  2585.    */
  2586.   function returnReasonableItself(...args) {
  2587.       const len = args.length;
  2588.       if (len === 0) {
  2589.           return null;
  2590.       }
  2591.       if (len === 1) {
  2592.           return args[0];
  2593.       }
  2594.       return args;
  2595.   }
  2596.  
  2597.   /**
  2598.    * 从数组中移除指定的元素
  2599.    * 注: 时间复杂度为 1~3On
  2600.    * @param arr 需要被过滤的数组
  2601.    * @param deleteItems 要过滤的元素数组
  2602.    * @param k 每个元素的唯一键函数
  2603.    */
  2604.   function filterItems(arr, deleteItems, k = returnItself) {
  2605.       const kFn = getKFn(k);
  2606.       const kSet = new Set(deleteItems.map(kFn));
  2607.       return arr.filter((v, i, arr) => !kSet.has(kFn(v, i, arr)));
  2608.   }
  2609.  
  2610.   /**
  2611.    * 比较两个数组的差异
  2612.    * @param left 第一个数组
  2613.    * @param right 第二个数组
  2614.    * @param k 每个元素的唯一标识产生函数
  2615.    * @returns 比较的差异结果
  2616.    */
  2617.   function diffBy(left, right, k = returnItself) {
  2618.       const kFn = getKFn(k);
  2619.       // 首先得到两个 kSet 集合用于过滤
  2620.       const kThanSet = new Set(left.map(kFn));
  2621.       const kThatSet = new Set(right.map(kFn));
  2622.       const leftUnique = left.filter((v, ...args) => !kThatSet.has(kFn(v, ...args)));
  2623.       const rightUnique = right.filter((v, ...args) => !kThanSet.has(kFn(v, ...args)));
  2624.       const kLeftSet = new Set(leftUnique.map(kFn));
  2625.       const common = left.filter((v, ...args) => !kLeftSet.has(kFn(v, ...args)));
  2626.       return { left: leftUnique, right: rightUnique, common };
  2627.   }
  2628.  
  2629.   /**
  2630.    * 比较两个数组的差异
  2631.    * @deprecated 已废弃，请使用更简洁的 {@link diffBy}
  2632.    */
  2633.   const arrayDiffBy = diffBy;
  2634.  
  2635.   /**
  2636.    * 使用 Generator 实现一个从 0 开始的无限自增序列
  2637.    */
  2638.   function* autoIncrementGenerator() {
  2639.       for (let i = 0;; i++) {
  2640.           /**
  2641.            * @returns 每次获取都返回循环中的当前迭代变量，然后暂停于此处
  2642.            */
  2643.           yield i;
  2644.       }
  2645.   }
  2646.   /**
  2647.    * 生成器对象
  2648.    */
  2649.   const generator = autoIncrementGenerator();
  2650.   /**
  2651.    * 获取自增长序列的最新值
  2652.    * @returns 最新值
  2653.    */
  2654.   function autoIncrement() {
  2655.       return generator.next().value;
  2656.   }
  2657.  
  2658.   /**
  2659.    * 转换接口
  2660.    * @interface
  2661.    */
  2662.   class IConverter {
  2663.       /**
  2664.        * 将字符串解析为字符串列表
  2665.        *
  2666.        * @param str 字符串
  2667.        * @return {Array.<String>} 字符串列表
  2668.        * @abstract
  2669.        */
  2670.       from(str) {
  2671.           throw new Error('子类必须重写 from 函数');
  2672.       }
  2673.       /**
  2674.        * 将字符串列表构造为字符串
  2675.        *
  2676.        * @param list 字符串列表
  2677.        * @return {String} 字符串
  2678.        * @abstract
  2679.        */
  2680.       to(list) {
  2681.           throw new Error('子类必须重写 to 函数');
  2682.       }
  2683.   }
  2684.  
  2685.   /**
  2686.    * 驼峰风格解析
  2687.    */
  2688.   class CamelOrPascalFrom extends IConverter {
  2689.       /**
  2690.        * 将字符串解析为字符串列表
  2691.        *
  2692.        * @param str 字符串
  2693.        * @return {Array.<String>} 字符串列表
  2694.        * @override
  2695.        */
  2696.       from(str) {
  2697.           const result = [];
  2698.           const len = str.length;
  2699.           let old = 0;
  2700.           for (let i = 0; i < len; i++) {
  2701.               const c = str.charAt(i);
  2702.               if (c >= 'A' && c <= 'Z') {
  2703.                   if (i !== 0) {
  2704.                       result.push(str.substring(old, i));
  2705.                   }
  2706.                   old = i;
  2707.               }
  2708.           }
  2709.           if (old !== str.length) {
  2710.               result.push(str.substring(old, str.length));
  2711.           }
  2712.           return result;
  2713.       }
  2714.   }
  2715.  
  2716.   /**
  2717.    * 小写开头的驼峰转换器
  2718.    *
  2719.    */
  2720.   class CamelConverter extends CamelOrPascalFrom {
  2721.       /**
  2722.        * 将字符串列表构造为字符串
  2723.        *
  2724.        * @param list 字符串列表
  2725.        * @return {String} 字符串
  2726.        * @override
  2727.        */
  2728.       to(list) {
  2729.           return list.reduce((res, s, i) => {
  2730.               const str = toLowerCase(s);
  2731.               return (res +=
  2732.                   (i === 0 ? toLowerCase : toUpperCase)(str.substring(0, 1)) +
  2733.                       str.substring(1));
  2734.           }, '');
  2735.       }
  2736.   }
  2737.  
  2738.   /**
  2739.    * 大写开头的驼峰转换器
  2740.    */
  2741.   class PascalConverter extends CamelOrPascalFrom {
  2742.       /**
  2743.        * 将字符串列表构造为字符串
  2744.        *
  2745.        * @param list 字符串列表
  2746.        * @return {String} 字符串
  2747.        * @override
  2748.        */
  2749.       to(list) {
  2750.           return list.reduce((res, s) => {
  2751.               const str = toLowerCase(s);
  2752.               return (res += toUpperCase(str.substring(0, 1)) + str.substring(1));
  2753.           }, '');
  2754.       }
  2755.   }
  2756.  
  2757.   /**
  2758.    * 下划线风格解析
  2759.    */
  2760.   class SnakeOrScreamingSnakeFrom extends IConverter {
  2761.       /**
  2762.        * 将字符串解析为字符串列表
  2763.        *
  2764.        * @param str 字符串
  2765.        * @return {Array.<String>} 字符串列表
  2766.        * @override
  2767.        */
  2768.       from(str) {
  2769.           return str.split('_');
  2770.       }
  2771.   }
  2772.  
  2773.   /**
  2774.    * 小写下划线的转换器
  2775.    */
  2776.   class SnakeConverter extends SnakeOrScreamingSnakeFrom {
  2777.       /**
  2778.        * 将字符串列表构造为字符串
  2779.        *
  2780.        * @param list 字符串列表
  2781.        * @return {String} 字符串
  2782.        * @override
  2783.        */
  2784.       to(list) {
  2785.           return list.map(toLowerCase).join('_');
  2786.       }
  2787.   }
  2788.  
  2789.   /**
  2790.    * 大写下划线的转换器
  2791.    */
  2792.   class ScreamingSnakeConverter extends SnakeOrScreamingSnakeFrom {
  2793.       /**
  2794.        * 将字符串列表构造为字符串
  2795.        *
  2796.        * @param list 字符串列表
  2797.        * @return {String} 字符串
  2798.        * @override
  2799.        */
  2800.       to(list) {
  2801.           return list.map(toUpperCase).join('_');
  2802.       }
  2803.   }
  2804.  
  2805.   /**
  2806.    * @enum {Symbol} 字符串风格常量对象
  2807.    */
  2808.   (function (StringStyleType) {
  2809.       /**
  2810.        * 小写驼峰
  2811.        */
  2812.       StringStyleType[StringStyleType["Camel"] = 1] = "Camel";
  2813.       /**
  2814.        * 大写驼峰
  2815.        */
  2816.       StringStyleType[StringStyleType["Pascal"] = 2] = "Pascal";
  2817.       /**
  2818.        * 小写下划线
  2819.        */
  2820.       StringStyleType[StringStyleType["Snake"] = 3] = "Snake";
  2821.       /**
  2822.        * 大写下划线
  2823.        */
  2824.       StringStyleType[StringStyleType["ScreamingSnake"] = 4] = "ScreamingSnake";
  2825.   })(exports.StringStyleType || (exports.StringStyleType = {}));
  2826.  
  2827.   /**
  2828.    * 转换器工厂
  2829.    */
  2830.   class ConverterFactory {
  2831.       /**
  2832.        * 获取一个转换器实例
  2833.        *
  2834.        * @param styleType 转换风格，使用了 {@link stringStyleType} 定义的常量对象
  2835.        * @return {IConverter} 转换器对象
  2836.        * @throws 如果获取未定义过的转换器，则会抛出异常
  2837.        */
  2838.       static getInstance(styleType) {
  2839.           switch (styleType) {
  2840.               case exports.StringStyleType.Camel:
  2841.                   return new CamelConverter();
  2842.               case exports.StringStyleType.Pascal:
  2843.                   return new PascalConverter();
  2844.               case exports.StringStyleType.Snake:
  2845.                   return new SnakeConverter();
  2846.               case exports.StringStyleType.ScreamingSnake:
  2847.                   return new ScreamingSnakeConverter();
  2848.               default:
  2849.                   throw new Error('No corresponding converter found');
  2850.           }
  2851.       }
  2852.   }
  2853.  
  2854.   /**
  2855.    * 字符串风格转换器
  2856.    * 请不要直接使用构造函数创建，而是用 {@link StringStyleUtil.getConverter} 来获得一个转换器
  2857.    * @private
  2858.    */
  2859.   class StringStyleConverter {
  2860.       /**
  2861.        * 构造一个字符串任意风格转换器
  2862.        * @param from 转换字符串的风格
  2863.        * @param to 需要转换的风格
  2864.        * @private
  2865.        */
  2866.       constructor(from, to) {
  2867.           /**
  2868.            * @field 解析字符串风格的转换器
  2869.            * @type {IConverter}
  2870.            * @private
  2871.            */
  2872.           this.fromConverter = ConverterFactory.getInstance(from);
  2873.           /**
  2874.            * @field 构造字符串风格的转换器
  2875.            * @type {IConverter}
  2876.            * @private
  2877.            */
  2878.           this.toConverter = ConverterFactory.getInstance(to);
  2879.       }
  2880.       /**
  2881.        * 转换字符串的风格
  2882.        *
  2883.        * @param str 要转换的字符串
  2884.        * @return {String} 转换得到的字符串
  2885.        */
  2886.       convert(str) {
  2887.           if (stringValidator.isEmpty(str)) {
  2888.               return str;
  2889.           }
  2890.           return this.toConverter.to(this.fromConverter.from(str));
  2891.       }
  2892.   }
  2893.  
  2894.   /**
  2895.    * 包装一个函数为指定参数只执行一次的函数
  2896.    * @param fn 需要包装的函数
  2897.    * @param identity 参数转换的函数，参数为需要包装函数的参数
  2898.    * @returns 需要被包装的函数
  2899.    */
  2900.   function onceOfSameParam(fn, identity = (args) => `onceOfSameParam-${fn.toString()}-${JSON.stringify(args)}`) {
  2901.       const cacheMap = new Map();
  2902.       const res = new Proxy(fn, {
  2903.           apply(_, _this, args) {
  2904.               const key = identity(args);
  2905.               const old = cacheMap.get(key);
  2906.               if (old !== undefined) {
  2907.                   return old;
  2908.               }
  2909.               const res = Reflect.apply(_, _this, args);
  2910.               return compatibleAsync(res, res => {
  2911.                   cacheMap.set(key, res);
  2912.                   return res;
  2913.               });
  2914.           },
  2915.       });
  2916.       return Object.assign(res, {
  2917.           origin: fn,
  2918.           clear(...keys) {
  2919.               if (keys.length) {
  2920.                   cacheMap.clear();
  2921.               }
  2922.               else {
  2923.                   keys.forEach(key => cacheMap.delete(key));
  2924.               }
  2925.           },
  2926.       });
  2927.   }
  2928.  
  2929.   /**
  2930.    * 包装获取字符串风格转换器
  2931.    * 此处采用了单例模式，每种转换器只会有一个
  2932.    *
  2933.    * @param from 解析风格
  2934.    * @param to 转换风格
  2935.    * @return {StringStyleConverter} 转换器的实例
  2936.    */
  2937.   const _getConverter = onceOfSameParam(
  2938.   /**
  2939.    * @param from 解析风格
  2940.    * @param to 转换风格
  2941.    * @return {StringStyleConverter} 转换器的实例
  2942.    */
  2943.   (from, to) => new StringStyleConverter(from, to));
  2944.   /**
  2945.    * 字符串风格转换工具类
  2946.    */
  2947.   class StringStyleUtil {
  2948.       /**
  2949.        * 获取一个转换器的实例
  2950.        * 该函数获取的转换器可以任意复用，请优先使用函数
  2951.        * @param from 解析风格
  2952.        * @param to 转换风格
  2953.        * @return {StringStyleConverter} 转换器的实例
  2954.        */
  2955.       static getConverter(from, to) {
  2956.           return _getConverter(from, to);
  2957.       }
  2958.       /**
  2959.        * 直接转换字符串的风格
  2960.        * 请优先使用可以复用的 {@link StringStyleUtil.getConverter} 函数
  2961.        * @param from 解析风格
  2962.        * @param to 转换风格
  2963.        * @param str 要转换的字符串
  2964.        * @return {String} 转换得到的字符串
  2965.        */
  2966.       static convert(from, to, str) {
  2967.           return StringStyleUtil.getConverter(from, to).convert(str);
  2968.       }
  2969.   }
  2970.  
  2971.   /**
  2972.    * 获取对象中所有的属性值，包括 ES6 新增的 Symbol 类型的属性
  2973.    * @param obj 任何对象
  2974.    * @returns 属性值数组
  2975.    * @deprecated 该函数将要被废弃，实质上应用场景很窄
  2976.    */
  2977.   function getObjectValues(obj) {
  2978.       return Reflect.ownKeys(obj).map(k => Reflect.get(obj, k));
  2979.   }
  2980.  
  2981.   /**
  2982.    * 递归使对象不可变
  2983.    * @param obj 任何非空对象
  2984.    * @returns 新的不可变对象
  2985.    */
  2986.   function deepFreeze(obj) {
  2987.       // 数组和对象分别处理
  2988.       if (TypeValidator.isArray(obj)) {
  2989.           obj.forEach(v => {
  2990.               if (typeof v === 'object') {
  2991.                   deepFreeze(v);
  2992.               }
  2993.           });
  2994.       }
  2995.       else if (TypeValidator.isObject(obj)) {
  2996.           getObjectValues(obj).forEach(v => {
  2997.               if (typeof v === 'object') {
  2998.                   deepFreeze(v);
  2999.               }
  3000.           });
  3001.       }
  3002.       return Object.freeze(obj);
  3003.   }
  3004.  
  3005.   /**
  3006.    * 包装对象，使其成为可以任意深度调用而不会出现 undefined 调用的问题
  3007.    * 注意: 该函数不能进行递归调用（{@link JSON.stringfy}），一定会造成堆栈溢出的问题（RangeError: Maximum call stack size exceeded）
  3008.    * @param obj 任意一个 Object 对象
  3009.    * @param [defaultValue] 默认值，默认为 {}
  3010.    * @returns 包装后的对象
  3011.    */
  3012.   function deepProxy(obj, defaultValue = {}) {
  3013.       const handler = {
  3014.           get(target, k) {
  3015.               let v = Reflect.get(target, k);
  3016.               if (isNullOrUndefined(v)) {
  3017.                   v = defaultValue;
  3018.               }
  3019.               if (typeof v !== 'object') {
  3020.                   return v;
  3021.               }
  3022.               return new Proxy(v, handler);
  3023.           },
  3024.       };
  3025.       return new Proxy(obj, handler);
  3026.   }
  3027.  
  3028.   /**
  3029.    * 将函数包装为柯里化函数
  3030.    * 注: 该函数模仿了 Lodash 的 curry 函数
  3031.    * @param fn 需要包装的函数
  3032.    * @param  {...any} args 应用的部分参数
  3033.    * @returns 包装后的函数
  3034.    * @deprecated 由于之前的理解错误，该函数在下个大版本将会被废弃，请使用命名更合适的 {@link partial}
  3035.    */
  3036.   function curry(fn, ...args) {
  3037.       const realArgs = args.filter(arg => arg !== curry._);
  3038.       // 如果函数参数足够则调用传入的函数
  3039.       if (realArgs.length >= fn.length) {
  3040.           return fn(...realArgs);
  3041.       }
  3042.       /**
  3043.        * 最终返回的函数
  3044.        * @param otherArgs 接受任意参数
  3045.        * @returns 返回一个函数，或者函数调用完成返回结果
  3046.        */
  3047.       function innerFn(...otherArgs) {
  3048.           // 记录需要移除补到前面的参数
  3049.           const removeIndexSet = new Set();
  3050.           let i = 0;
  3051.           const newArgs = args.map(arg => {
  3052.               if (arg !== curry._ ||
  3053.                   otherArgs[i] === undefined ||
  3054.                   otherArgs[i] === curry._) {
  3055.                   return arg;
  3056.               }
  3057.               removeIndexSet.add(i);
  3058.               // 每次补偿前面的 curry._ 参数计数器 +1
  3059.               return otherArgs[i++];
  3060.           });
  3061.           const newOtherArgs = otherArgs.filter((_v, i) => !removeIndexSet.has(i));
  3062.           return curry(fn, ...newArgs, ...newOtherArgs);
  3063.       }
  3064.       // 定义柯里化函数的剩余参数长度，便于在其他地方进行部分参数应用
  3065.       // 注: 不使用 length 属性的原因是 length 属性
  3066.       innerFn._length = fn.length - args.filter(arg => arg !== curry._).length;
  3067.       // 自定义 toString 函数便于调试
  3068.       innerFn.toString = () => `name: ${fn.name}, args: [${args.map(o => o.toString()).join(', ')}]`;
  3069.       innerFn._curry = true;
  3070.       return innerFn;
  3071.   }
  3072.   /**
  3073.    * 柯里化的占位符，需要应用后面的参数时使用
  3074.    * 例如 {@link curry(fn)(curry._, 1)} 意味着函数 fn 的第二个参数将被确定为 1
  3075.    */
  3076.   curry._ = Symbol('_');
  3077.  
  3078.   /**
  3079.    * 快速根据指定函数对数组进行排序
  3080.    * 注: 使用递归实现，对于超大数组（其实前端的数组不可能特别大吧？#笑）可能造成堆栈溢出
  3081.    * @param arr 需要排序的数组
  3082.    * @param k 对数组中每个元素都产生可比较的值的函数，默认返回自身进行比较
  3083.    * @returns 排序后的新数组
  3084.    */
  3085.   function sortBy(arr, k = returnItself) {
  3086.       const kFn = getKFn(k);
  3087.       //  此处为了让 typedoc 能生成文档而不得不加上类型
  3088.       const newArr = arr.map((v, i) => [v, i]);
  3089.       function _sort(arr, fn) {
  3090.           // 边界条件，如果传入数组的值
  3091.           if (arr.length <= 1) {
  3092.               return arr;
  3093.           }
  3094.           // 根据中间值对数组分治为两个数组
  3095.           const medianIndex = Math.floor(arr.length / 2);
  3096.           const medianValue = arr[medianIndex];
  3097.           const left = [];
  3098.           const right = [];
  3099.           for (let i = 0, len = arr.length; i < len; i++) {
  3100.               if (i === medianIndex) {
  3101.                   continue;
  3102.               }
  3103.               const v = arr[i];
  3104.               if (fn(v, medianValue) <= 0) {
  3105.                   left.push(v);
  3106.               }
  3107.               else {
  3108.                   right.push(v);
  3109.               }
  3110.           }
  3111.           return _sort(left, fn)
  3112.               .concat([medianValue])
  3113.               .concat(_sort(right, fn));
  3114.       }
  3115.       return _sort(newArr, ([t1, i1], [t2, i2]) => {
  3116.           const k1 = kFn(t1, i1, arr);
  3117.           const k2 = kFn(t2, i2, arr);
  3118.           if (k1 === k2) {
  3119.               return 0;
  3120.           }
  3121.           else if (k1 < k2) {
  3122.               return -1;
  3123.           }
  3124.           else {
  3125.               return 1;
  3126.           }
  3127.       }).map(([_v, i]) => arr[i]);
  3128.   }
  3129.  
  3130.   /**
  3131.    * 日期格式化器
  3132.    * 包含格式化为字符串和解析字符串为日期的函数
  3133.    */
  3134.   class DateFormatter {
  3135.       /**
  3136.        * 构造函数
  3137.        * @param fmt 日期时间格式
  3138.        */
  3139.       constructor(fmt) {
  3140.           this.fmt = fmt;
  3141.       }
  3142.       /**
  3143.        * 格式化
  3144.        * @param date 需要格式化的日期
  3145.        * @returns 格式化的字符串
  3146.        */
  3147.       format(date) {
  3148.           if (isNullOrUndefined(date)) {
  3149.               return '';
  3150.           }
  3151.           return dateFormat(date, this.fmt);
  3152.       }
  3153.       /**
  3154.        * 解析字符串为日期对象
  3155.        * @param str 字符串
  3156.        * @returns 解析得到的日期
  3157.        */
  3158.       parse(str) {
  3159.           if (stringValidator.isEmpty(str)) {
  3160.               return null;
  3161.           }
  3162.           return dateParse(str, this.fmt);
  3163.       }
  3164.       /**
  3165.        * 将日期时间字符串转换为前端指定格式的字符串
  3166.        * 主要适用场景是前端接收到后端的日期时间一般是一个字符串，然而需要自定义格式的时候还必须先创建 {@link Date} 对象才能格式化，略微繁琐，故使用该函数
  3167.        * @param str 字符串
  3168.        * @param parseFmt 解析的日期时间格式。默认直接使用 {@link new Date()} 创建
  3169.        * @returns 转换后得到的字符串
  3170.        */
  3171.       strFormat(str, parseFmt) {
  3172.           if (stringValidator.isEmpty(str)) {
  3173.               return '';
  3174.           }
  3175.           const date = parseFmt ? dateParse(str, parseFmt) : new Date(str);
  3176.           return dateFormat(date, this.fmt);
  3177.       }
  3178.   }
  3179.   /**
  3180.    * 日期格式化器
  3181.    */
  3182.   DateFormatter.dateFormatter = new DateFormatter('yyyy-MM-dd');
  3183.   /**
  3184.    * 时间格式化器
  3185.    */
  3186.   DateFormatter.timeFormatter = new DateFormatter('hh:mm:ss');
  3187.   /**
  3188.    * 日期时间格式化器
  3189.    */
  3190.   DateFormatter.dateTimeFormatter = new DateFormatter('yyyy-MM-dd hh:mm:ss');
  3191.  
  3192.   /**
  3193.    * 查询符合条件的元素的下标
  3194.    * @param arr 查询的数组
  3195.    * @param fn 谓词
  3196.    * @param num 查询的第几个符合条件的元素，默认为 1，和默认的 findIndex 行为保持一致
  3197.    * @returns 符合条件的元素的下标，如果没有则返回 -1
  3198.    */
  3199.   function findIndex(arr, fn, num = 1) {
  3200.       let k = 0;
  3201.       for (let i = 0, len = arr.length; i < len; i++) {
  3202.           if (fn.call(arr, arr[i], i, arr) && ++k >= num) {
  3203.               return i;
  3204.           }
  3205.       }
  3206.       return -1;
  3207.   }
  3208.  
  3209.   /**
  3210.    * 连接两个函数并自动柯里化
  3211.    * 注: 该函数依赖于 length，所以不支持默认参数以及不定参数
  3212.    * @param fn1 第一个函数
  3213.    * @param fn2 第二个函数
  3214.    * @returns 连接后的函数
  3215.    */
  3216.   const _compose = (fn1, fn2) => {
  3217.       return function (...args) {
  3218.           const i = findIndex(args, v => v !== curry._, fn1._length || fn1.length);
  3219.           const res = curry(fn1, ...args);
  3220.           // 如果这个函数的参数不足，则返回它
  3221.           if (i === -1) {
  3222.               return _compose(res, fn2);
  3223.           }
  3224.           // 否则将结果以及多余的参数应用到下一个函数上
  3225.           return curry(fn2, res, ...args.slice(i + 1));
  3226.       };
  3227.   };
  3228.   /**
  3229.    * 将多个函数组合起来
  3230.    * 前面函数的返回值将变成后面函数的第一个参数，如果到了最后一个函数执行完成，则直接返回
  3231.    * 注: 该函数是自动柯里化，将对所有传入的函数进行柯里化处理
  3232.    * 注: 该函数支持一次调用传入全部函数的参数
  3233.    * @param fns 多个需要连接函数
  3234.    * @returns 连接后的柯里化函数
  3235.    * TODO 这里需要进行类型优化
  3236.    */
  3237.   function compose(...fns) {
  3238.       return fns.reduceRight((fn1, fn2) => _compose(fn2, fn1));
  3239.   }
  3240.  
  3241.   /**
  3242.    * 递归排除对象中的指定字段
  3243.    * @param obj 需要排除的对象
  3244.    * @param  {...obj} fields 需要排除的字段
  3245.    */
  3246.   function excludeFieldsDeep(obj, ...fields) {
  3247.       return Object.keys(obj).reduce((res, k) => {
  3248.           const v = Reflect.get(res, k);
  3249.           if (v instanceof Object) {
  3250.               Reflect.set(obj, k, excludeFieldsDeep(v, ...fields));
  3251.           }
  3252.           return res;
  3253.       }, obj instanceof Array ? obj : excludeFields(obj, ...fields));
  3254.   }
  3255.  
  3256.   /**
  3257.    * 缓存的值
  3258.    */
  3259.   class CacheVal {
  3260.       /**
  3261.        * 构造函数
  3262.        * @param options 缓存值对象
  3263.        * @param options.key 缓存的键原始值
  3264.        * @param options.val 缓存的值
  3265.        * @param options.cacheOption 缓存的选项
  3266.        */
  3267.       constructor(options = {}) {
  3268.           Object.assign(this, options);
  3269.       }
  3270.   }
  3271.  
  3272.   /**
  3273.    * 无限的超时时间
  3274.    * TODO 此处暂时使用字符串作为一种折衷方法，因为 Symbol 无法被序列化为 JSON，反向序列化也是不可能的
  3275.    */
  3276.   const TimeoutInfinite = 'TimeoutInfinite';
  3277.  
  3278.   /**
  3279.    * 使用 LocalStorage 实现的缓存
  3280.    * 1. get: 根据 key 获取
  3281.    * 2. set: 根据 key value 设置，会覆盖
  3282.    * 3. touch: 获取并刷新超时时间
  3283.    * 4. add: 根据 key value 添加，不会覆盖
  3284.    * 5. del: 根据 key 删除
  3285.    * 6. clearExpired: 清除所有过期的缓存
  3286.    */
  3287.   class LocalStorageCache {
  3288.       /**
  3289.        * 构造函数
  3290.        * @param cacheOption 全局缓存选项
  3291.        */
  3292.       constructor({ timeout = TimeoutInfinite, serialize = JSON.stringify, deserialize = JSON.parse, } = {}) {
  3293.           // 这里必须强制转换，因为 timeStart 在全局选项中是不可能存在的
  3294.           this.cacheOption = {
  3295.               timeout,
  3296.               serialize,
  3297.               deserialize,
  3298.           };
  3299.           /**
  3300.            * 缓存对象，默认使用 localStorage
  3301.            */
  3302.           this.localStorage = window.localStorage;
  3303.           // 创建后将异步清空所有过期的缓存
  3304.           this.clearExpired();
  3305.       }
  3306.       /**
  3307.        * 清空所有过期的 key
  3308.        * 注: 该函数是异步执行的
  3309.        */
  3310.       clearExpired() {
  3311.           return __awaiter(this, void 0, void 0, function* () {
  3312.               const local = this.localStorage;
  3313.               const getKeys = () => {
  3314.                   const len = local.length;
  3315.                   const res = [];
  3316.                   for (let i = 0; i < len; i++) {
  3317.                       res.push(local.key(i));
  3318.                   }
  3319.                   return res;
  3320.               };
  3321.               getKeys()
  3322.                   .filter(not(isNullOrUndefined))
  3323.                   .map(key => safeExec(() => JSON.parse(local.getItem(key))))
  3324.                   .filter(cacheVal => !isNullOrUndefined(cacheVal) &&
  3325.                   isNullOrUndefined(cacheVal.cacheOption))
  3326.                   // TODO 这里暂时加个补丁，过滤掉 timeStart,timeout 为 undefined 的缓存
  3327.                   .filter(({ cacheOption = {} }) => {
  3328.                   const { timeStart, timeout } = cacheOption;
  3329.                   if (isNullOrUndefined(timeStart) || isNullOrUndefined(timeout)) {
  3330.                       return false;
  3331.                   }
  3332.                   return timeout !== TimeoutInfinite && Date.now() - timeStart > timeout;
  3333.               })
  3334.                   .forEach(({ key }) => local.removeItem(key));
  3335.           });
  3336.       }
  3337.       /**
  3338.        * 根据 key + value 添加
  3339.        * 如果不存在则添加，否则忽略
  3340.        * @param key 缓存的 key
  3341.        * @param val 缓存的 value
  3342.        * @param cacheOption 缓存的选项，默认为无限时间
  3343.        * @override
  3344.        */
  3345.       add(key, val, timeout) {
  3346.           const result = this.get(key);
  3347.           if (result !== null) {
  3348.               return;
  3349.           }
  3350.           this.set(key, val, timeout);
  3351.       }
  3352.       /**
  3353.        * 根据指定的 key 删除
  3354.        * 如果存在则删除，否则忽略
  3355.        * @param key 删除的 key
  3356.        * @override
  3357.        */
  3358.       del(key) {
  3359.           this.localStorage.removeItem(key);
  3360.       }
  3361.       /**
  3362.        * 根据指定的 key 修改
  3363.        * 不管是否存在都会设置
  3364.        * @param key 修改的 key
  3365.        * @param val 修改的 value
  3366.        * @param timeout 修改的选项
  3367.        * @override
  3368.        */
  3369.       set(key, val, timeout) {
  3370.           this.localStorage.setItem(key, JSON.stringify(new CacheVal({
  3371.               key,
  3372.               val: this.cacheOption.serialize(val),
  3373.               // 我们不需要缓存序列化/反序列化策略（实际上也无法缓存）
  3374.               cacheOption: {
  3375.                   timeStart: Date.now(),
  3376.                   timeout: timeout || this.cacheOption.timeout,
  3377.               },
  3378.           })));
  3379.       }
  3380.       /**
  3381.        * 根据 key 获取
  3382.        * 如果存在则获取，否则忽略
  3383.        * @param key 指定的 key
  3384.        * @param timeout 获取的选项
  3385.        * @returns 获取到的缓存值
  3386.        * @override
  3387.        */
  3388.       get(key) {
  3389.           const str = this.localStorage.getItem(key);
  3390.           const cacheVal = safeExec(() => JSON.parse(str));
  3391.           if (isNullOrUndefined(cacheVal) ||
  3392.               isNullOrUndefined(cacheVal.cacheOption)) {
  3393.               return null;
  3394.           }
  3395.           const [timeStart, timeout, deserialize] = [
  3396.               cacheVal.cacheOption.timeStart,
  3397.               cacheVal.cacheOption.timeout,
  3398.               this.cacheOption.deserialize,
  3399.           ];
  3400.           // 如果超时则删除并返回 null
  3401.           if (timeout !== TimeoutInfinite && Date.now() - timeStart > timeout) {
  3402.               this.del(key);
  3403.               return null;
  3404.           }
  3405.           try {
  3406.               return deserialize(cacheVal.val);
  3407.           }
  3408.           catch (e) {
  3409.               this.del(key);
  3410.               return null;
  3411.           }
  3412.       }
  3413.       /**
  3414.        * 根据 key 获取并刷新超时时间
  3415.        * @param key 指定的 key
  3416.        * @param cacheOption 获取的选项
  3417.        * @returns 获取到的缓存值
  3418.        * @override
  3419.        */
  3420.       touch(key) {
  3421.           const str = this.localStorage.getItem(key);
  3422.           /**
  3423.            * @type {CacheVal}
  3424.            */
  3425.           const cacheVal = safeExec(() => JSON.parse(str));
  3426.           if (isNullOrUndefined(cacheVal) ||
  3427.               isNullOrUndefined(cacheVal.cacheOption)) {
  3428.               return null;
  3429.           }
  3430.           const [timeStart, timeout, deserialize] = [
  3431.               cacheVal.cacheOption.timeStart,
  3432.               cacheVal.cacheOption.timeout,
  3433.               this.cacheOption.deserialize,
  3434.           ];
  3435.           // 如果超时则删除并返回 null
  3436.           if (timeout !== TimeoutInfinite && Date.now() - timeStart > timeout) {
  3437.               this.del(key);
  3438.               return null;
  3439.           }
  3440.           try {
  3441.               const result = deserialize(cacheVal.val);
  3442.               this.set(key, result, { timeStart: Date.now(), timeout });
  3443.               return result;
  3444.           }
  3445.           catch (e) {
  3446.               this.del(key);
  3447.               return null;
  3448.           }
  3449.       }
  3450.   }
  3451.  
  3452.   /**
  3453.    * 默认使用的 {@link ICache} 接口的缓存实现
  3454.    */
  3455.   const cache = new LocalStorageCache();
  3456.   /**
  3457.    * 缓存工具类
  3458.    * 主要实现缓存高阶函数的封装
  3459.    */
  3460.   class CacheUtil {
  3461.       /**
  3462.        * 将指定函数包装为只调用一次为缓存函数
  3463.        * @param fn 需要包装的函数
  3464.        * @param options 缓存选项对象。可选项
  3465.        * @param options.identity 缓存标识。默认为函数 {@link toString}，但有时候不太可行（继承自基类的函数）
  3466.        * @param options.timeout 缓存时间。默认为无限
  3467.        * @returns 包装后的函数
  3468.        */
  3469.       static once(fn, { identity = fn.toString(), timeout } = {}) {
  3470.           const generateKey = () => `CacheUtil.onceOfSameParam-${identity}`;
  3471.           const innerFn = new Proxy(fn, {
  3472.               apply(_, _this, args) {
  3473.                   const key = generateKey();
  3474.                   const val = cache.get(key);
  3475.                   if (val !== null) {
  3476.                       return val;
  3477.                   }
  3478.                   return compatibleAsync(Reflect.apply(_, _this, args), res => {
  3479.                       cache.set(key, res, timeout);
  3480.                       return res;
  3481.                   });
  3482.               },
  3483.           });
  3484.           return Object.assign(innerFn, {
  3485.               origin: fn,
  3486.               clear() {
  3487.                   cache.del(generateKey());
  3488.               },
  3489.           });
  3490.       }
  3491.       /**
  3492.        * 包裹函数为缓存函数
  3493.        * @param fn 一个接受一些参数并返回结果的函数
  3494.        * @param options 缓存选项对象。可选项
  3495.        * @param options.identity 缓存标识。默认为函数 {@link toString}，但有时候不太可行（继承自基类的函数）
  3496.        * @param options.timeout 缓存时间。默认为无限
  3497.        * @returns 带有缓存功能的函数
  3498.        */
  3499.       static onceOfSameParam(fn, { identity = fn.toString(), timeout } = {}) {
  3500.           const generateKey = (args) => `CacheUtil.onceOfSameParam-${identity}-${JSON.stringify(args)}`;
  3501.           const innerFn = new Proxy(fn, {
  3502.               apply(_, _this, args) {
  3503.                   const key = generateKey(args);
  3504.                   const val = cache.get(key);
  3505.                   if (val !== null) {
  3506.                       return val;
  3507.                   }
  3508.                   return compatibleAsync(Reflect.apply(_, _this, args), res => {
  3509.                       cache.set(key, res, timeout);
  3510.                       return res;
  3511.                   });
  3512.               },
  3513.           });
  3514.           return Object.assign(innerFn, {
  3515.               origin: fn,
  3516.               clear(...args) {
  3517.                   cache.del(generateKey(args));
  3518.               },
  3519.           });
  3520.       }
  3521.   }
  3522.   /**
  3523.    * 导出一个默认的缓存工具对象
  3524.    * @deprecated 已废弃，请直接使用类的静态函数
  3525.    */
  3526.   const cacheUtil = CacheUtil;
  3527.  
  3528.   /**
  3529.    * 一个空的函数
  3530.    * @param args 接受任何参数
  3531.    */
  3532.   function emptyFunc(...args) { }
  3533.  
  3534.   /**
  3535.    * 禁止他人调试网站相关方法的集合对象
  3536.    */
  3537.   class AntiDebug {
  3538.       /**
  3539.        * 不停循环 debugger 防止有人调试代码
  3540.        * @returns 取消函数
  3541.        */
  3542.       static cyclingDebugger() {
  3543.           const res = setInterval(() => {
  3544.               debugger;
  3545.           }, 100);
  3546.           return () => clearInterval(res);
  3547.       }
  3548.       /**
  3549.        * 检查是否正在 debugger 并调用回调函数
  3550.        * @param fn 回调函数，默认为重载页面
  3551.        * @returns 取消函数
  3552.        */
  3553.       static checkDebug(fn = () => window.location.reload()) {
  3554.           const res = setInterval(() => {
  3555.               const diff = timing(() => {
  3556.                   for (let i = 0; i < 1000; i++) {
  3557.                       console.log(i);
  3558.                       console.clear();
  3559.                   }
  3560.               });
  3561.               if (diff > 500) {
  3562.                   console.log(diff);
  3563.                   fn();
  3564.               }
  3565.           }, 1000);
  3566.           return () => clearInterval(res);
  3567.       }
  3568.       /**
  3569.        * 禁用控制台调试输出
  3570.        * @returns 取消函数
  3571.        */
  3572.       static disableConsoleOutput() {
  3573.           if (!window.console) {
  3574.               return emptyFunc;
  3575.           }
  3576.           const map = arrayToMap(Object.keys(console), returnItself, k => {
  3577.               // @ts-ignore
  3578.               const temp = console[k];
  3579.               // @ts-ignore
  3580.               console[k] = emptyFunc;
  3581.               return temp;
  3582.           });
  3583.           return () => {
  3584.               for (const [k, v] of map) {
  3585.                   // @ts-ignore
  3586.                   console[k] = v;
  3587.               }
  3588.           };
  3589.       }
  3590.   }
  3591.   /**
  3592.    * 禁止他人调试网站相关方法的集合对象
  3593.    * @deprecated 已废弃，请直接使用类的静态函数
  3594.    */
  3595.   const antiDebug = AntiDebug;
  3596.  
  3597.   /**
  3598.    * 判断一个字符串是否为空白的字符串
  3599.    * @param str 字符串
  3600.    * @returns 是否为空字符串
  3601.    * @deprecated 已废弃，请使用 {@link stringValidator#isBlank}
  3602.    */
  3603.   function isBlank(str) {
  3604.       return stringValidator.isBlank(str);
  3605.   }
  3606.  
  3607.   /**
  3608.    * 判断一个字符串是否为空字符串
  3609.    * @param str 字符串
  3610.    * @returns 是否为空字符串
  3611.    * @deprecated 已废弃，请使用 {@link stringValidator#isEmpty}
  3612.    */
  3613.   function isEmpty(str) {
  3614.       return stringValidator.isEmpty(str);
  3615.   }
  3616.  
  3617.   /**
  3618.    * 加载一个远程脚本文件
  3619.    * @param src 远程脚本路径
  3620.    * @returns 等待异步加载脚本完成
  3621.    */
  3622.   function loadScript(src) {
  3623.       return new Promise((resolve, reject) => {
  3624.           const script = document.createElement('script');
  3625.           script.src = src;
  3626.           script.addEventListener('load', () => resolve());
  3627.           script.addEventListener('error', reject);
  3628.           document.body.appendChild(script);
  3629.       });
  3630.   }
  3631.  
  3632.   /**
  3633.    * 将一个谓词函数取反
  3634.    * 如果是同步函数，则返回的函数也是同步的，否则返回的是取反后的异步函数
  3635.    * @param fn 要取反的函数
  3636.    * @returns 取反得到的函数
  3637.    * @deprecated 已废弃，请使用 {@link CombinedPredicate.not} 进行为此取反
  3638.    */
  3639.   function deny(fn) {
  3640.       return CombinedPredicate.not(fn);
  3641.   }
  3642.  
  3643.   /**
  3644.    * 数组校验器
  3645.    */
  3646.   class ArrayValidator {
  3647.       /**
  3648.        * 是否为空数组
  3649.        * @param array 空数组
  3650.        * @returns 是否为空数组
  3651.        */
  3652.       static isEmpty(array) {
  3653.           return (isNullOrUndefined(array) ||
  3654.               !(array instanceof Array) ||
  3655.               array.length === 0);
  3656.       }
  3657.   }
  3658.   /**
  3659.    * 导出一个默认的数组校验对象
  3660.    * @deprecated 已废弃，请直接使用类的静态函数
  3661.    */
  3662.   const arrayValidator = ArrayValidator;
  3663.  
  3664.   /**
  3665.    * 路径工具
  3666.    */
  3667.   class PathUtil {
  3668.       /**
  3669.        * 拼接多个路径
  3670.        *
  3671.        * @param paths 路径数组
  3672.        * @return {String} 拼接完成的路径
  3673.        */
  3674.       static join(...paths) {
  3675.           return paths.reduce(PathUtil._join);
  3676.       }
  3677.       /**
  3678.        * 拼接两个路径
  3679.        *
  3680.        * @param pathStart 开始路径
  3681.        * @param pathEnd   结束路径
  3682.        * @return {String} 拼接完成的两个路径
  3683.        */
  3684.       static _join(pathStart, pathEnd) {
  3685.           if (pathStart.endsWith(PathUtil.Separator)) {
  3686.               return (pathStart + pathEnd).replace(PathUtil.Separator + PathUtil.Separator, PathUtil.Separator);
  3687.           }
  3688.           if (pathEnd.startsWith(PathUtil.Separator)) {
  3689.               return pathStart + pathEnd;
  3690.           }
  3691.           return pathStart + PathUtil.Separator + pathEnd;
  3692.       }
  3693.   }
  3694.   /**
  3695.    * 路径分隔符
  3696.    */
  3697.   PathUtil.Separator = '/';
  3698.   /**
  3699.    * 导出一个路径工具类
  3700.    * @deprecated 已废弃，请直接使用类的静态函数
  3701.    */
  3702.   const pathUtil = PathUtil;
  3703.  
  3704.   /**
  3705.    * 自定义的日志类
  3706.    * 主要便于在开发环境下正常显示调试信息，在生产环境则默认关闭它
  3707.    */
  3708.   class Logger {
  3709.       /**
  3710.        * 构造函数
  3711.        * @param options 可选项
  3712.        * @param options.enable 是否开启日志
  3713.        */
  3714.       constructor({ enable = true } = {}) {
  3715.           this.debug = console.debug;
  3716.           this.error = console.error;
  3717.           this.info = console.info;
  3718.           this.log = console.log;
  3719.           this.warn = console.warn;
  3720.           this.dir = console.dir;
  3721.           this.dirxml = console.dirxml;
  3722.           this.table = console.table;
  3723.           this.trace = console.trace;
  3724.           this.group = console.group;
  3725.           this.groupCollapsed = console.groupCollapsed;
  3726.           this.groupEnd = console.groupEnd;
  3727.           this.clear = console.clear;
  3728.           this.count = console.count;
  3729.           this.assert = console.assert;
  3730.           this.profile = console.profile;
  3731.           this.profileEnd = console.profileEnd;
  3732.           this.time = console.time;
  3733.           this.timeEnd = console.timeEnd;
  3734.           this.timeStamp = console.timeStamp;
  3735.           this._enable = enable;
  3736.       }
  3737.       /**
  3738.        * 设置 enable 的 setter 属性，在改变时合并对应的子类对象实现
  3739.        * @param enable 是否开启
  3740.        */
  3741.       set enable(enable) {
  3742.           /**
  3743.            * @field 是否开启全局控制台，该属性只写
  3744.            */
  3745.           this._enable = enable;
  3746.           Object.keys(console).forEach(
  3747.           // @ts-ignore
  3748.           k => (this[k] = enable ? console[k] : emptyFunc));
  3749.       }
  3750.   }
  3751.   /**
  3752.    * 导出一个全局可用的 Logger 对象
  3753.    * 使用 enable 属性控制是否开启日志输出，默认为 true
  3754.    */
  3755.   const logger = new Logger();
  3756.  
  3757.   /**
  3758.    * 将 Object 对象 转换为 Map
  3759.    * @param obj Object 对象
  3760.    * @returns 转换得到的 Map 键值表
  3761.    */
  3762.   function objectToMap(obj) {
  3763.       return Object.keys(obj).reduce((map, k) => map.set(k, Reflect.get(obj, k)), new Map());
  3764.   }
  3765.  
  3766.   /**
  3767.    * 将列表转换为树节点
  3768.    * 注: 该函数默认树的根节点只有一个，如果有多个，则返回一个数组
  3769.    * @param list 树节点列表
  3770.    * @param options 其他选项
  3771.    * @returns 树节点，或是树节点列表
  3772.    */
  3773.   function listToTree(list, { bridge = returnItself, isRoot = node => !node.parentId, } = {}) {
  3774.       const arr = [];
  3775.       const res = list.reduce((root, _sub) => {
  3776.           const sub = bridge(_sub);
  3777.           if (isRoot(sub)) {
  3778.               root.push(sub);
  3779.               return root;
  3780.           }
  3781.           for (const _parent of list) {
  3782.               const parent = bridge(_parent);
  3783.               if (sub.parentId === parent.id) {
  3784.                   parent.child = parent.child || [];
  3785.                   parent.child.push(sub);
  3786.                   return root;
  3787.               }
  3788.           }
  3789.           return root;
  3790.       }, arr);
  3791.       // 根据顶级节点的数量决定如何返回
  3792.       const len = res.length;
  3793.       if (len === 0)
  3794.           return {};
  3795.       if (len === 1)
  3796.           return res[0];
  3797.       return res;
  3798.   }
  3799.  
  3800.   /**
  3801.    * 桥接对象不存在的字段
  3802.    * @param map 代理的字段映射 Map
  3803.    * @returns 转换一个对象为代理对象
  3804.    */
  3805.   function bridge(map) {
  3806.       /**
  3807.        * 为对象添加代理的函数
  3808.        * @param obj 任何对象
  3809.        * @returns 代理后的对象
  3810.        */
  3811.       return function (obj) {
  3812.           return new Proxy(obj, {
  3813.               get(_, k) {
  3814.                   if (Reflect.has(map, k)) {
  3815.                       return Reflect.get(_, Reflect.get(map, k));
  3816.                   }
  3817.                   return Reflect.get(_, k);
  3818.               },
  3819.               set(_, k, v) {
  3820.                   if (Reflect.has(map, k)) {
  3821.                       Reflect.set(_, Reflect.get(map, k), v);
  3822.                       return true;
  3823.                   }
  3824.                   Reflect.set(_, k, v);
  3825.                   return true;
  3826.               },
  3827.           });
  3828.       };
  3829.   }
  3830.  
  3831.   /**
  3832.    * 遍历并映射一棵树的每个节点
  3833.    * @param root 树节点
  3834.    * @param options 其他选项
  3835.    * @returns 递归遍历后的树节点
  3836.    */
  3837.   function treeMapping(root, { before = returnItself, after = returnItself, paramFn = (node, ...args) => [], } = {}) {
  3838.       /**
  3839.        * 遍历一颗完整的树
  3840.        * @param node 要遍历的树节点
  3841.        * @param args 每次递归遍历时的参数
  3842.        */
  3843.       function _treeMapping(node, ...args) {
  3844.           // 之前的操作
  3845.           const _node = before(node, ...args);
  3846.           const _child = _node.child;
  3847.           if (!arrayValidator.isEmpty(_child)) {
  3848.               _node.child = _child.map(v => 
  3849.               // 产生一个参数
  3850.               _treeMapping(v, ...paramFn(_node, ...args)));
  3851.           }
  3852.           // 之后的操作
  3853.           return after(_node, ...args);
  3854.       }
  3855.       return _treeMapping(root);
  3856.   }
  3857.  
  3858.   /**
  3859.    * 将树节点转为树节点列表
  3860.    * 这里使用了循环进行遍历，而非传统的递归方式
  3861.    * @param root 树节点
  3862.    * @param options 其他选项
  3863.    * @returns 树节点列表
  3864.    */
  3865.   function treeToList(root, { calcPath = false, bridge = returnItself, } = {}) {
  3866.       const res = [];
  3867.       const temp = bridge(root);
  3868.       if (calcPath) {
  3869.           temp.path = temp.id + '';
  3870.       }
  3871.       // 利用队列缓存所有未处理的节点
  3872.       const queue = [temp];
  3873.       // 使用 Set 防止可能的重复引用
  3874.       const filterSet = new Set();
  3875.       // 使用 lastIdMap 避免重复添加
  3876.       const lastIdMap = new Map();
  3877.       for (let value; queue.length > 0;) {
  3878.           const first = queue.shift();
  3879.           value = bridge(first);
  3880.           // 判断重复
  3881.           if (value === undefined || filterSet.has(first)) {
  3882.               continue;
  3883.           }
  3884.           filterSet.add(first);
  3885.           res.push(value);
  3886.           const child = value.child;
  3887.           if (ArrayValidator.isEmpty(child)) {
  3888.               continue;
  3889.           }
  3890.           const childNonIllegal = child.filter(v => !isNullOrUndefined(v) || filterSet.has(v));
  3891.           // TODO 这里和上面的代码明显重复，待优化。。。
  3892.           queue.push(...(calcPath
  3893.               ? childNonIllegal.map(v => {
  3894.                   const _v = bridge(v);
  3895.                   // 如果最后一个的 id 等于自身，说明已经被添加过了
  3896.                   if (lastIdMap.get(_v.id) === _v.id) {
  3897.                       return _v;
  3898.                   }
  3899.                   // 使用父节点绝对路径 + 当前 id
  3900.                   _v.path = value.path + ',' + _v.id;
  3901.                   lastIdMap.set(_v.id, _v.id);
  3902.                   return _v;
  3903.               })
  3904.               : childNonIllegal));
  3905.       }
  3906.       return res;
  3907.   }
  3908.  
  3909.   /**
  3910.    * 树节点桥接工具类
  3911.    * 主要实现了桥接 {@field bridge} {@field bridgeTree} 和 {@field bridgeList} 三个函数，事实上桥接之后再转换相当于做了两遍，但就目前而言暂且只能如此了
  3912.    */
  3913.   class NodeBridgeUtil {
  3914.       /**
  3915.        * 桥接对象为标准的树结构
  3916.        * @param nodeBridge 桥接对象
  3917.        * @returns 代理函数
  3918.        */
  3919.       static bridge({ id = 'id', parentId = 'parentId', child = 'child', path = 'path', } = {}) {
  3920.           return bridge({
  3921.               id,
  3922.               parentId,
  3923.               child,
  3924.               path,
  3925.           });
  3926.       }
  3927.       /**
  3928.        * 桥接一棵完整的树
  3929.        * @param tree 树节点
  3930.        * @param nodeBridge 桥接对象
  3931.        * @returns 代理后的树对象
  3932.        */
  3933.       static bridgeTree(tree, nodeBridge) {
  3934.           return treeMapping(tree, {
  3935.               before: this.bridge(nodeBridge),
  3936.           });
  3937.       }
  3938.       /**
  3939.        * 桥接一个树节点列表
  3940.        * @param list 树节点列表
  3941.        * @param nodeBridge 桥接对象
  3942.        * @returns 代理后的树节点列表
  3943.        */
  3944.       static bridgeList(list, nodeBridge) {
  3945.           return list.map(this.bridge(nodeBridge));
  3946.       }
  3947.   }
  3948.   /**
  3949.    * 导出一个 NodeBridgeUtil 的实例
  3950.    * @deprecated 已废弃，请直接使用类的静态函数
  3951.    */
  3952.   const nodeBridgeUtil = NodeBridgeUtil;
  3953.  
  3954.   /**
  3955.    * 获取对象中所有的属性及对应的值，包括 ES6 新增的 Symbol 类型的属性
  3956.    * @param obj 任何对象
  3957.    * @returns 属性及其对应值的二维数组
  3958.    * @deprecated 该函数将要被废弃，实质上应用场景很窄
  3959.    */
  3960.   function getObjectEntries(obj) {
  3961.       const mFn = k => [
  3962.           k,
  3963.           Reflect.get(obj, k),
  3964.       ];
  3965.       return Reflect.ownKeys(obj).map(mFn);
  3966.   }
  3967.  
  3968.   /**
  3969.    * 获取对象中所有的属性，包括 ES6 新增的 Symbol 类型的属性
  3970.    * @param obj 任何对象
  3971.    * @returns 属性数组
  3972.    * @deprecated 已废弃，请使用 ES6 {@see Reflect.ownKeys} 代替
  3973.    * 具体参考 {@url(https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect/ownKeys)}
  3974.    */
  3975.   function getObjectKeys(obj) {
  3976.       if (isNullOrUndefined(obj)) {
  3977.           return [];
  3978.       }
  3979.       return Reflect.ownKeys(obj);
  3980.   }
  3981.  
  3982.   /**
  3983.    * 比较两个浮点数是否相等
  3984.    * 具体实现采用差值取绝对值并与 {@link Number.EPSILON} 比较的方式，如果小于浮点数最小差值，则认为它们是 [相等] 的
  3985.    * @param num1 第一个浮点数
  3986.    * @param num2 第二个浮点数
  3987.    * @returns 两数是否相等
  3988.    */
  3989.   function floatEquals(num1, num2) {
  3990.       return Math.abs(num1 - num2) < Number.EPSILON;
  3991.   }
  3992.  
  3993.   //TODO 暂时绕过类型错误，之后有时间再修
  3994.   // export function assign<T, A>(target: T, a: A): T & A
  3995.   // export function assign<T, A, B>(target: T, a: A, b: B): T & A & B
  3996.   // export function assign<T, A, B, C>(target: T, a: A, b: B, c: C): T & A & B & C
  3997.   // export function assign<T, A, B, C, D>(
  3998.   //   target: T,
  3999.   //   a: A,
  4000.   //   b: B,
  4001.   //   c: C,
  4002.   //   d: D,
  4003.   // ): T & A & B & C & D
  4004.   /**
  4005.    * 合并多个对象的属性
  4006.    * 1. 该合并的方式为浅层合并，只会合并一层的对象
  4007.    * 2. 默认忽略值为 undefined/null 的属性
  4008.    * @param target 覆盖的对象上
  4009.    * @param  {...Object} sources 任意数量的对象
  4010.    * @returns 合并后的对象
  4011.    */
  4012.   function assign(target, ...sources) {
  4013.       return [target, ...sources].reduce((res, source) => {
  4014.           if (isNullOrUndefined(source)) {
  4015.               return res;
  4016.           }
  4017.           return Object.keys(source).reduce((res, k) => {
  4018.               const v = Reflect.get(source, k);
  4019.               if (isNullOrUndefined(v)) {
  4020.                   return res;
  4021.               }
  4022.               Reflect.set(res, k, v);
  4023.               return res;
  4024.           }, res);
  4025.       }, {});
  4026.   }
  4027.  
  4028.   /**
  4029.    * 根据不同的源对象获取不同的正则匹配，代表不需要拷贝的属性
  4030.    * @param source 源对象
  4031.    * @returns 匹配内部属性的正则表达式
  4032.    */
  4033.   function getInnerFieldRule(source) {
  4034.       if (source instanceof Function) {
  4035.           return /^(?:constructor|prototype|arguments|caller|name|bind|call|apply|toString|length)$/;
  4036.       }
  4037.       else {
  4038.           return /^(?:toString|length)$/;
  4039.       }
  4040.   }
  4041.   /**
  4042.    * 拷贝对象的属性到目标对象上
  4043.    * @param target 目标对象
  4044.    * @param source 源对象
  4045.    * @returns 返回 {@param target} 目标对象
  4046.    */
  4047.   function _copyProps(target, source) {
  4048.       const innerField = getInnerFieldRule(source);
  4049.       Reflect.ownKeys(source).forEach(prop => {
  4050.           if (typeof prop === 'string' && innerField.test(prop)) {
  4051.               return;
  4052.           }
  4053.           Reflect.set(target, prop, Reflect.get(source, prop));
  4054.       });
  4055.       return target;
  4056.   }
  4057.   /**
  4058.    * 混合多个类
  4059.    * @param  {...Class} mixins 需要混合的多个类及其构造函数参数映射函数的 Map 集合
  4060.    * @returns 返回一个混合后的类，构造函数将的参数
  4061.    */
  4062.   function aggregation(mixins) {
  4063.       const arr = Array.from(mixins);
  4064.       class Aggregate {
  4065.           /**
  4066.            * @param args 任意数量的参数
  4067.            */
  4068.           constructor(...args) {
  4069.               arr.forEach(([Mixin, fn = returnItself]) => _copyProps(this, new Mixin(...fn(args))));
  4070.           }
  4071.       }
  4072.       arr.forEach(([Mixin]) => {
  4073.           _copyProps(Aggregate.prototype, Mixin.prototype);
  4074.           _copyProps(Aggregate, Mixin);
  4075.       });
  4076.       return Aggregate;
  4077.   }
  4078.  
  4079.   /**
  4080.    * 包装一个异步函数为有限制并发功能的函数
  4081.    * @param fn 异步函数
  4082.    * @param options 可选参数
  4083.    * @param options.limit 并发限制数量，默认为 1
  4084.    * @returns 返回被包装后的限制并发功能的函数
  4085.    */
  4086.   function asyncLimiting(fn, { limit = 1 } = {}) {
  4087.       // 当前正在执行异步的数量
  4088.       let execCount = 0;
  4089.       // waitArr 等待的队列
  4090.       const takeQueue = [];
  4091.       // 是否增加了 execCount 的标记
  4092.       let flag = false;
  4093.       return new Proxy(fn, {
  4094.           apply(_, _this, args) {
  4095.               return __awaiter(this, void 0, void 0, function* () {
  4096.                   const _takeRun = () => __awaiter(this, void 0, void 0, function* () {
  4097.                       if (!flag) {
  4098.                           execCount++;
  4099.                           flag = false;
  4100.                       }
  4101.                       const tempArgs = takeQueue.shift();
  4102.                       try {
  4103.                           return yield Reflect.apply(_, _this, tempArgs);
  4104.                       }
  4105.                       finally {
  4106.                           execCount--;
  4107.                       }
  4108.                   });
  4109.                   takeQueue.push(args);
  4110.                   yield wait(() => {
  4111.                       const result = execCount < limit;
  4112.                       // 如果等待结束则必须立刻增加 execCount，避免微任务与宏任务调度可能产生错误
  4113.                       if (result) {
  4114.                           flag = true;
  4115.                           execCount++;
  4116.                       }
  4117.                       return result;
  4118.                   });
  4119.                   return _takeRun();
  4120.               });
  4121.           },
  4122.       });
  4123.   }
  4124.  
  4125.   /**
  4126.    * 默认的超时时间，可以认为是无限
  4127.    */
  4128.   const TimeoutInfinity = () => false;
  4129.   /**
  4130.    * 创建一个 Lock 对象，用于锁住当前的当前的异步流程
  4131.    */
  4132.   class Locker {
  4133.       /**
  4134.        * @param options 可选项
  4135.        * @param options.limit 限制并发数量，默认为 1
  4136.        * @param options.timeout 超时时间，默认为无限
  4137.        */
  4138.       constructor({ limit = 1, timeout } = {}) {
  4139.           this.limit = limit;
  4140.           this.timeout = timeout || TimeoutInfinity;
  4141.       }
  4142.       /**
  4143.        * 当前是否锁住了
  4144.        * @returns 是否锁住了
  4145.        */
  4146.       isLocked() {
  4147.           return this.limit <= 0;
  4148.       }
  4149.       /**
  4150.        * 添加异步锁
  4151.        * @param timeout 超时时间，默认为全局 timeout
  4152.        * @returns 进行等待
  4153.        */
  4154.       lock(timeout = this.timeout) {
  4155.           return __awaiter(this, void 0, void 0, function* () {
  4156.               if (this.isLocked()) {
  4157.                   /**
  4158.                    * @type {Number|Function}
  4159.                    */
  4160.                   yield Promise.race([
  4161.                       wait(() => {
  4162.                           const result = !this.isLocked();
  4163.                           if (result) {
  4164.                               this.limit--;
  4165.                           }
  4166.                           return result;
  4167.                       }),
  4168.                       wait(timeout),
  4169.                   ]);
  4170.               }
  4171.               else {
  4172.                   this.limit--;
  4173.               }
  4174.           });
  4175.       }
  4176.       /**
  4177.        * 删除异步锁
  4178.        */
  4179.       unlock() {
  4180.           this.limit++;
  4181.       }
  4182.   }
  4183.  
  4184.   /**
  4185.    * 包装一个函数为有错误重试功能的函数
  4186.    * 注: 如果发生错误，最终将抛出最后一次调用的异常
  4187.    * @param fn 需要被包装的函数
  4188.    * @param num 调用的次数。默认为 1
  4189.    * @param errorCheck 检查返回结果是否需要重试的函数。默认只要 resolve() 就返回 true
  4190.    * @returns 包装后的有错误重试功能的函数
  4191.    */
  4192.   function trySometime(fn, num = 1, errorCheck = res => true) {
  4193.       return new Proxy(fn, {
  4194.           apply(target, thisArg, args) {
  4195.               return __awaiter(this, void 0, void 0, function* () {
  4196.                   let err;
  4197.                   for (let i = 0; i < num; i++) {
  4198.                       try {
  4199.                           // 等待结果出来
  4200.                           const res = yield Reflect.apply(target, thisArg, args);
  4201.                           // 如果没问题就直接返回了
  4202.                           if (errorCheck(res)) {
  4203.                               return res;
  4204.                           }
  4205.                           // 否则抛出异常以进行下一次重试
  4206.                           throw res;
  4207.                       }
  4208.                       catch (error) {
  4209.                           err = error;
  4210.                       }
  4211.                   }
  4212.                   throw err;
  4213.               });
  4214.           },
  4215.       });
  4216.   }
  4217.  
  4218.   /**
  4219.    * 包装一个函数为有错误重试功能的函数
  4220.    * 注意: 该函数是并行运行，所以一旦调用，就会同时调用 n 次，不管之前有没有失败。。。此函数不适合包装有副作用的操作，例如修改用户信息，请使用 {@link trySometime} 替代
  4221.    * @param fn 需要被包装的函数
  4222.    * @param num 调用的次数。默认为 1
  4223.    * @param errorCheck 检查返回结果是否需要重试的函数。默认只要 resolve() 就返回 true
  4224.    * @returns 包装后的有错误重试功能的函数
  4225.    */
  4226.   function trySometimeParallel(fn, num = 1, errorCheck = res => true) {
  4227.       return new Proxy(fn, {
  4228.           apply(target, thisArg, args) {
  4229.               return __awaiter(this, void 0, void 0, function* () {
  4230.                   return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
  4231.                       let err;
  4232.                       try {
  4233.                           yield Promise.all(range(0, num).map(() => __awaiter(this, void 0, void 0, function* () {
  4234.                               try {
  4235.                                   const res = yield Reflect.apply(target, thisArg, args);
  4236.                                   if (errorCheck(res) === true) {
  4237.                                       resolve(res);
  4238.                                   }
  4239.                                   throw res;
  4240.                               }
  4241.                               catch (error) {
  4242.                                   err = error;
  4243.                               }
  4244.                           })));
  4245.                       }
  4246.                       catch (error) {
  4247.                           console.log(error);
  4248.                       }
  4249.                       reject(err);
  4250.                   }));
  4251.               });
  4252.           },
  4253.       });
  4254.   }
  4255.  
  4256.   /**
  4257.    * 深度比较两个对象是否相等
  4258.    * @param x 任何对象
  4259.    * @param y 任何对象
  4260.    * @returns 是否相等
  4261.    */
  4262.   function compare(x, y) {
  4263.       if ((typeof x === 'number' || x instanceof Number) &&
  4264.           (typeof y === 'number' || y instanceof Number)) {
  4265.           const _x = +x;
  4266.           const _y = +y;
  4267.           // 如果都是 NaN 则直接返回 true
  4268.           if (isNaN(_x) && isNaN(_y)) {
  4269.               return true;
  4270.           }
  4271.           // 如果是 -0/+0 则返回 false
  4272.           if (_x === _y) {
  4273.               return 1 / _x === 1 / _y;
  4274.           }
  4275.           // 如果均为数字且两数之差的绝对值小于浮点数的最小精度（此举主要是为了避免浮点数的精度丢失）
  4276.           if (Math.abs(_x - _y) < Number.EPSILON) {
  4277.               return true;
  4278.           }
  4279.       }
  4280.       // 如果恒等表达式成立则直接返回 true
  4281.       if (x === y) {
  4282.           return true;
  4283.       }
  4284.       // 比较正则和字符串
  4285.       if ((x instanceof RegExp && y instanceof RegExp) ||
  4286.           ((typeof x === 'string' || x instanceof String) &&
  4287.               (typeof y === 'string' || y instanceof String))) {
  4288.           return x.toString() === y.toString();
  4289.       }
  4290.       // 如果都是时间则比较它们的时间戳
  4291.       if (x instanceof Date && y instanceof Date) {
  4292.           return x.getTime() === y.getTime();
  4293.       }
  4294.       // 如果两者有一个不是 Object 类型的话则直接返回 false
  4295.       // 注: 此处直接返回 false 是因为特殊原生类型的都在上面处理过了
  4296.       // 注: Array 可以按照 Object 的逻辑进行处理
  4297.       if (!(x instanceof Object && y instanceof Object)) {
  4298.           return false;
  4299.       }
  4300.       // 比较它们的原型
  4301.       if (x.prototype !== y.prototype) {
  4302.           return false;
  4303.       }
  4304.       // 比较构造函数
  4305.       if (x.constructor !== y.constructor) {
  4306.           return false;
  4307.       }
  4308.       // 比较 y 中的属性是否全部都在 x 中
  4309.       for (const p of Object.keys(y)) {
  4310.           if (!Reflect.has(x, p)) {
  4311.               return false;
  4312.           }
  4313.       }
  4314.       // 比较 x 中的属性是否全部都在 y 中
  4315.       for (const p of Object.keys(x)) {
  4316.           if (!Reflect.has(y, p)) {
  4317.               return false;
  4318.           }
  4319.           // 比较每个元素的类型，如果不同则直接返回 false
  4320.           if (typeof y[p] !== typeof x[p]) {
  4321.               return false;
  4322.           }
  4323.           // 递归比较每个元素
  4324.           if (!compare(x[p], y[p])) {
  4325.               return false;
  4326.           }
  4327.       }
  4328.       // 全部比较完成仍然没有结果就返回 true
  4329.       return true;
  4330.   }
  4331.  
  4332.   /**
  4333.    * 阻塞主线程指定时间
  4334.    * 注: 和 {@see wait} 不同，该函数会真的阻塞住主线程，即这段时间内其他的代码都无法执行，例如用户的点击事件！
  4335.    * @param time 阻塞毫秒数
  4336.    */
  4337.   function sleep(time) {
  4338.       const end = performance.now() + time;
  4339.       while (performance.now() <= end) { }
  4340.   }
  4341.  
  4342.   /**
  4343.    * 包装一个函数为异步函数
  4344.    * 如果是一个异步函数，则直接返回，否则返回一部函数
  4345.    * @param fn 任意一个函数
  4346.    * @returns 返回的异步结果 Promise 对象
  4347.    * @typeparam R 原函数函数返回值类型
  4348.    */
  4349.   function async(fn) {
  4350.       return new Proxy(fn, {
  4351.           apply(_, _this, args) {
  4352.               return __awaiter(this, void 0, void 0, function* () {
  4353.                   return yield Reflect.apply(_, _this, args);
  4354.               });
  4355.           },
  4356.       });
  4357.   }
  4358.  
  4359.   /**
  4360.    * 将一个异步函数包装为具有时序的异步函数
  4361.    * 注: 该函数会按照调用顺序依次返回结果，后面的调用的结果需要等待前面的，所以如果不关心过时的结果，请使用 {@link switchMap} 函数
  4362.    * @param fn 一个普通的异步函数
  4363.    * @returns 包装后的函数
  4364.    */
  4365.   function mergeMap(fn) {
  4366.       // 当前执行的异步操作 id
  4367.       let id = 0;
  4368.       // 所执行的异步操作 id 列表
  4369.       const ids = new Set();
  4370.       return new Proxy(fn, {
  4371.           apply(_, _this, args) {
  4372.               return __awaiter(this, void 0, void 0, function* () {
  4373.                   const prom = Reflect.apply(_, _this, args);
  4374.                   const temp = id;
  4375.                   ids.add(temp);
  4376.                   id++;
  4377.                   yield wait(() => !ids.has(temp - 1));
  4378.                   ids.delete(temp);
  4379.                   return yield prom;
  4380.               });
  4381.           },
  4382.       });
  4383.   }
  4384.  
  4385.   /**
  4386.    * 将一个异步函数包装为具有时序的异步函数
  4387.    * 注: 该函数会丢弃过期的异步操作结果，这样的话性能会稍稍提高（主要是响应比较快的结果会立刻生效而不必等待前面的响应结果）
  4388.    * @param fn 一个普通的异步函数
  4389.    * @returns 包装后的函数
  4390.    */
  4391.   function switchMap(fn) {
  4392.       // 当前执行的异步操作 id
  4393.       let id = 0;
  4394.       // 最后一次异步操作的 id，小于这个的操作结果会被丢弃
  4395.       let last = 0;
  4396.       // 缓存最后一次异步操作的结果
  4397.       let cache;
  4398.       return new Proxy(fn, {
  4399.           apply(_, _this, args) {
  4400.               return __awaiter(this, void 0, void 0, function* () {
  4401.                   const temp = id;
  4402.                   id++;
  4403.                   const res = yield Reflect.apply(_, _this, args);
  4404.                   if (temp < last) {
  4405.                       return cache;
  4406.                   }
  4407.                   cache = res;
  4408.                   last = temp;
  4409.                   return res;
  4410.               });
  4411.           },
  4412.       });
  4413.   }
  4414.  
  4415.   /**
  4416.    * 将指定函数包装为只调用一次
  4417.    * @param fn 需要包装的函数
  4418.    * @returns 包装后的函数
  4419.    */
  4420.   function once(fn) {
  4421.       let flag = true;
  4422.       let cache;
  4423.       const res = new Proxy(fn, {
  4424.           apply(target, thisArg, args) {
  4425.               if (flag === false) {
  4426.                   return cache;
  4427.               }
  4428.               flag = false;
  4429.               // 如果是异步函数则返回异步的结果
  4430.               return compatibleAsync(Reflect.apply(target, thisArg, args), res => {
  4431.                   cache = res;
  4432.                   return cache;
  4433.               });
  4434.           },
  4435.       });
  4436.       return Object.assign(res, {
  4437.           origin: fn,
  4438.           clear() {
  4439.               cache = null;
  4440.           },
  4441.       });
  4442.   }
  4443.  
  4444.   /**
  4445.    * 将一个异步函数包装为具有时序的异步函数
  4446.    * 注: 该函数会按照调用顺序依次返回结果，后面的执行的调用（不是调用结果）需要等待前面的，此函数适用于异步函数的内里执行也必须保证顺序时使用，否则请使用 {@link mergeMap} 函数
  4447.    * 注: 该函数其实相当于调用 {@code asyncLimiting(fn, {limit: 1})} 函数
  4448.    * 例如即时保存文档到服务器，当然要等待上一次的请求结束才能请求下一次，不然数据库保存的数据就存在谬误了
  4449.    * @param fn 一个普通的异步函数
  4450.    * @returns 包装后的函数
  4451.    */
  4452.   function concatMap(fn) {
  4453.       // 当前执行的异步操作 id
  4454.       let id = 0;
  4455.       // 所执行的异步操作 id 列表
  4456.       const ids = new Set();
  4457.       return new Proxy(fn, {
  4458.           apply(_, _this, args) {
  4459.               return __awaiter(this, void 0, void 0, function* () {
  4460.                   const temp = id;
  4461.                   ids.add(temp);
  4462.                   id++;
  4463.                   yield wait(() => !ids.has(temp - 1));
  4464.                   const prom = Reflect.apply(_, _this, args);
  4465.                   ids.delete(temp);
  4466.                   return yield prom;
  4467.               });
  4468.           },
  4469.       });
  4470.   }
  4471.  
  4472.   /**
  4473.    * 重复执行指定的函数
  4474.    * @param num 重复的次数
  4475.    * @param fn 执行的函数，如果是异步函数，则返回 Array.<Promise>
  4476.    * @param  {...Object} args 参数
  4477.    * @returns 执行返回结果
  4478.    */
  4479.   function repeatedCall(num, fn, ...args) {
  4480.       return range(0, num).map(() => fn(...args));
  4481.   }
  4482.  
  4483.   /**
  4484.    * 发布订阅模式
  4485.    * @typeparam T 订阅主题的类型，虽然可以为 any，但这里是刻意进行限制以避免 “全局” 的发布订阅中心对象
  4486.    */
  4487.   class PubSubMachine {
  4488.       constructor() {
  4489.           /**
  4490.            * 订阅者集合
  4491.            */
  4492.           this.subMap = new Map();
  4493.       }
  4494.       /**
  4495.        * 发布一个主题
  4496.        * @param topic 发布的主题
  4497.        * @param [args] 主题订阅所需要的参数
  4498.        */
  4499.       pub(topic, ...args) {
  4500.           const fns = this.subMap.get(topic);
  4501.           if (fns === undefined) {
  4502.               return;
  4503.           }
  4504.           fns.forEach(fn => fn(...args));
  4505.       }
  4506.       /**
  4507.        * 订阅一个主题
  4508.        * @param topic 订阅的主题
  4509.        * @param fn 回调的函数
  4510.        */
  4511.       sub(topic, fn) {
  4512.           if (!this.subMap.has(topic)) {
  4513.               this.subMap.set(topic, []);
  4514.           }
  4515.           this.subMap.get(topic).push(fn);
  4516.       }
  4517.       /**
  4518.        * 取消订阅
  4519.        * @param topic 订阅的主题
  4520.        * @param fn 订阅的函数，没有则删除这个主题下所有的函数
  4521.        */
  4522.       unsub(topic, fn) {
  4523.           if (fn === undefined) {
  4524.               this.subMap.delete(topic);
  4525.               return;
  4526.           }
  4527.           if (!this.subMap.has(topic)) {
  4528.               return;
  4529.           }
  4530.           const fns = this.subMap.get(topic);
  4531.           fns.splice(fns.indexOf(fn), 1);
  4532.       }
  4533.   }
  4534.  
  4535.   /**
  4536.    * 提取对象数组为 Map
  4537.    * @param arr 对象数组
  4538.    * @param fields 提取的字段
  4539.    * @returns 提取字段名对应其字段值数组的 Map
  4540.    * @typeparam T 数组元素的类型，必须为可提取字段的对象
  4541.    */
  4542.   function extractFieldMap(arr, fields) {
  4543.       return arr.reduce((res, v) => {
  4544.           for (const [k, _arr] of res) {
  4545.               _arr.push(Reflect.get(v, k));
  4546.           }
  4547.           return res;
  4548.       }, arrayToMap(fields, k => k, () => new Array()));
  4549.   }
  4550.  
  4551.   /**
  4552.    * 数组按照指定长度进行分段为二维数组
  4553.    * 注: num 必须要大于 1
  4554.    * @param arr 要进行分段的数组
  4555.    * @param num 每段的长度
  4556.    * @returns 分段后的二维数组
  4557.    */
  4558.   function segmentation(arr, num) {
  4559.       return arr.reduce((res, v, i) => {
  4560.           const index = (i + 1) % num;
  4561.           if (index === 1) {
  4562.               res.push([]);
  4563.           }
  4564.           res[res.length - 1].push(v);
  4565.           return res;
  4566.       }, new Array());
  4567.   }
  4568.  
  4569.   /**
  4570.    * 切换 DOM 元素的 class
  4571.    * @param {Element} el DOM 元素
  4572.    * @param {Object} obj 切换的状态/class 键值对象
  4573.    * @return 根据状态切换 class 的函数
  4574.    */
  4575.   function toggleClass(el, obj) {
  4576.       const arr = Array.from(Object.values(obj));
  4577.       /**
  4578.        * 返回切换 class 的函数
  4579.        * @param state 切换的状态
  4580.        */
  4581.       return function toggle(state) {
  4582.           arr.forEach(v => el.classList.remove(v));
  4583.           el.classList.add(obj[state]);
  4584.       };
  4585.   }
  4586.  
  4587.   /**
  4588.    * 将函数包装为偏函数
  4589.    * 注: 该函数模仿了 underscore 的 partial 函数
  4590.    * @param fn 需要包装的函数
  4591.    * @param  {...any} args 应用的部分参数
  4592.    * @returns 包装后的函数
  4593.    */
  4594.   function partial(fn, ...args) {
  4595.       const realArgs = args.filter(arg => arg !== partial._);
  4596.       // 如果函数参数足够则调用传入的函数
  4597.       if (realArgs.length >= fn.length) {
  4598.           return fn(...realArgs);
  4599.       }
  4600.       /**
  4601.        * 最终返回的函数
  4602.        * @param otherArgs 接受任意参数
  4603.        * @returns 返回一个函数，或者函数调用完成返回结果
  4604.        */
  4605.       function innerFn(...otherArgs) {
  4606.           // 记录需要移除补到前面的参数
  4607.           const removeIndexSet = new Set();
  4608.           let i = 0;
  4609.           const newArgs = args.map(arg => {
  4610.               if (arg !== partial._ ||
  4611.                   otherArgs[i] === undefined ||
  4612.                   otherArgs[i] === partial._) {
  4613.                   return arg;
  4614.               }
  4615.               removeIndexSet.add(i);
  4616.               // 每次补偿前面的 partial._ 参数计数器 +1
  4617.               return otherArgs[i++];
  4618.           });
  4619.           const newOtherArgs = otherArgs.filter((_v, i) => !removeIndexSet.has(i));
  4620.           return partial(fn, ...newArgs, ...newOtherArgs);
  4621.       }
  4622.       // 定义偏函数的剩余参数长度，便于在其他地方进行部分参数应用
  4623.       // 注: 不使用 length 属性的原因是 length 属性
  4624.       innerFn._length = fn.length - args.filter(arg => arg !== partial._).length;
  4625.       // 自定义 toString 函数便于调试
  4626.       innerFn.toString = () => `name: ${fn.name}, args: [${args.map(o => o.toString()).join(', ')}]`;
  4627.       innerFn._partial = true;
  4628.       return innerFn;
  4629.   }
  4630.   /**
  4631.    * 偏的占位符，需要应用后面的参数时使用
  4632.    * 例如 {@link partial(fn)(partial._, 1)} 意味着函数 fn 的第二个参数将被确定为 1
  4633.    */
  4634.   partial._ = Symbol('_');
  4635.  
  4636.   exports.AntiDebug = AntiDebug;
  4637.   exports.ArrayValidator = ArrayValidator;
  4638.   exports.AsyncArray = AsyncArray;
  4639.   exports.CacheUtil = CacheUtil;
  4640.   exports.CombinedPredicate = CombinedPredicate;
  4641.   exports.DateConstants = DateConstants;
  4642.   exports.DateFormatter = DateFormatter;
  4643.   exports.FetchLimiting = FetchLimiting;
  4644.   exports.LocalStorageCache = LocalStorageCache;
  4645.   exports.Locker = Locker;
  4646.   exports.Logger = Logger;
  4647.   exports.NodeBridgeUtil = NodeBridgeUtil;
  4648.   exports.PathUtil = PathUtil;
  4649.   exports.PubSubMachine = PubSubMachine;
  4650.   exports.StateMachine = StateMachine;
  4651.   exports.StringStyleUtil = StringStyleUtil;
  4652.   exports.StringValidator = StringValidator;
  4653.   exports.TypeValidator = TypeValidator;
  4654.   exports.aggregation = aggregation;
  4655.   exports.and = and;
  4656.   exports.antiDebug = antiDebug;
  4657.   exports.appends = appends;
  4658.   exports.arrayDiffBy = arrayDiffBy;
  4659.   exports.arrayToMap = arrayToMap;
  4660.   exports.arrayValidator = arrayValidator;
  4661.   exports.asIterator = asIterator;
  4662.   exports.assign = assign;
  4663.   exports.async = async;
  4664.   exports.asyncFlatMap = asyncFlatMap;
  4665.   exports.asyncLimiting = asyncLimiting;
  4666.   exports.autoIncrement = autoIncrement;
  4667.   exports.blankToNull = blankToNull;
  4668.   exports.blankToNullField = blankToNullField;
  4669.   exports.bridge = bridge;
  4670.   exports.cacheUtil = cacheUtil;
  4671.   exports.compare = compare;
  4672.   exports.compatibleAsync = compatibleAsync;
  4673.   exports.compose = compose;
  4674.   exports.concatMap = concatMap;
  4675.   exports.copyText = copyText;
  4676.   exports.createElByString = createElByString;
  4677.   exports.curry = curry;
  4678.   exports.dateBetween = dateBetween;
  4679.   exports.dateConstants = dateConstants;
  4680.   exports.dateEnhance = dateEnhance;
  4681.   exports.dateFormat = dateFormat;
  4682.   exports.dateParse = dateParse;
  4683.   exports.debounce = debounce;
  4684.   exports.deepFreeze = deepFreeze;
  4685.   exports.deepProxy = deepProxy;
  4686.   exports.deletes = deletes;
  4687.   exports.deny = deny;
  4688.   exports.diffBy = diffBy;
  4689.   exports.download = download;
  4690.   exports.downloadString = downloadString;
  4691.   exports.downloadUrl = downloadUrl;
  4692.   exports.emptyAllField = emptyAllField;
  4693.   exports.emptyFunc = emptyFunc;
  4694.   exports.excludeFields = excludeFields;
  4695.   exports.excludeFieldsDeep = excludeFieldsDeep;
  4696.   exports.extractFieldMap = extractFieldMap;
  4697.   exports.fetchTimeout = fetchTimeout;
  4698.   exports.fill = fill;
  4699.   exports.filterItems = filterItems;
  4700.   exports.findIndex = findIndex;
  4701.   exports.flatMap = flatMap;
  4702.   exports.floatEquals = floatEquals;
  4703.   exports.formDataToArray = formDataToArray;
  4704.   exports.format = format;
  4705.   exports.getCookies = getCookies;
  4706.   exports.getCursorPosition = getCursorPosition;
  4707.   exports.getCusorPostion = getCusorPostion;
  4708.   exports.getObjectEntries = getObjectEntries;
  4709.   exports.getObjectKeys = getObjectKeys;
  4710.   exports.getYearWeek = getYearWeek;
  4711.   exports.groupBy = groupBy;
  4712.   exports.insertText = insertText;
  4713.   exports.isBlank = isBlank;
  4714.   exports.isEditable = isEditable;
  4715.   exports.isEmpty = isEmpty;
  4716.   exports.isFloat = isFloat;
  4717.   exports.isNullOrUndefined = isNullOrUndefined;
  4718.   exports.isNumber = isNumber;
  4719.   exports.isRange = isRange;
  4720.   exports.lastFocus = lastFocus;
  4721.   exports.listToTree = listToTree;
  4722.   exports.loadResource = loadResource;
  4723.   exports.loadScript = loadScript;
  4724.   exports.logger = logger;
  4725.   exports.mapToObject = mapToObject;
  4726.   exports.mergeMap = mergeMap;
  4727.   exports.nodeBridgeUtil = nodeBridgeUtil;
  4728.   exports.not = not;
  4729.   exports.objToFormData = objToFormData;
  4730.   exports.objectToMap = objectToMap;
  4731.   exports.once = once;
  4732.   exports.onceOfSameParam = onceOfSameParam;
  4733.   exports.or = or;
  4734.   exports.parseUrl = parseUrl;
  4735.   exports.partial = partial;
  4736.   exports.pathUtil = pathUtil;
  4737.   exports.randomInt = randomInt;
  4738.   exports.range = range;
  4739.   exports.readLocal = readLocal;
  4740.   exports.removeEl = removeEl;
  4741.   exports.removeText = removeText;
  4742.   exports.repeatedCall = repeatedCall;
  4743.   exports.returnItself = returnItself;
  4744.   exports.returnReasonableItself = returnReasonableItself;
  4745.   exports.safeExec = safeExec;
  4746.   exports.segmentation = segmentation;
  4747.   exports.setCursorPosition = setCursorPosition;
  4748.   exports.setCusorPostion = setCusorPostion;
  4749.   exports.sets = sets;
  4750.   exports.singleModel = singleModel;
  4751.   exports.sleep = sleep;
  4752.   exports.sortBy = sortBy;
  4753.   exports.spliceParams = spliceParams;
  4754.   exports.strToArrayBuffer = strToArrayBuffer;
  4755.   exports.strToDate = strToDate;
  4756.   exports.stringValidator = stringValidator;
  4757.   exports.switchMap = switchMap;
  4758.   exports.throttle = throttle;
  4759.   exports.timing = timing;
  4760.   exports.toLowerCase = toLowerCase;
  4761.   exports.toObject = toObject;
  4762.   exports.toString = toString$1;
  4763.   exports.toUpperCase = toUpperCase;
  4764.   exports.toggleClass = toggleClass;
  4765.   exports.treeMapping = treeMapping;
  4766.   exports.treeToList = treeToList;
  4767.   exports.trySometime = trySometime;
  4768.   exports.trySometimeParallel = trySometimeParallel;
  4769.   exports.uniqueBy = uniqueBy;
  4770.   exports.wait = wait;
  4771.   exports.waitResource = waitResource;
  4772.   exports.watch = watch;
  4773.   exports.watchEventListener = watchEventListener;
  4774.   exports.watchObject = watchObject;
  4775.  
  4776.   Object.defineProperty(exports, '__esModule', { value: true });
  4777.  
  4778. }));
  4779. //# sourceMappingURL=rx-util.js.map