☰

Everything-Hook

it can hook everything

目前为 2025-01-20 提交的版本。查看 最新版本。

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.gf.qytechs.cn/scripts/509211/1523440/Everything-Hook.js 

  1. if (window.performance) window.performance.now = Date.now;
  2. (function () {
  3.     'use strict';
  4.     // 延迟执行的函数
  5.     function speedHook() {
  6.         // ==UserScript==
  7.         // @name         Everything-Hook
  8.         // @namespace    https://gitee.com/HGJing/everthing-hook/
  9.         // @updateURL    https://gitee.com/HGJing/everthing-hook/raw/master/src/everything-hook.js
  10.         // @version      0.5.9056
  11.         // @include      *
  12.         // @description  it can hook everything
  13.         // @author       Cangshi
  14.         // @match        http://*/*
  15.         // @grant        none
  16.         // @run-at       document-start
  17.         // ==/UserScript==
  18.         (function webpackUniversalModuleDefinition(root, factory) {
  19.             if (typeof exports === 'object' && typeof module === 'object')
  20.                 module.exports = factory();
  21.             else if (typeof define === 'function' && define.amd)
  22.                 define([], factory);
  23.             else {
  24.                 var a = factory();
  25.                 for (var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
  26.             }
  27.         })(typeof self !== 'undefined' ? self : this, function () {
  28.             return /******/ (() => { // webpackBootstrap
  29.     /******/ 	var __webpack_modules__ = ([
  30.     /* 0 */
  31.     /***/ (function (module, __unused_webpack_exports, __webpack_require__) {
  32.     
  33.                         "use strict";
  34.     
  35.                         /**
  36.                          * ---------------------------
  37.                          * Time: 2017/9/20 18:33.
  38.                          * Author: Cangshi
  39.                          * View: http://palerock.cn
  40.                          * ---------------------------
  41.                          */
  42.     
  43.     
  44.                         const eUtils = __webpack_require__(1);
  45.     
  46.                         ~(function (global, factory) {
  47.     
  48.                             "use strict";
  49.     
  50.                             if (true && typeof module.exports === "object") {
  51.                                 var results = factory.bind(global)(global, eUtils, true) || [];
  52.                                 var HookJS = {};
  53.                                 results.forEach(function (part) {
  54.                                     HookJS[part.name] = part.module;
  55.                                 });
  56.                                 module.exports = HookJS;
  57.                             } else {
  58.                                 factory.bind(global)(global, eUtils);
  59.                             }
  60.     
  61.                         }(typeof window !== "undefined" ? window : this, function (_global, utils, noGlobal) {
  62.                             /**
  63.                              * @namespace EHook
  64.                              * @author Cangshi
  65.                              * @constructor
  66.                              * @see {@link https://palerock.cn/projects/006HDUuOhBj}
  67.                              * @license Apache License 2.0
  68.                              */
  69.                             var EHook = function () {
  70.                                 var _autoId = 1;
  71.                                 var _hookedMap = {};
  72.                                 var _hookedContextMap = {};
  73.                                 this._getHookedMap = function () {
  74.                                     return _hookedMap;
  75.                                 };
  76.                                 this._getHookedContextMap = function () {
  77.                                     return _hookedContextMap;
  78.                                 };
  79.                                 this._getAutoStrId = function () {
  80.                                     return '__auto__' + _autoId++;
  81.                                 };
  82.                                 this._getAutoId = function () {
  83.                                     return _autoId++;
  84.                                 };
  85.                             };
  86.                             EHook.prototype = {
  87.                                 /**
  88.                                  * 获取一个对象的劫持id，若没有则创建一个
  89.                                  * @param context
  90.                                  * @return {*}
  91.                                  * @private
  92.                                  */
  93.                                 _getHookedId: function (context) {
  94.                                     var contextMap = this._getHookedContextMap();
  95.                                     var hookedId = null;
  96.                                     Object.keys(contextMap).forEach(key => {
  97.                                         if (context === contextMap[key]) {
  98.                                             hookedId = key;
  99.                                         }
  100.                                     });
  101.                                     if (hookedId == null) {
  102.                                         hookedId = this._getAutoStrId();
  103.                                         contextMap[hookedId] = context;
  104.                                     }
  105.                                     return hookedId;
  106.                                 },
  107.                                 /**
  108.                                  * 获取一个对象的劫持方法映射，若没有则创建一个
  109.                                  * @param context
  110.                                  * @return {*}
  111.                                  * @private
  112.                                  */
  113.                                 _getHookedMethodMap: function (context) {
  114.                                     var hookedId = this._getHookedId(context);
  115.                                     var hookedMap = this._getHookedMap();
  116.                                     var thisTask = hookedMap[hookedId];
  117.                                     if (!utils.isExistObject(thisTask)) {
  118.                                         thisTask = hookedMap[hookedId] = {};
  119.                                     }
  120.                                     return thisTask;
  121.                                 },
  122.                                 /**
  123.                                  * 获取对应方法的hook原型任务对象，若没有则初始化一个。
  124.                                  * @param context
  125.                                  * @param methodName
  126.                                  * @private
  127.                                  */
  128.                                 _getHookedMethodTask: function (context, methodName) {
  129.                                     var thisMethodMap = this._getHookedMethodMap(context);
  130.                                     var thisMethod = thisMethodMap[methodName];
  131.                                     if (!utils.isExistObject(thisMethod)) {
  132.                                         thisMethod = thisMethodMap[methodName] = {
  133.                                             original: undefined,
  134.                                             replace: undefined,
  135.                                             task: {
  136.                                                 before: [],
  137.                                                 current: undefined,
  138.                                                 after: []
  139.                                             }
  140.                                         };
  141.                                     }
  142.                                     return thisMethod;
  143.                                 },
  144.                                 /**
  145.                                  * 执行多个方法并注入一个方法和参数集合
  146.                                  * @param context
  147.                                  * @param methods
  148.                                  * @param args
  149.                                  * @return result 最后一次执行方法的有效返回值
  150.                                  * @private
  151.                                  */
  152.                                 _invokeMethods: function (context, methods, args) {
  153.                                     if (!utils.isArray(methods)) {
  154.                                         return;
  155.                                     }
  156.                                     var result = null;
  157.                                     utils.ergodicArrayObject(context, methods, function (_method) {
  158.                                         if (!utils.isFunction(_method.method)) {
  159.                                             return;
  160.                                         }
  161.                                         var r = _method.method.apply(this, args);
  162.                                         if (r != null) {
  163.                                             result = r;
  164.                                         }
  165.                                     });
  166.                                     return result;
  167.                                 },
  168.                                 /**
  169.                                  * 生成和替换劫持方法
  170.                                  * @param parent
  171.                                  * @param context
  172.                                  * @param methodName {string}
  173.                                  * @private
  174.                                  */
  175.                                 _hook: function (parent, methodName, context) {
  176.                                     if (context === undefined) {
  177.                                         context = parent;
  178.                                     }
  179.                                     var method = parent[methodName];
  180.                                     var methodTask = this._getHookedMethodTask(parent, methodName);
  181.                                     if (!methodTask.original) {
  182.                                         methodTask.original = method;
  183.                                     }
  184.                                     if (utils.isExistObject(methodTask.replace) && utils.isFunction(methodTask.replace.method)) {
  185.                                         parent[methodName] = methodTask.replace.method(methodTask.original);
  186.                                         return;
  187.                                     }
  188.                                     var invokeMethods = this._invokeMethods;
  189.                                     // 组装劫持函数
  190.                                     var builder = new utils.FunctionBuilder(function (v) {
  191.                                         return {
  192.                                             result: undefined
  193.                                         };
  194.                                     });
  195.                                     if (methodTask.task.before.length > 0) {
  196.                                         builder.push(function (v) {
  197.                                             invokeMethods(context || v.this, methodTask.task.before, [methodTask.original, v.arguments]);
  198.                                         });
  199.                                     }
  200.                                     if (utils.isExistObject(methodTask.task.current) && utils.isFunction(methodTask.task.current.method)) {
  201.                                         builder.push(function (v) {
  202.                                             return {
  203.                                                 result: methodTask.task.current.method.call(context || v.this, parent, methodTask.original, v.arguments)
  204.                                             }
  205.                                         });
  206.                                     } else {
  207.                                         builder.push(function (v) {
  208.                                             return {
  209.                                                 result: methodTask.original.apply(context || v.this, v.arguments)
  210.                                             }
  211.                                         });
  212.                                     }
  213.                                     if (methodTask.task.after.length > 0) {
  214.                                         builder.push(function (v) {
  215.                                             var args = [];
  216.                                             args.push(methodTask.original);
  217.                                             args.push(v.arguments);
  218.                                             args.push(v.result);
  219.                                             var r = invokeMethods(context || v.this, methodTask.task.after, args);
  220.                                             return {
  221.                                                 result: (r != null ? r : v.result)
  222.                                             };
  223.                                         });
  224.                                     }
  225.                                     builder.push(function (v) {
  226.                                         return {
  227.                                             returnValue: v.result
  228.                                         };
  229.                                     });
  230.                                     // var methodStr = '(function(){\n';
  231.                                     // methodStr = methodStr + 'var result = undefined;\n';
  232.                                     // if (methodTask.task.before.length > 0) {
  233.                                     //     methodStr = methodStr + 'invokeMethods(context, methodTask.task.before,[methodTask.original, arguments]);\n';
  234.                                     // }
  235.                                     // if (utils.isExistObject(methodTask.task.current) && utils.isFunction(methodTask.task.current.method)) {
  236.                                     //     methodStr = methodStr + 'result = methodTask.task.current.method.call(context, parent, methodTask.original, arguments);\n';
  237.                                     // } else {
  238.                                     //     methodStr = methodStr + 'result = methodTask.original.apply(context, arguments);\n';
  239.                                     // }
  240.                                     // if (methodTask.task.after.length > 0) {
  241.                                     //     methodStr = methodStr + 'var args = [];args.push(methodTask.original);args.push(arguments);args.push(result);\n';
  242.                                     //     methodStr = methodStr + 'var r = invokeMethods(context, methodTask.task.after, args);result = (r!=null?r:result);\n';
  243.                                     // }
  244.                                     // methodStr = methodStr + 'return result;\n})';
  245.                                     // 绑定劫持函数
  246.                                     var resultFunc = builder.result();
  247.                                     for (var proxyName in methodTask.original) {
  248.                                         Object.defineProperty(resultFunc, proxyName, {
  249.                                             get: function () {
  250.                                                 return methodTask.original[proxyName];
  251.                                             },
  252.                                             set: function (v) {
  253.                                                 methodTask.original[proxyName] = v;
  254.                                             }
  255.                                         })
  256.                                     }
  257.                                     resultFunc.prototype = methodTask.original.prototype;
  258.                                     parent[methodName] = resultFunc;
  259.                                 },
  260.                                 /**
  261.                                  * 劫持一个方法
  262.                                  * @inner
  263.                                  * @memberOf EHook
  264.                                  * @param parent{Object} 指定方法所在的对象
  265.                                  * @param methodName{String} 指定方法的名称
  266.                                  * @param config{Object} 劫持的配置对象
  267.                                  */
  268.                                 hook: function (parent, methodName, config) {
  269.                                     var hookedFailure = -1;
  270.                                     // 调用方法的上下文
  271.                                     var context = config.context !== undefined ? config.context : parent;
  272.                                     if (parent[methodName] == null) {
  273.                                         parent[methodName] = function () {
  274.                                         }
  275.                                     }
  276.                                     if (!utils.isFunction(parent[methodName])) {
  277.                                         return hookedFailure;
  278.                                     }
  279.                                     var methodTask = this._getHookedMethodTask(parent, methodName);
  280.                                     var id = this._getAutoId();
  281.                                     if (utils.isFunction(config.replace)) {
  282.                                         methodTask.replace = {
  283.                                             id: id,
  284.                                             method: config.replace
  285.                                         };
  286.                                         hookedFailure = 0;
  287.                                     }
  288.                                     if (utils.isFunction(config.before)) {
  289.                                         methodTask.task.before.push({
  290.                                             id: id,
  291.                                             method: config.before
  292.                                         });
  293.                                         hookedFailure = 0;
  294.                                     }
  295.                                     if (utils.isFunction(config.current)) {
  296.                                         methodTask.task.current = {
  297.                                             id: id,
  298.                                             method: config.current
  299.                                         };
  300.                                         hookedFailure = 0;
  301.                                     }
  302.                                     if (utils.isFunction(config.after)) {
  303.                                         methodTask.task.after.push({
  304.                                             id: id,
  305.                                             method: config.after
  306.                                         });
  307.                                         hookedFailure = 0;
  308.                                     }
  309.                                     if (hookedFailure === 0) {
  310.                                         this._hook(parent, methodName, context);
  311.                                         return id;
  312.                                     } else {
  313.                                         return hookedFailure;
  314.                                     }
  315.     
  316.                                 },
  317.                                 /**
  318.                                  * 劫持替换一个方法
  319.                                  * @see 注意：该方法会覆盖指定劫持方法在之前所进行的一切劫持，也不能重复使用，并且不和hookAfter,hookCurrent,hookBefore共存，在同时使用的情况下，优先使用hookReplace而不是其他的方法
  320.                                  * @inner
  321.                                  * @memberOf EHook
  322.                                  * @param parent{Object} 指定方法所在的对象
  323.                                  * @param context{Object=} 回调方法的上下文
  324.                                  * @param methodName{String} 指定方法的名称
  325.                                  * @param replace {function} 回调方法，该方法的返回值便是替换的方法 回调参数及返回值：[ method:指定的原方法，类型:function return:规定被替换的方法内容，类型:function ]
  326.                                  * @return {number} 该次劫持的id
  327.                                  */
  328.                                 hookReplace: function (parent, methodName, replace, context) {
  329.                                     return this.hook(parent, methodName, {
  330.                                         replace: replace,
  331.                                         context: context
  332.                                     });
  333.                                 },
  334.                                 /**
  335.                                  * 在指定方法前执行
  336.                                  * @inner
  337.                                  * @memberOf EHook
  338.                                  * @param parent{Object} 指定方法所在的对象
  339.                                  * @param methodName{String} 指定方法的名称
  340.                                  * @param before{function} 回调方法，该方法在指定方法运行前执行 回调参数：[ method:指定的原方法 args:原方法运行的参数（在此改变参数值会影响后续指定方法的参数值） ]
  341.                                  * @param context{Object=} 回调方法的上下文
  342.                                  * @returns {number} 劫持id（用于解除劫持）
  343.                                  */
  344.                                 hookBefore: function (parent, methodName, before, context) {
  345.                                     return this.hook(parent, methodName, {
  346.                                         before: before,
  347.                                         context: context
  348.                                     });
  349.                                 },
  350.                                 /**
  351.                                  * 劫持方法的运行，在对制定方法进行该劫持的时候，指定方法不会主动执行，替换为执行参数中的current方法
  352.                                  * @see 注意：该方法只能对指定方法进行一次劫持，若再次使用该方法劫持就会覆盖之前的劫持[可以和hookBefore,hookAfter共存，且hookBefore和hookAfter可以对同个指定方法多次劫持]
  353.                                  * @inner
  354.                                  * @memberOf EHook
  355.                                  * @param parent{Object} 指定方法所在的对象
  356.                                  * @param methodName{String} 指定方法的名称
  357.                                  * @param current{function} 回调方法，该方法在指定方法被调用时执行 回调参数及返回值：[ parent:指定方法所在的对象，类型:object method:指定的原方法，类型:function args:原方法的参数，类型:array return:规定被劫持方法的返回值，类型:* ]
  358.                                  * @param context{Object=} 回调方法的上下文
  359.                                  * @returns {number} 劫持id（用于解除劫持）
  360.                                  */
  361.                                 hookCurrent: function (parent, methodName, current, context) {
  362.                                     return this.hook(parent, methodName, {
  363.                                         current: current,
  364.                                         context: context
  365.                                     });
  366.                                 },
  367.                                 /**
  368.                                  * 在指定方法后执行
  369.                                  * @inner
  370.                                  * @memberOf EHook
  371.                                  * @param parent{Object} 指定方法所在的对象
  372.                                  * @param methodName{String} 指定方法的名称
  373.                                  * @param after{function} 回调方法，该方法在指定方法运行后执行 回调参数及返回值：[ method:指定的原方法，类型:function args:原方法的参数，类型:array result:原方法的返回值，类型:* return:规定被劫持方法的返回值，类型:* ]
  374.                                  * @param context{Object=} 回调方法的上下文
  375.                                  * @returns {number} 劫持id（用于解除劫持）
  376.                                  */
  377.                                 hookAfter: function (parent, methodName, after, context) {
  378.                                     return this.hook(parent, methodName, {
  379.                                         after: after,
  380.                                         context: context
  381.                                     });
  382.                                 },
  383.                                 hookClass: function (parent, className, replace, innerName, excludeProperties) {
  384.                                     var _this = this;
  385.                                     var originFunc = parent[className];
  386.                                     if (!excludeProperties) {
  387.                                         excludeProperties = [];
  388.                                     }
  389.                                     excludeProperties.push('prototype');
  390.                                     excludeProperties.push('caller');
  391.                                     excludeProperties.push('arguments');
  392.                                     innerName = innerName || '_innerHook';
  393.                                     var resFunc = function () {
  394.                                         this[innerName] = new originFunc();
  395.                                         replace.apply(this, arguments);
  396.                                     };
  397.                                     this.hookedToString(originFunc, resFunc);
  398.                                     this.hookedToProperties(originFunc, resFunc, true, excludeProperties);
  399.                                     var prototypeProperties = Object.getOwnPropertyNames(originFunc.prototype);
  400.                                     var prototype = resFunc.prototype = {
  401.                                         constructor: resFunc
  402.                                     };
  403.                                     prototypeProperties.forEach(function (name) {
  404.                                         if (name === 'constructor') {
  405.                                             return;
  406.                                         }
  407.                                         var method = function () {
  408.                                             if (originFunc.prototype[name] && utils.isFunction(originFunc.prototype[name])) {
  409.                                                 return originFunc.prototype[name].apply(this[innerName], arguments);
  410.                                             }
  411.                                             return undefined;
  412.                                         };
  413.                                         _this.hookedToString(originFunc.prototype[name], method);
  414.                                         prototype[name] = method;
  415.                                     });
  416.                                     this.hookReplace(parent, className, function () {
  417.                                         return resFunc;
  418.                                     }, parent)
  419.                                 },
  420.                                 hookedToProperties: function (originObject, resultObject, isDefined, excludeProperties) {
  421.                                     var objectProperties = Object.getOwnPropertyNames(originObject);
  422.                                     objectProperties.forEach(function (property) {
  423.                                         if (utils.contains(excludeProperties, property)) {
  424.                                             return;
  425.                                         }
  426.                                         if (!isDefined) {
  427.                                             resultObject[property] = originObject[property];
  428.                                         } else {
  429.                                             Object.defineProperty(resultObject, property, {
  430.                                                 configurable: false,
  431.                                                 enumerable: false,
  432.                                                 value: originObject[property],
  433.                                                 writable: false
  434.                                             });
  435.                                         }
  436.                                     });
  437.                                 },
  438.                                 hookedToString: function (originObject, resultObject) {
  439.                                     Object.defineProperties(resultObject, {
  440.                                         toString: {
  441.                                             configurable: false,
  442.                                             enumerable: false,
  443.                                             value: originObject.toString.bind(originObject),
  444.                                             writable: false
  445.                                         },
  446.                                         toLocaleString: {
  447.                                             configurable: false,
  448.                                             enumerable: false,
  449.                                             value: originObject.toLocaleString.bind(originObject),
  450.                                             writable: false
  451.                                         }
  452.                                     })
  453.                                 },
  454.                                 /**
  455.                                  * 劫持全局ajax
  456.                                  * @inner
  457.                                  * @memberOf EHook
  458.                                  * @param methods {object} 劫持的方法
  459.                                  * @return {*|number} 劫持的id
  460.                                  */
  461.                                 hookAjax: function (methods) {
  462.                                     if (this.isHooked(_global, 'XMLHttpRequest')) {
  463.                                         return;
  464.                                     }
  465.                                     var _this = this;
  466.                                     var hookMethod = function (methodName) {
  467.                                         if (utils.isFunction(methods[methodName])) {
  468.                                             // 在执行方法之前hook原方法
  469.                                             _this.hookBefore(this.xhr, methodName, methods[methodName]);
  470.                                         }
  471.                                         // 返回方法调用内部的xhr
  472.                                         return this.xhr[methodName].bind(this.xhr);
  473.                                     };
  474.                                     var getProperty = function (attr) {
  475.                                         return function () {
  476.                                             return this.hasOwnProperty(attr + "_") ? this[attr + "_"] : this.xhr[attr];
  477.                                         };
  478.                                     };
  479.                                     var setProperty = function (attr) {
  480.                                         return function (f) {
  481.                                             var xhr = this.xhr;
  482.                                             var that = this;
  483.                                             if (attr.indexOf("on") !== 0) {
  484.                                                 this[attr + "_"] = f;
  485.                                                 return;
  486.                                             }
  487.                                             if (methods[attr]) {
  488.                                                 xhr[attr] = function () {
  489.                                                     f.apply(xhr, arguments);
  490.                                                 };
  491.                                                 // on方法在set时劫持
  492.                                                 _this.hookBefore(xhr, attr, methods[attr]);
  493.                                                 // console.log(1,attr);
  494.                                                 // xhr[attr] = function () {
  495.                                                 //     methods[attr](that) || f.apply(xhr, arguments);
  496.                                                 // }
  497.                                             } else {
  498.                                                 xhr[attr] = f;
  499.                                             }
  500.                                         };
  501.                                     };
  502.                                     return this.hookReplace(_global, 'XMLHttpRequest', function (XMLHttpRequest) {
  503.                                         var resFunc = function () {
  504.                                             this.xhr = new XMLHttpRequest();
  505.                                             for (var propertyName in this.xhr) {
  506.                                                 var property = this.xhr[propertyName];
  507.                                                 if (utils.isFunction(property)) {
  508.                                                     // hook 原方法
  509.                                                     this[propertyName] = hookMethod.bind(this)(propertyName);
  510.                                                 } else {
  511.                                                     Object.defineProperty(this, propertyName, {
  512.                                                         get: getProperty(propertyName),
  513.                                                         set: setProperty(propertyName)
  514.                                                     });
  515.                                                 }
  516.                                             }
  517.                                             // 定义外部xhr可以在内部访问
  518.                                             this.xhr.xhr = this;
  519.                                         };
  520.                                         _this.hookedToProperties(XMLHttpRequest, resFunc, true);
  521.                                         _this.hookedToString(XMLHttpRequest, resFunc);
  522.                                         return resFunc
  523.                                     });
  524.                                 },
  525.                                 /**
  526.                                  * 劫持全局ajax
  527.                                  * @param methods {object} 劫持的方法
  528.                                  * @return {*|number} 劫持的id
  529.                                  */
  530.                                 hookAjaxV2: function (methods) {
  531.                                     this.hookClass(window, 'XMLHttpRequest', function () {
  532.     
  533.                                     });
  534.                                     utils.ergodicObject(this, methods, function (method) {
  535.     
  536.                                     });
  537.                                 },
  538.                                 /**
  539.                                  * 解除劫持
  540.                                  * @inner
  541.                                  * @memberOf EHook
  542.                                  * @param context 上下文
  543.                                  * @param methodName 方法名
  544.                                  * @param isDeeply {boolean=} 是否深度解除[默认为false]
  545.                                  * @param eqId {number=}  解除指定id的劫持[可选]
  546.                                  */
  547.                                 unHook: function (context, methodName, isDeeply, eqId) {
  548.                                     if (!context[methodName] || !utils.isFunction(context[methodName])) {
  549.                                         return;
  550.                                     }
  551.                                     var methodTask = this._getHookedMethodTask(context, methodName);
  552.                                     if (eqId) {
  553.                                         if (this.unHookById(eqId)) {
  554.                                             return;
  555.                                         }
  556.                                     }
  557.                                     if (!methodTask.original) {
  558.                                         delete this._getHookedMethodMap(context)[methodName];
  559.                                         return;
  560.                                     }
  561.                                     context[methodName] = methodTask.original;
  562.                                     if (isDeeply) {
  563.                                         delete this._getHookedMethodMap(context)[methodName];
  564.                                     }
  565.                                 },
  566.                                 /**
  567.                                  * 通过Id解除劫持
  568.                                  * @inner
  569.                                  * @memberOf EHook
  570.                                  * @param eqId
  571.                                  * @returns {boolean}
  572.                                  */
  573.                                 unHookById: function (eqId) {
  574.                                     var hasEq = false;
  575.                                     if (eqId) {
  576.                                         var hookedMap = this._getHookedMap();
  577.                                         utils.ergodicObject(this, hookedMap, function (contextMap) {
  578.                                             utils.ergodicObject(this, contextMap, function (methodTask) {
  579.                                                 methodTask.task.before = methodTask.task.before.filter(function (before) {
  580.                                                     hasEq = hasEq || before.id === eqId;
  581.                                                     return before.id !== eqId;
  582.                                                 });
  583.                                                 methodTask.task.after = methodTask.task.after.filter(function (after) {
  584.                                                     hasEq = hasEq || after.id === eqId;
  585.                                                     return after.id !== eqId;
  586.                                                 });
  587.                                                 if (methodTask.task.current && methodTask.task.current.id === eqId) {
  588.                                                     methodTask.task.current = undefined;
  589.                                                     hasEq = true;
  590.                                                 }
  591.                                                 if (methodTask.replace && methodTask.replace.id === eqId) {
  592.                                                     methodTask.replace = undefined;
  593.                                                     hasEq = true;
  594.                                                 }
  595.                                             })
  596.                                         });
  597.                                     }
  598.                                     return hasEq;
  599.                                 },
  600.                                 /**
  601.                                  *  移除所有劫持相关的方法
  602.                                  * @inner
  603.                                  * @memberOf EHook
  604.                                  * @param context 上下文
  605.                                  * @param methodName 方法名
  606.                                  */
  607.                                 removeHookMethod: function (context, methodName) {
  608.                                     if (!context[methodName] || !utils.isFunction(context[methodName])) {
  609.                                         return;
  610.                                     }
  611.                                     this._getHookedMethodMap(context)[methodName] = {
  612.                                         original: undefined,
  613.                                         replace: undefined,
  614.                                         task: {
  615.                                             before: [],
  616.                                             current: undefined,
  617.                                             after: []
  618.                                         }
  619.                                     };
  620.                                 },
  621.                                 /**
  622.                                  * 判断一个方法是否被劫持过
  623.                                  * @inner
  624.                                  * @memberOf EHook
  625.                                  * @param context
  626.                                  * @param methodName
  627.                                  */
  628.                                 isHooked: function (context, methodName) {
  629.                                     var hookMap = this._getHookedMethodMap(context);
  630.                                     return hookMap[methodName] !== undefined ? (hookMap[methodName].original !== undefined) : false;
  631.                                 },
  632.                                 /**
  633.                                  * 保护一个对象使之不会被篡改
  634.                                  * @inner
  635.                                  * @memberOf EHook
  636.                                  * @param parent
  637.                                  * @param methodName
  638.                                  */
  639.                                 protect: function (parent, methodName) {
  640.                                     Object.defineProperty(parent, methodName, {
  641.                                         configurable: false,
  642.                                         writable: false
  643.                                     });
  644.                                 },
  645.                                 preventError: function (parent, methodName, returnValue, context) {
  646.                                     this.hookCurrent(parent, methodName, function (m, args) {
  647.                                         var value = returnValue;
  648.                                         try {
  649.                                             value = m.apply(this, args);
  650.                                         } catch (e) {
  651.                                             console.log('Error Prevented from method ' + methodName, e);
  652.                                         }
  653.                                         return value;
  654.                                     }, context)
  655.                                 },
  656.                                 /**
  657.                                  * 装载插件
  658.                                  * @inner
  659.                                  * @memberOf EHook
  660.                                  * @param option
  661.                                  */
  662.                                 plugins: function (option) {
  663.                                     if (utils.isFunction(option.mount)) {
  664.                                         var result = option.mount.call(this, utils);
  665.                                         if (typeof option.name === 'string') {
  666.                                             _global[option.name] = result;
  667.                                         }
  668.                                     }
  669.                                 }
  670.                             };
  671.                             if (_global.eHook && (_global.eHook instanceof EHook)) {
  672.                                 return;
  673.                             }
  674.                             var eHook = new EHook();
  675.                             /**
  676.                              * @namespace AHook
  677.                              * @author Cangshi
  678.                              * @constructor
  679.                              * @see {@link https://palerock.cn/projects/006HDUuOhBj}
  680.                              * @license Apache License 2.0
  681.                              */
  682.                             var AHook = function () {
  683.                                 this.isHooked = false;
  684.                                 var autoId = 1;
  685.                                 this._urlDispatcherList = [];
  686.                                 this._getAutoId = function () {
  687.                                     return autoId++;
  688.                                 };
  689.                             };
  690.                             AHook.prototype = {
  691.                                 /**
  692.                                  * 执行配置列表中的指定方法组
  693.                                  * @param xhr
  694.                                  * @param methodName
  695.                                  * @param args
  696.                                  * @private
  697.                                  */
  698.                                 _invokeAimMethods: function (xhr, methodName, args) {
  699.                                     var configs = utils.parseArrayByProperty(xhr.patcherList, 'config');
  700.                                     var methods = [];
  701.                                     utils.ergodicArrayObject(xhr, configs, function (config) {
  702.                                         if (utils.isFunction(config[methodName])) {
  703.                                             methods.push(config[methodName]);
  704.                                         }
  705.                                     });
  706.                                     return utils.invokeMethods(xhr, methods, args);
  707.                                 },
  708.                                 /**
  709.                                  * 根据url获取配置列表
  710.                                  * @param url
  711.                                  * @return {Array}
  712.                                  * @private
  713.                                  */
  714.                                 _urlPatcher: function (url) {
  715.                                     var patcherList = [];
  716.                                     utils.ergodicArrayObject(this, this._urlDispatcherList, function (patcherMap, i) {
  717.                                         if (utils.UrlUtils.urlMatching(url, patcherMap.patcher)) {
  718.                                             patcherList.push(patcherMap);
  719.                                         }
  720.                                     });
  721.                                     return patcherList;
  722.                                 },
  723.                                 /**
  724.                                  * 根据xhr对象分发回调请求
  725.                                  * @param xhr
  726.                                  * @param fullUrl
  727.                                  * @private
  728.                                  */
  729.                                 _xhrDispatcher: function (xhr, fullUrl) {
  730.                                     var url = utils.UrlUtils.getUrlWithoutParam(fullUrl);
  731.                                     xhr.patcherList = this._urlPatcher(url);
  732.                                 },
  733.                                 /**
  734.                                  * 转换响应事件
  735.                                  * @param e
  736.                                  * @param xhr
  737.                                  * @private
  738.                                  */
  739.                                 _parseEvent: function (e, xhr) {
  740.                                     try {
  741.                                         Object.defineProperties(e, {
  742.                                             target: {
  743.                                                 get: function () {
  744.                                                     return xhr;
  745.                                                 }
  746.                                             },
  747.                                             srcElement: {
  748.                                                 get: function () {
  749.                                                     return xhr;
  750.                                                 }
  751.                                             }
  752.                                         });
  753.                                     } catch (error) {
  754.                                         console.warn('重定义返回事件失败，劫持响应可能失败');
  755.                                     }
  756.                                     return e;
  757.                                 },
  758.                                 /**
  759.                                  * 解析open方法的参数
  760.                                  * @param args
  761.                                  * @private
  762.                                  */
  763.                                 _parseOpenArgs: function (args) {
  764.                                     return {
  765.                                         method: args[0],
  766.                                         fullUrl: args[1],
  767.                                         url: utils.UrlUtils.getUrlWithoutParam(args[1]),
  768.                                         params: utils.UrlUtils.getParamFromUrl(args[1]),
  769.                                         async: args[2]
  770.                                     };
  771.                                 },
  772.                                 /**
  773.                                  * 劫持ajax 请求参数
  774.                                  * @param argsObject
  775.                                  * @param argsArray
  776.                                  * @private
  777.                                  */
  778.                                 _rebuildOpenArgs: function (argsObject, argsArray) {
  779.                                     argsArray[0] = argsObject.method;
  780.                                     argsArray[1] = utils.UrlUtils.margeUrlAndParams(argsObject.url, argsObject.params);
  781.                                     argsArray[2] = argsObject.async;
  782.                                 },
  783.                                 /**
  784.                                  * 获取劫持方法的参数 [原方法,原方法参数,原方法返回值]，剔除原方法参数
  785.                                  * @param args
  786.                                  * @return {*|Array.<T>}
  787.                                  * @private
  788.                                  */
  789.                                 _getHookedArgs: function (args) {
  790.                                     // 将参数中'原方法'剔除
  791.                                     return Array.prototype.slice.call(args, 0).splice(1);
  792.                                 },
  793.                                 /**
  794.                                  * 响应被触发时调用的方法
  795.                                  * @param outerXhr
  796.                                  * @param funcArgs
  797.                                  * @private
  798.                                  */
  799.                                 _onResponse: function (outerXhr, funcArgs) {
  800.                                     // 因为参数是被劫持的参数为[method(原方法),args(参数)],该方法直接获取参数并转换为数组
  801.                                     var args = this._getHookedArgs(funcArgs);
  802.                                     args[0][0] = this._parseEvent(args[0][0], outerXhr.xhr); // 强制事件指向外部xhr
  803.                                     // 执行所有的名为hookResponse的方法组
  804.                                     var results = this._invokeAimMethods(outerXhr, 'hookResponse', args);
  805.                                     // 遍历结果数组并获取最后返回的有效的值作为响应值
  806.                                     var resultIndex = -1;
  807.                                     utils.ergodicArrayObject(outerXhr, results, function (res, i) {
  808.                                         if (res != null) {
  809.                                             resultIndex = i;
  810.                                         }
  811.                                     });
  812.                                     if (resultIndex !== -1) {
  813.                                         outerXhr.xhr.responseText_ = outerXhr.xhr.response_ = results[resultIndex];
  814.                                     }
  815.                                 },
  816.                                 /**
  817.                                  * 手动开始劫持
  818.                                  * @inner
  819.                                  * @memberOf AHook
  820.                                  */
  821.                                 startHook: function () {
  822.                                     var _this = this;
  823.                                     var normalMethods = {
  824.                                         // 方法中的this指向内部xhr
  825.                                         // 拦截响应
  826.                                         onreadystatechange: function () {
  827.                                             if (this.readyState == 4 && this.status == 200 || this.status == 304) {
  828.                                                 _this._onResponse(this, arguments);
  829.                                             }
  830.                                         },
  831.                                         onload: function () {
  832.                                             _this._onResponse(this, arguments);
  833.                                         },
  834.                                         // 拦截请求
  835.                                         open: function () {
  836.                                             var args = _this._getHookedArgs(arguments);
  837.                                             var fullUrl = args[0][1];
  838.                                             _this._xhrDispatcher(this, fullUrl);
  839.                                             var argsObject = _this._parseOpenArgs(args[0]);
  840.                                             this.openArgs = argsObject;
  841.                                             _this._invokeAimMethods(this, 'hookRequest', [argsObject]);
  842.                                             _this._rebuildOpenArgs(argsObject, args[0]);
  843.                                         },
  844.                                         send: function () {
  845.                                             var args = _this._getHookedArgs(arguments);
  846.                                             this.sendArgs = args;
  847.                                             _this._invokeAimMethods(this, 'hookSend', args);
  848.                                         }
  849.                                     };
  850.                                     // 设置总的hookId
  851.                                     this.___hookedId = _global.eHook.hookAjax(normalMethods);
  852.                                     this.isHooked = true;
  853.                                 },
  854.                                 /**
  855.                                  * 注册(不可用)ajaxUrl拦截
  856.                                  * @inner
  857.                                  * @memberOf AHook
  858.                                  * @param urlPatcher
  859.                                  * @param configOrRequest
  860.                                  * @param response
  861.                                  * @return {number}
  862.                                  */
  863.                                 register: function (urlPatcher, configOrRequest, response) {
  864.                                     if (!urlPatcher) {
  865.                                         return -1;
  866.                                     }
  867.                                     if (!utils.isExistObject(configOrRequest) && !utils.isFunction(response)) {
  868.                                         return -1;
  869.                                     }
  870.                                     var config = {};
  871.                                     if (utils.isFunction(configOrRequest)) {
  872.                                         config.hookRequest = configOrRequest;
  873.                                     }
  874.                                     if (utils.isFunction(response)) {
  875.                                         config.hookResponse = response;
  876.                                     }
  877.                                     if (utils.isExistObject(configOrRequest)) {
  878.                                         config = configOrRequest;
  879.                                     }
  880.                                     var id = this._getAutoId();
  881.                                     this._urlDispatcherList.push({
  882.                                         // 指定id便于后续取消
  883.                                         id: id,
  884.                                         patcher: urlPatcher,
  885.                                         config: config
  886.                                     });
  887.                                     // 当注册(不可用)一个register时，自动开始运行劫持
  888.                                     if (!this.isHooked) {
  889.                                         this.startHook();
  890.                                     }
  891.                                     return id;
  892.                                 }
  893.                                 // todo 注销  cancellation: function (registerId){};
  894.                             };
  895.     
  896.                             _global['eHook'] = eHook;
  897.                             _global['aHook'] = new AHook();
  898.     
  899.                             return [{
  900.                                 name: 'eHook',
  901.                                 module: eHook
  902.                             }, {
  903.                                 name: 'aHook',
  904.                                 module: _global['aHook']
  905.                             }]
  906.     
  907.                         }));
  908.     
  909.                         /***/
  910.     }),
  911.     /* 1 */
  912.     /***/ (function (module) {
  913.     
  914.                         (function (global, factory) {
  915.     
  916.                             "use strict";
  917.     
  918.                             if (true && typeof module.exports === "object") {
  919.                                 module.exports = factory(global, true);
  920.                             } else {
  921.                                 factory(global);
  922.                             }
  923.     
  924.                         }(typeof window !== "undefined" ? window : this, function (_global, noGlobal) {
  925.     
  926.                             var map = Array.prototype.map;
  927.                             var forEach = Array.prototype.forEach;
  928.                             var reduce = Array.prototype.reduce;
  929.     
  930.                             var BaseUtils = {
  931.                                 /**
  932.                                  * 对象是否为数组
  933.                                  * @param arr
  934.                                  */
  935.                                 isArray: function (arr) {
  936.                                     return Array.isArray(arr) || Object.prototype.toString.call(arr) === "[object Array]";
  937.                                 },
  938.                                 /**
  939.                                  * 判断是否为方法
  940.                                  * @param func
  941.                                  * @return {boolean}
  942.                                  */
  943.                                 isFunction: function (func) {
  944.                                     if (!func) {
  945.                                         return false;
  946.                                     }
  947.                                     return typeof func === 'function';
  948.                                 },
  949.                                 /**
  950.                                  * 判断是否是一个有效的对象
  951.                                  * @param obj
  952.                                  * @return {*|boolean}
  953.                                  */
  954.                                 isExistObject: function (obj) {
  955.                                     return obj && (typeof obj === 'object');
  956.                                 },
  957.                                 isString: function (str) {
  958.                                     if (str === null) {
  959.                                         return false;
  960.                                     }
  961.                                     return typeof str === 'string';
  962.                                 },
  963.                                 uniqueNum: 1000,
  964.                                 /**
  965.                                  * 根据当前时间戳生产一个随机id
  966.                                  * @returns {string}
  967.                                  */
  968.                                 buildUniqueId: function () {
  969.                                     var prefix = new Date().getTime().toString();
  970.                                     var suffix = this.uniqueNum.toString();
  971.                                     this.uniqueNum++;
  972.                                     return prefix + suffix;
  973.                                 }
  974.                             };
  975.     
  976.                             //
  977.                             var serviceProvider = {
  978.                                 _parseDepends: function (depends) {
  979.                                     var dependsArr = [];
  980.                                     if (!BaseUtils.isArray(depends)) {
  981.                                         return;
  982.                                     }
  983.                                     forEach.call(depends, function (depend) {
  984.                                         if (BaseUtils.isString(depend)) {
  985.                                             dependsArr.push(serviceProvider[depend.toLowerCase()]);
  986.                                         }
  987.                                     });
  988.                                     return dependsArr;
  989.                                 }
  990.                             };
  991.     
  992.                             var factory = function (name, depends, construction) {
  993.                                 if (!BaseUtils.isFunction(construction)) {
  994.                                     return;
  995.                                 }
  996.                                 serviceProvider[name.toLowerCase()] = construction.apply(this, serviceProvider._parseDepends(depends));
  997.                             };
  998.     
  999.                             var depend = function (depends, construction) {
  1000.                                 if (!BaseUtils.isFunction(construction)) {
  1001.                                     return;
  1002.                                 }
  1003.                                 construction.apply(this, serviceProvider._parseDepends(depends));
  1004.                             };
  1005.     
  1006.                             factory('BaseUtils', [], function () {
  1007.                                 return BaseUtils;
  1008.                             });
  1009.     
  1010.                             // logger
  1011.                             factory('logger', [], function () {
  1012.                                 return console;
  1013.                             });
  1014.     
  1015.                             // DateTimeUtils
  1016.                             factory('DateTimeUtils', ['logger'], function (logger) {
  1017.                                 return {
  1018.                                     /**
  1019.                                      * 打印当前时间
  1020.                                      */
  1021.                                     printNowTime: function () {
  1022.                                         var date = new Date();
  1023.                                         console.log(this.pattern(date, 'hh:mm:ss:S'));
  1024.                                     },
  1025.                                     /**
  1026.                                      * 格式化日期
  1027.                                      * @param date
  1028.                                      * @param fmt
  1029.                                      * @returns {*}
  1030.                                      */
  1031.                                     pattern: function (date, fmt) {
  1032.                                         var o = {
  1033.                                             "M+": date.getMonth() + 1, //月份
  1034.                                             "d+": date.getDate(), //日
  1035.                                             "h+": date.getHours() % 12 === 0 ? 12 : date.getHours() % 12, //小时
  1036.                                             "H+": date.getHours(), //小时
  1037.                                             "m+": date.getMinutes(), //分
  1038.                                             "s+": date.getSeconds(), //秒
  1039.                                             "q+": Math.floor((date.getMonth() + 3) / 3), //季度
  1040.                                             "S": date.getMilliseconds() //毫秒
  1041.                                         };
  1042.                                         var week = {
  1043.                                             "0": "/u65e5",
  1044.                                             "1": "/u4e00",
  1045.                                             "2": "/u4e8c",
  1046.                                             "3": "/u4e09",
  1047.                                             "4": "/u56db",
  1048.                                             "5": "/u4e94",
  1049.                                             "6": "/u516d"
  1050.                                         };
  1051.                                         if (/(y+)/.test(fmt)) {
  1052.                                             fmt = fmt.replace(RegExp.$1, (date.getFullYear() + "").substr(4 - RegExp.$1.length));
  1053.                                         }
  1054.                                         if (/(E+)/.test(fmt)) {
  1055.                                             fmt = fmt.replace(RegExp.$1, ((RegExp.$1.length > 1) ? (RegExp.$1.length > 2 ? "/u661f/u671f" : "/u5468") : "") + week[date.getDay() + ""]);
  1056.                                         }
  1057.                                         for (var k in o) {
  1058.                                             if (new RegExp("(" + k + ")").test(fmt)) {
  1059.                                                 fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
  1060.                                             }
  1061.                                         }
  1062.                                         return fmt;
  1063.                                     },
  1064.                                     /**
  1065.                                      * 以当前时间获取id
  1066.                                      * @returns {number}
  1067.                                      */
  1068.                                     getCurrentId: function () {
  1069.                                         var date = new Date();
  1070.                                         return date.getTime();
  1071.                                     },
  1072.                                     /**
  1073.                                      * 获取指定时间距离现在相差多久
  1074.                                      * @param date {number|Date}
  1075.                                      * @param isCeil{boolean=} 是否对结果向上取整，默认[false]
  1076.                                      * @param type {string=} 单位可取值['day','month','year']默认'day'
  1077.                                      * @returns {number}
  1078.                                      */
  1079.                                     getNowBetweenADay: function (date, isCeil, type) {
  1080.                                         if (!type) {
  1081.                                             type = 'day'
  1082.                                         }
  1083.                                         if (typeof date === 'number') {
  1084.                                             date = new Date(date);
  1085.                                         }
  1086.                                         if (!(date instanceof Date)) {
  1087.                                             throw new TypeError('该参数类型必须是Date')
  1088.                                         }
  1089.                                         var time = date.getTime();
  1090.                                         var now = new Date();
  1091.                                         var nowTime = now.getTime();
  1092.                                         if (nowTime - time < 0) {
  1093.                                             logger.warn('需要计算的时间必须在当前时间之前');
  1094.                                         }
  1095.                                         var result = 0;
  1096.                                         switch (type) {
  1097.                                             default:
  1098.                                             case 'day':
  1099.                                                 result = (nowTime - time) / (1000 * 60 * 60 * 24);
  1100.                                                 break;
  1101.                                             case 'month':
  1102.                                                 var yearDifference = now.getFullYear() - date.getFullYear();
  1103.                                                 if (yearDifference > 0) {
  1104.                                                     result += yearDifference * 12;
  1105.                                                 }
  1106.                                                 result += now.getMonth() - date.getMonth();
  1107.                                                 break;
  1108.                                             case 'year':
  1109.                                                 result += now.getFullYear() - date.getFullYear();
  1110.                                                 break;
  1111.                                         }
  1112.                                         if (!isCeil) {
  1113.                                             return Math.floor(result);
  1114.                                         } else {
  1115.                                             if (result === 0 && isCeil) {
  1116.                                                 result = 1;
  1117.                                             }
  1118.                                             return Math.ceil(result);
  1119.                                         }
  1120.                                     }
  1121.                                 }
  1122.                             });
  1123.     
  1124.                             // ArrayUtils
  1125.                             factory('ArrayUtils', ['BaseUtils'], function (BaseUtils) {
  1126.                                 return {
  1127.                                     isArrayObject: function (arr) {
  1128.                                         return BaseUtils.isArray(arr);
  1129.                                     },
  1130.                                     /**
  1131.                                      * 遍历数组
  1132.                                      * @param context {Object}
  1133.                                      * @param arr {Array}
  1134.                                      * @param cb {Function} 回调函数
  1135.                                      */
  1136.                                     ergodicArrayObject: function (context, arr, cb) {
  1137.                                         if (!context) {
  1138.                                             context = _global;
  1139.                                         }
  1140.                                         if (!BaseUtils.isArray(arr) || !BaseUtils.isFunction(cb)) {
  1141.                                             return;
  1142.                                         }
  1143.                                         for (var i = 0; i < arr.length; i++) {
  1144.                                             var result = cb.call(context, arr[i], i);
  1145.                                             if (result && result === -1) {
  1146.                                                 break;
  1147.                                             }
  1148.                                         }
  1149.                                     },
  1150.                                     /**
  1151.                                      * 获取数组对象的一个属性发起动作
  1152.                                      * @param context {Object}
  1153.                                      * @param arr {Array}
  1154.                                      * @param propertyName {String}
  1155.                                      * @param cb {Function}
  1156.                                      * @param checkProperty {boolean} 是否排除不拥有该属性的对象[default:true]
  1157.                                      */
  1158.                                     getPropertyDo: function (context, arr, propertyName, cb, checkProperty) {
  1159.                                         if (checkProperty === null) {
  1160.                                             checkProperty = true;
  1161.                                         }
  1162.                                         this.ergodicArrayObject(context, arr, function (ele) {
  1163.                                             if (!checkProperty || ele.hasOwnProperty(propertyName)) {
  1164.                                                 cb.call(context, ele[propertyName], ele);
  1165.                                             }
  1166.                                         })
  1167.                                     },
  1168.                                     /**
  1169.                                      * [私有方法]将多个键值对对象转换为map
  1170.                                      * @param arr {Array}
  1171.                                      * @returns {{}}
  1172.                                      */
  1173.                                     parseKeyValue: function (arr) {
  1174.                                         var map = {};
  1175.                                         if (!(BaseUtils.isArray(arr))) {
  1176.                                             return map;
  1177.                                         }
  1178.                                         this.ergodicArrayObject(this, arr, function (ele) {
  1179.                                             if (ele.key === null) {
  1180.                                                 return;
  1181.                                             }
  1182.                                             if (!map.hasOwnProperty(ele.key)) {
  1183.                                                 map[ele.key] = ele.value;
  1184.                                             }
  1185.                                         });
  1186.                                         return map;
  1187.                                     },
  1188.                                     /**
  1189.                                      * 获取数组的哈希码
  1190.                                      * @param arr {Array}
  1191.                                      * @returns {number}
  1192.                                      */
  1193.                                     getHashCode: function (arr) {
  1194.                                         var str = arr.toString();
  1195.                                         var hash = 31;
  1196.                                         if (str.length === 0) return hash;
  1197.                                         for (var i = 0; i < str.length; i++) {
  1198.                                             var char = str.charCodeAt(i);
  1199.                                             hash = ((hash << 5) - hash) + char;
  1200.                                             hash = hash & hash; // Convert to 32bit integer
  1201.                                         }
  1202.                                         return hash;
  1203.                                     },
  1204.                                     /**
  1205.                                      * 通过数组中每个对象的指定属性生成一个新数组
  1206.                                      * @param arr {Array}
  1207.                                      * @param propertyName {String}
  1208.                                      */
  1209.                                     parseArrayByProperty: function (arr, propertyName) {
  1210.                                         var result = [];
  1211.                                         if (!this.isArrayObject(arr)) {
  1212.                                             return result;
  1213.                                         }
  1214.                                         this.getPropertyDo(this, arr, propertyName, function (value) {
  1215.                                             result.push(value);
  1216.                                         }, true);
  1217.                                         return result;
  1218.                                     },
  1219.                                     /**
  1220.                                      * 数组对象是否包含一个对象
  1221.                                      * @param arr {Array}
  1222.                                      * @param obj
  1223.                                      * @param cb {function=}
  1224.                                      * @returns {boolean}
  1225.                                      */
  1226.                                     isContainsObject: function (arr, obj, cb) {
  1227.                                         var isContainsObject = false;
  1228.                                         this.ergodicArrayObject(this, arr, function (value, i) {
  1229.                                             if (obj === value) {
  1230.                                                 isContainsObject = true;
  1231.                                                 if (BaseUtils.isFunction(cb)) {
  1232.                                                     cb.call(_global, i);
  1233.                                                 }
  1234.                                                 return -1;
  1235.                                             }
  1236.                                         });
  1237.                                         return isContainsObject;
  1238.                                     },
  1239.                                     /**
  1240.                                      * 获取数组中的最大值
  1241.                                      * @param arr 若数组中的对象还是数组，则按里面数组的每个对象进行多级比较
  1242.                                      * @param cb
  1243.                                      * @returns {*}
  1244.                                      */
  1245.                                     getMaxInArray: function (arr, cb) {
  1246.                                         var maxObject = null;
  1247.                                         var maxIndex = -1;
  1248.                                         while (maxObject === null && maxIndex < arr.length) {
  1249.                                             maxObject = arr[++maxIndex]
  1250.                                         }
  1251.                                         for (var i = maxIndex + 1; i < arr.length; i++) {
  1252.                                             // 若是比较对象都是数组，则对每个数组的第一个元素进行比较，若相同，则比较第二个元素
  1253.                                             if (maxObject !== null && this.isArrayObject(maxObject) && this.isArrayObject(arr[i])) {
  1254.                                                 var classLength = maxObject.length;
  1255.                                                 var classLevel = 0;
  1256.                                                 // console.log(maxObject[classLevel],arr[i][classLevel]);
  1257.                                                 while (maxObject[classLevel] === arr[i][classLevel] && classLevel < classLength) {
  1258.                                                     classLevel++
  1259.                                                 }
  1260.                                                 if (maxObject[classLevel] !== null && maxObject[classLevel] < arr[i][classLevel]) {
  1261.                                                     maxObject = arr[i];
  1262.                                                     maxIndex = i;
  1263.                                                 }
  1264.                                                 continue;
  1265.                                             }
  1266.                                             if (maxObject !== null && maxObject < arr[i]) {
  1267.                                                 maxObject = arr[i];
  1268.                                                 maxIndex = i;
  1269.                                             }
  1270.                                         }
  1271.                                         if (BaseUtils.isFunction(cb)) {
  1272.                                             cb.call(this, maxObject, maxIndex);
  1273.                                         }
  1274.                                         return maxObject;
  1275.                                     },
  1276.                                     /**
  1277.                                      * 获取数组中的总值
  1278.                                      * @param arr{Array<number>}
  1279.                                      * @param cb {function=}
  1280.                                      */
  1281.                                     getSumInArray: function (arr, cb) {
  1282.                                         if (!this.isArrayObject(arr)) {
  1283.                                             return;
  1284.                                         }
  1285.                                         var sum = 0;
  1286.                                         var count = 0;
  1287.                                         this.ergodicArrayObject(this, arr, function (value) {
  1288.                                             if (typeof value === 'number' && !Number.isNaN(value)) {
  1289.                                                 sum += value;
  1290.                                                 count += 1;
  1291.                                             }
  1292.                                         });
  1293.                                         if (BaseUtils.isFunction(cb)) {
  1294.                                             cb.call(_global, sum, count);
  1295.                                         }
  1296.                                         return sum;
  1297.                                     },
  1298.                                     /**
  1299.                                      * 获取数组中的平均值
  1300.                                      * @param arr{Array<number>}
  1301.                                      */
  1302.                                     getAverageInArray: function (arr) {
  1303.                                         var average = 0;
  1304.                                         this.getSumInArray(arr, function (sum, i) {
  1305.                                             i === 0 || (average = sum / i);
  1306.                                         });
  1307.                                         return average;
  1308.                                     },
  1309.                                     /**
  1310.                                      * 为数组排序
  1311.                                      * @param arr
  1312.                                      * @param order
  1313.                                      * @param sortSetting {object=}
  1314.                                      */
  1315.                                     sortingArrays: function (arr, order, sortSetting) {
  1316.                                         if (!this.isArrayObject(arr)) {
  1317.                                             return;
  1318.                                         }
  1319.                                         var DESC = 0;
  1320.                                         var ASC = 1;
  1321.                                         var thisArr = arr.slice(0);
  1322.                                         var _thisAction = null;
  1323.                                         // 解析配置
  1324.                                         var isSetting = sortSetting && sortSetting.getComparedProperty &&
  1325.                                             BaseUtils.isFunction(sortSetting.getComparedProperty);
  1326.                                         if (isSetting) {
  1327.                                             thisArr = sortSetting.getComparedProperty(arr);
  1328.                                         }
  1329.                                         switch (order) {
  1330.                                             default:
  1331.                                             case DESC:
  1332.                                                 _thisAction = thisArr.push;
  1333.                                                 break;
  1334.                                             case ASC:
  1335.                                                 _thisAction = thisArr.unshift;
  1336.                                                 break;
  1337.                                         }
  1338.                                         var resultArr = [];
  1339.                                         for (var j = 0; j < thisArr.length; j++) {
  1340.                                             this.getMaxInArray(thisArr, function (max, i) {
  1341.                                                 delete thisArr[i];
  1342.                                                 _thisAction.call(resultArr, arr[i]);
  1343.                                             });
  1344.                                         }
  1345.                                         if (sortSetting && sortSetting.createNewData) {
  1346.                                             return resultArr.slice(0);
  1347.                                         }
  1348.                                         return resultArr;
  1349.                                     },
  1350.                                     /**
  1351.                                      * 将类数组转化为数组
  1352.                                      * @param arrLike 类数组对象
  1353.                                      */
  1354.                                     toArray: function (arrLike) {
  1355.                                         if (!arrLike || arrLike.length === 0) {
  1356.                                             return [];
  1357.                                         }
  1358.                                         // 非伪类对象，直接返回最好
  1359.                                         if (!arrLike.length) {
  1360.                                             return arrLike;
  1361.                                         }
  1362.                                         // 针对IE8以前 DOM的COM实现
  1363.                                         try {
  1364.                                             return [].slice.call(arrLike);
  1365.                                         } catch (e) {
  1366.                                             var i = 0,
  1367.                                                 j = arrLike.length,
  1368.                                                 res = [];
  1369.                                             for (; i < j; i++) {
  1370.                                                 res.push(arrLike[i]);
  1371.                                             }
  1372.                                             return res;
  1373.                                         }
  1374.                                     },
  1375.                                     /**
  1376.                                      * 判断是否为类数组
  1377.                                      * @param o
  1378.                                      * @returns {boolean}
  1379.                                      */
  1380.                                     isArrayLick: function (o) {
  1381.                                         if (o &&                                // o is not null, undefined, etc.
  1382.                                             typeof o === 'object' &&            // o is an object
  1383.                                             isFinite(o.length) &&               // o.length is a finite number
  1384.                                             o.length >= 0 &&                    // o.length is non-negative
  1385.                                             o.length === Math.floor(o.length) &&  // o.length is an integer
  1386.                                             o.length < 4294967296)              // o.length < 2^32
  1387.                                             return true;                        // Then o is array-like
  1388.                                         else
  1389.                                             return false;                       // Otherwise it is not
  1390.     
  1391.                                     },
  1392.                                     /**
  1393.                                      * 判断数组是否包含对象
  1394.                                      * @param arr
  1395.                                      * @param obj
  1396.                                      */
  1397.                                     contains: function (arr, obj) {
  1398.                                         var contains = false;
  1399.                                         this.ergodicArrayObject(this, arr, function (a) {
  1400.                                             if (a === obj) {
  1401.                                                 contains = true;
  1402.                                                 return -1;
  1403.                                             }
  1404.                                         });
  1405.                                         return contains;
  1406.                                     }
  1407.                                 }
  1408.                             });
  1409.     
  1410.                             // ObjectUtils
  1411.                             factory('ObjectUtils', ['ArrayUtils', 'BaseUtils'], function (ArrayUtils, BaseUtils) {
  1412.                                 return {
  1413.                                     /**
  1414.                                      * 获取对象属性[支持链式表达式,如获取学生所在班级所在的学校(student.class.school):'class.school']
  1415.                                      * @param obj
  1416.                                      * @param linkProperty {string|Array} 属性表达式，获取多个属性则用数组
  1417.                                      * @param cb {function=}
  1418.                                      * @return 对象属性
  1419.                                      */
  1420.                                     readLinkProperty: function (obj, linkProperty, cb) {
  1421.                                         var callback = null;
  1422.                                         if (BaseUtils.isFunction(cb)) {
  1423.                                             callback = cb;
  1424.                                         }
  1425.                                         if (typeof linkProperty === 'string') {
  1426.                                             // 除去所有的空格
  1427.                                             linkProperty = linkProperty.replace(/ /g, '');
  1428.                                             // 不判断为空的值
  1429.                                             if (linkProperty === '') {
  1430.                                                 return null;
  1431.                                             }
  1432.                                             // 若是以','隔开的伪数组，则转化为数组再进行操作
  1433.                                             if (linkProperty.indexOf(',') !== -1) {
  1434.                                                 var propertyNameArr = linkProperty.split(',');
  1435.                                                 return this.readLinkProperty(obj, propertyNameArr, callback);
  1436.                                             }
  1437.                                             if (linkProperty.indexOf('.') !== -1) {
  1438.                                                 var names = linkProperty.split('.');
  1439.                                                 var iterationObj = obj;
  1440.                                                 var result = null;
  1441.                                                 ArrayUtils.ergodicArrayObject(this, names, function (name, i) {
  1442.                                                     iterationObj = this.readLinkProperty(iterationObj, name);
  1443.                                                     if (names[names.length - 1] === name && names.length - 1 === i) {
  1444.                                                         result = iterationObj;
  1445.                                                         if (callback) {
  1446.                                                             callback.call(_global, result, linkProperty);
  1447.                                                         }
  1448.                                                     }
  1449.                                                     // 终止对接下来的属性的遍历
  1450.                                                     if (typeof iterationObj === 'undefined') {
  1451.                                                         return -1;
  1452.                                                     }
  1453.                                                 });
  1454.                                                 return result;
  1455.                                             }
  1456.                                             var normalResult = null;
  1457.                                             if (linkProperty.slice(linkProperty.length - 2) === '()') {
  1458.                                                 var func = linkProperty.slice(0, linkProperty.length - 2);
  1459.                                                 normalResult = obj[func]();
  1460.                                             } else {
  1461.                                                 normalResult = obj[linkProperty];
  1462.                                             }
  1463.                                             if (normalResult === null) {
  1464.                                                 console.warn(obj, '的属性[\'' + linkProperty + '\']值未找到');
  1465.                                             }
  1466.                                             if (callback) {
  1467.                                                 callback.call(_global, normalResult, linkProperty);
  1468.                                             }
  1469.                                             return normalResult;
  1470.                                         }
  1471.                                         if (BaseUtils.isArray(linkProperty)) {
  1472.                                             var results = [];
  1473.                                             ArrayUtils.ergodicArrayObject(this, linkProperty, function (name) {
  1474.                                                 var value = this.readLinkProperty(obj, name);
  1475.                                                 results.push(value);
  1476.                                                 if (callback && name !== '') {
  1477.                                                     return callback.call(_global, value, name);
  1478.                                                 }
  1479.                                             });
  1480.                                             results.isMultipleResults = true;
  1481.                                             return results;
  1482.                                         }
  1483.                                     },
  1484.                                     /**
  1485.                                      * 为对象属性赋值
  1486.                                      * （同一个对象中不能够既有数字开头的属性名和普通属性名）
  1487.                                      * @param obj
  1488.                                      * @param linkProperty {string|Array} 属性表达式，多个属性则用数组
  1489.                                      * @param value
  1490.                                      */
  1491.                                     createLinkProperty: function (obj, linkProperty, value) {
  1492.                                         if (obj === null) {
  1493.                                             obj = {};
  1494.                                         }
  1495.                                         if (typeof linkProperty === 'string') {
  1496.                                             // 除去所有的空格
  1497.                                             linkProperty = linkProperty.replace(/ /g, '');
  1498.                                             // 不判断为空的值
  1499.                                             if (linkProperty === '') {
  1500.                                                 throw new TypeError('对象属性名不能为空')
  1501.                                             }
  1502.                                             if (linkProperty.indexOf(',') !== -1) {
  1503.                                                 var propertyNameArr = linkProperty.split(',');
  1504.                                                 this.createLinkProperty(obj, propertyNameArr, value);
  1505.                                                 return obj;
  1506.                                             }
  1507.                                             if (linkProperty.indexOf('.') !== -1) {
  1508.                                                 var names = linkProperty.split('.');
  1509.                                                 if (!obj.hasOwnProperty(names[0])) {
  1510.                                                     obj[names[0]] = {}
  1511.                                                 }
  1512.                                                 // 判断属性名是否以数字开头（若是代表是一个数组）
  1513.                                                 if (!Number.isNaN(parseInt(names[0]))) {
  1514.                                                     if (!ArrayUtils.isArrayObject(obj)) {
  1515.                                                         obj = [];
  1516.                                                     }
  1517.                                                 }
  1518.                                                 var propertyObj = obj[names[0]];
  1519.                                                 var newProperties = names.slice(1, names.length);
  1520.                                                 var newLinkProperty = '';
  1521.                                                 ArrayUtils.ergodicArrayObject(this, newProperties, function (property, i) {
  1522.                                                     if (i < newProperties.length - 1) {
  1523.                                                         newLinkProperty = newLinkProperty + property + '.'
  1524.                                                     } else {
  1525.                                                         newLinkProperty = newLinkProperty + property;
  1526.                                                     }
  1527.                                                 });
  1528.                                                 obj[names[0]] = this.createLinkProperty(propertyObj, newLinkProperty, value);
  1529.                                                 return obj;
  1530.                                             }
  1531.                                             // 判断属性名是否以数字开头（若是代表是一个数组）
  1532.                                             if (!Number.isNaN(parseInt(linkProperty))) {
  1533.                                                 if (!ArrayUtils.isArrayObject(obj)) {
  1534.                                                     obj = [];
  1535.                                                 }
  1536.                                             }
  1537.                                             obj[linkProperty] = value;
  1538.                                             return obj;
  1539.                                         } else if (BaseUtils.isArray(linkProperty)) {
  1540.                                             ArrayUtils.ergodicArrayObject(this, linkProperty, function (link) {
  1541.                                                 obj = this.createLinkProperty(obj, link, value);
  1542.                                             });
  1543.                                             return obj;
  1544.                                         }
  1545.                                     },
  1546.                                     /**
  1547.                                      * 遍历对象属性
  1548.                                      * @param context {object} 上下文
  1549.                                      * @param obj {object} 遍历对象
  1550.                                      * @param cb {function} 回调函数
  1551.                                      * @param isReadInnerObject {boolean=} 是否遍历内部对象的属性
  1552.                                      */
  1553.                                     ergodicObject: function (context, obj, cb, isReadInnerObject) {
  1554.                                         var keys = Object.keys(obj);
  1555.                                         ArrayUtils.ergodicArrayObject(this, keys, function (propertyName) {
  1556.                                             // 若内部对象需要遍历
  1557.                                             var _propertyName = propertyName;
  1558.                                             if (isReadInnerObject && obj[propertyName] !== null && typeof obj[propertyName] === 'object') {
  1559.                                                 this.ergodicObject(this, obj[propertyName], function (value, key) {
  1560.                                                     return cb.call(context, value, _propertyName + '.' + key);
  1561.                                                 }, true)
  1562.                                             } else {
  1563.                                                 return cb.call(context, obj[propertyName], propertyName);
  1564.                                             }
  1565.                                         })
  1566.                                     },
  1567.                                     /**
  1568.                                      * 当指定属性为空或不存在时执行回到函数；
  1569.                                      * @param context {object} 上下文
  1570.                                      * @param obj {object} 检测对象
  1571.                                      * @param propertyNames{Array|string} 需要检测的属性名
  1572.                                      *                                     可以检查多级属性如:'a.b.c.e'，
  1573.                                      *                                     多个属性使用数组，支持纯字符串多个属性用','隔开
  1574.                                      * @param cb {function} 回调函数[参数：为空或不存在的属性名,返回值为'-1'时，跳过之后的回调函数]
  1575.                                      */
  1576.                                     whileEmptyObjectProperty: function (context, obj, propertyNames, cb) {
  1577.                                         // 解析单个属性名
  1578.                                         if (typeof propertyNames === 'string') {
  1579.                                             // 除去所有的空格
  1580.                                             propertyNames = propertyNames.replace(/ /g, '');
  1581.                                             // 不判断为空的值
  1582.                                             if (propertyNames === '') {
  1583.                                                 return;
  1584.                                             }
  1585.                                             // 若是以','隔开的伪数组，则转化为数组再进行操作
  1586.                                             if (propertyNames.indexOf(',') !== -1) {
  1587.                                                 var propertyNameArr = propertyNames.split(',');
  1588.                                                 return this.whileEmptyObjectProperty(context, obj, propertyNameArr, cb);
  1589.                                             }
  1590.                                             // 若指定级联属性
  1591.                                             if (propertyNames.indexOf('.') !== -1) {
  1592.                                                 var names = propertyNames.split('.');
  1593.                                                 var iterationObj = obj;
  1594.                                                 var result = null;
  1595.                                                 ArrayUtils.ergodicArrayObject(this, names, function (name) {
  1596.                                                     if (iterationObj && iterationObj.hasOwnProperty(name)) {
  1597.                                                         iterationObj = iterationObj[name];
  1598.                                                     } else {
  1599.                                                         result = cb.call(_global, propertyNames);
  1600.                                                         // 终止对接下来的属性的遍历
  1601.                                                         return -1;
  1602.                                                     }
  1603.                                                 });
  1604.                                                 return result;
  1605.                                             }
  1606.                                             // 正常流程
  1607.                                             if (!obj.hasOwnProperty(propertyNames)) {
  1608.                                                 return cb.call(context, propertyNames);
  1609.                                             }
  1610.                                             if (obj[propertyNames] === null || obj[propertyNames] === '') {
  1611.                                                 return cb.call(context, propertyNames);
  1612.                                             }
  1613.                                         } else if (BaseUtils.isArray(propertyNames)) {
  1614.                                             // 解析数组
  1615.                                             var _this = this;
  1616.                                             ArrayUtils.ergodicArrayObject(this, propertyNames, function (propertyName) {
  1617.                                                 // 递归调用
  1618.                                                 return _this.whileEmptyObjectProperty(context, obj, propertyName, cb);
  1619.                                             })
  1620.                                         }
  1621.                                     },
  1622.                                     whileEmptyObjectPropertyV2: function (context, obj, propertyNames, cb) {
  1623.                                         this.readLinkProperty(obj, propertyNames, function (value, propertyName) {
  1624.                                             if (value === null || value === '' || parseInt(value) < 0) {
  1625.                                                 return cb.call(context, propertyName);
  1626.                                             }
  1627.                                         })
  1628.                                     },
  1629.                                     /**
  1630.                                      * 克隆对象[只克隆属性，不克隆原型链]
  1631.                                      * @param obj {*}
  1632.                                      */
  1633.                                     cloneObject: function (obj) {
  1634.                                         var newObj = {};
  1635.                                         // 判断是否为基本数据类型，若是则直接返回
  1636.                                         if (typeof obj === 'string' ||
  1637.                                             typeof obj === 'number' ||
  1638.                                             typeof obj === 'undefined' ||
  1639.                                             typeof obj === 'function' ||
  1640.                                             typeof obj === 'boolean') {
  1641.                                             return obj;
  1642.                                         }
  1643.                                         // 判断是否是数组
  1644.                                         if (BaseUtils.isArray(obj)) {
  1645.                                             newObj = [];
  1646.                                             // 遍历数组并递归调用该方法获取数组内部对象的克隆对象并push到新数组
  1647.                                             ArrayUtils.ergodicArrayObject(this, obj, function (arrObjValue) {
  1648.                                                 newObj.push(this.cloneObject(arrObjValue));
  1649.                                             })
  1650.                                         } else if (typeof obj === 'object') {
  1651.                                             // 当目标为一般对象时即 typeof 为 object
  1652.                                             if (obj === null) {
  1653.                                                 // 当克隆对象为空时，返回空
  1654.                                                 return null;
  1655.                                             }
  1656.                                             // 遍历对象的属性并调用递归方法获得该属性对应的对象的克隆对象并将其重新赋值到该属性
  1657.                                             this.ergodicObject(this, obj, function (value, key) {
  1658.                                                 newObj[key] = this.cloneObject(value);
  1659.                                             });
  1660.                                         }
  1661.                                         return newObj;
  1662.                                     },
  1663.                                     /**
  1664.                                      * 获取对象的哈希码
  1665.                                      * @param obj {Object}
  1666.                                      * @returns {number}
  1667.                                      */
  1668.                                     getObjHashCode: function (obj) {
  1669.                                         var str = JSON.stringify(obj);
  1670.                                         var hash = 0, i, chr, len;
  1671.                                         console.log(str)
  1672.                                         console.log(hash)
  1673.                                         if (str.length === 0) return hash;
  1674.                                         for (i = 0, len = str.length; i < len; i++) {
  1675.                                             chr = str.charCodeAt(i);
  1676.                                             hash = ((hash << 5) - hash) + chr;
  1677.                                             hash |= 0; // Convert to 32bit integer
  1678.                                         }
  1679.                                         console.log(str)
  1680.                                         console.log(hash)
  1681.                                         return hash;
  1682.                                     },
  1683.                                     /**
  1684.                                      * 扩展对象属性
  1685.                                      * @param obj 原对象
  1686.                                      * @param extendedObj 被扩展的对象
  1687.                                      * @param isCover {boolean=} 扩展的属性和原来属性冲突时是否覆盖 默认[false]
  1688.                                      * @param isClone {boolean=} 是否返回一个新的对象，默认[false]返回扩展后的原对象
  1689.                                      */
  1690.                                     expandObject: function (obj, extendedObj, isCover, isClone) {
  1691.                                         var resultObj = obj;
  1692.                                         if (isClone) {
  1693.                                             resultObj = this.cloneObject(obj);
  1694.                                         }
  1695.                                         this.ergodicObject(this, extendedObj, function (value, key) {
  1696.                                             if (isCover && this.readLinkProperty(resultObj, key) !== null) {
  1697.                                                 return;
  1698.                                             }
  1699.                                             resultObj = this.createLinkProperty(resultObj, key, value);
  1700.                                         }, true);
  1701.                                         return resultObj;
  1702.                                     },
  1703.                                     /**
  1704.                                      * 为数组排序，当数组中的元素为对象时，根据指定对象的属性名进行排序
  1705.                                      * @param arr 数组
  1706.                                      * @param propertyName 属性名（当有多个属性名时，为多级排序）
  1707.                                      * @param order 升降序
  1708.                                      * @returns {*}
  1709.                                      */
  1710.                                     sortingArrayByProperty: function (arr, propertyName, order) {
  1711.                                         var _this = this;
  1712.                                         var sortSetting = {
  1713.                                             // 是否创建新数据
  1714.                                             createNewData: false,
  1715.                                             // 通过该方法获取数组中每个对象中用来比较的属性
  1716.                                             getComparedProperty: function (arr) {
  1717.                                                 var compareArr = [];
  1718.                                                 ArrayUtils.ergodicArrayObject(_this, arr, function (obj, i) {
  1719.                                                     if (typeof obj !== 'object') {
  1720.                                                         compareArr.push(obj);
  1721.                                                     } else {
  1722.                                                         var compareValue = this.readLinkProperty(obj, propertyName);
  1723.                                                         if (compareValue !== null) {
  1724.                                                             compareArr.push(compareValue);
  1725.                                                         } else {
  1726.                                                             compareArr.push(obj);
  1727.                                                         }
  1728.                                                     }
  1729.                                                 });
  1730.                                                 return compareArr.slice(0);
  1731.                                             }
  1732.                                         };
  1733.                                         return ArrayUtils.sortingArrays(arr, order, sortSetting);
  1734.                                     },
  1735.                                     /**
  1736.                                      * 转话为目标的实例
  1737.                                      * @param constructor {function} 构造函数
  1738.                                      * @param obj {object|Array}判断的对象
  1739.                                      * @param defaultProperty {object=}
  1740.                                      */
  1741.                                     toAimObject: function (obj, constructor, defaultProperty) {
  1742.                                         if (BaseUtils.isArray(obj)) {
  1743.                                             var originArr = [];
  1744.                                             ArrayUtils.ergodicArrayObject(this, obj, function (value) {
  1745.                                                 originArr.push(this.toAimObject(value, constructor, defaultProperty));
  1746.                                             });
  1747.                                             return originArr;
  1748.                                         } else if (typeof obj === 'object') {
  1749.                                             if (defaultProperty) {
  1750.                                                 this.ergodicObject(this, defaultProperty, function (value, key) {
  1751.                                                     if (obj[key] === null) {
  1752.                                                         obj[key] = value;
  1753.                                                     }
  1754.                                                 });
  1755.                                             }
  1756.                                             if (obj instanceof constructor) {
  1757.                                                 return obj;
  1758.                                             }
  1759.                                             var originObj = obj;
  1760.                                             while (originObj.__proto__ !== null && originObj.__proto__ !== Object.prototype) {
  1761.                                                 originObj = originObj.__proto__;
  1762.                                             }
  1763.                                             originObj.__proto__ = constructor.prototype;
  1764.                                             return originObj;
  1765.                                         }
  1766.                                     },
  1767.                                     /**
  1768.                                      * 将数组中结构类似对象指定属性融合为一个数组
  1769.                                      * @param arr {Array}
  1770.                                      * @param propertyNames
  1771.                                      */
  1772.                                     parseTheSameObjectPropertyInArray: function (arr, propertyNames) {
  1773.                                         var result = {};
  1774.                                         var temp = {};
  1775.                                         ArrayUtils.ergodicArrayObject(this, arr, function (obj) {
  1776.                                             // 获取想要得到的所有属性，以属性名为键值存储到temp中
  1777.                                             this.readLinkProperty(obj, propertyNames, function (value, property) {
  1778.                                                 if (!temp.hasOwnProperty(property) || !(BaseUtils.isArray(temp[property]))) {
  1779.                                                     temp[property] = [];
  1780.                                                 }
  1781.                                                 temp[property].push(value);
  1782.                                             });
  1783.                                         });
  1784.                                         // 遍历temp获取每个键值中的值，并单独取出
  1785.                                         this.ergodicObject(this, temp, function (value, key) {
  1786.                                             result = this.createLinkProperty(result, key, value);
  1787.                                         });
  1788.                                         return this.cloneObject(result);
  1789.                                     },
  1790.                                     /**
  1791.                                      * 将数组中结构类似对象指定属性融合为一个数组
  1792.                                      * @param arr {Array}
  1793.                                      */
  1794.                                     parseTheSameObjectAllPropertyInArray: function (arr) {
  1795.                                         if (!ArrayUtils.isArrayObject(arr) || arr.length < 1) {
  1796.                                             return;
  1797.                                         }
  1798.                                         // 获取一个对象的所有属性，包括内部对象的属性
  1799.                                         var propertyNames = [];
  1800.                                         this.ergodicObject(this, arr[0], function (v, k) {
  1801.                                             propertyNames.push(k);
  1802.                                         }, true);
  1803.                                         return this.parseTheSameObjectPropertyInArray(arr, propertyNames);
  1804.                                     },
  1805.                                     /**
  1806.                                      * 获取对象属性，若为数组则计算其中数字的平均值或其它
  1807.                                      * @param obj
  1808.                                      * @param propertyNames{Array<string>|string}
  1809.                                      * @param type
  1810.                                      */
  1811.                                     getCalculationInArrayByLinkPropertyNames: function (obj, propertyNames, type) {
  1812.                                         var resultObject = {};
  1813.                                         var _this = this;
  1814.                                         switch (type) {
  1815.                                             default:
  1816.                                             case 'sum':
  1817.                                                 this.readLinkProperty(obj, propertyNames, function (value, key) {
  1818.                                                     if (ArrayUtils.isArrayObject(value)) {
  1819.                                                         resultObject = _this.createLinkProperty(resultObject, key, ArrayUtils.getSumInArray(value));
  1820.                                                     }
  1821.                                                 });
  1822.                                                 break;
  1823.                                             case 'average':
  1824.                                                 this.readLinkProperty(obj, propertyNames, function (value, key) {
  1825.                                                     if (ArrayUtils.isArrayObject(value)) {
  1826.                                                         resultObject = _this.createLinkProperty(resultObject, key, ArrayUtils.getAverageInArray(value));
  1827.                                                     }
  1828.                                                 });
  1829.                                                 break;
  1830.                                         }
  1831.                                         return resultObject;
  1832.                                     }
  1833.                                 }
  1834.                             });
  1835.     
  1836.                             // ColorUtils
  1837.                             factory('ColorUtils', [], function () {
  1838.                                 return {
  1839.                                     /**
  1840.                                      * 转换颜色rgb为16进制
  1841.                                      * @param r
  1842.                                      * @param g
  1843.                                      * @param b
  1844.                                      * @return {string}
  1845.                                      */
  1846.                                     rgbToHex: function (r, g, b) {
  1847.                                         var hex = ((r << 16) | (g << 8) | b).toString(16);
  1848.                                         return "#" + new Array(Math.abs(hex.length - 7)).join("0") + hex;
  1849.                                     },
  1850.                                     /**
  1851.                                      * 转换颜色16进制为rgb
  1852.                                      * @param hex
  1853.                                      * @return {Array}
  1854.                                      */
  1855.                                     hexToRgb: function (hex) {
  1856.                                         hex = hex.replace(/ /g, '');
  1857.                                         var length = hex.length;
  1858.                                         var rgb = [];
  1859.                                         switch (length) {
  1860.                                             case 4:
  1861.                                                 rgb.push(parseInt(hex[1] + hex[1], 16));
  1862.                                                 rgb.push(parseInt(hex[2] + hex[2], 16));
  1863.                                                 rgb.push(parseInt(hex[3] + hex[3], 16));
  1864.                                                 return rgb;
  1865.                                             case 7:
  1866.                                                 for (var i = 1; i < 7; i += 2) {
  1867.                                                     rgb.push(parseInt("0x" + hex.slice(i, i + 2)));
  1868.                                                 }
  1869.                                                 return rgb;
  1870.                                             default:
  1871.                                                 break
  1872.                                         }
  1873.                                     },
  1874.                                     /**
  1875.                                      * 根据两个颜色以及之间的百分比获取渐进色
  1876.                                      * @param start
  1877.                                      * @param end
  1878.                                      * @param percentage
  1879.                                      * @return {*}
  1880.                                      */
  1881.                                     gradientColorsPercentage: function (start, end, percentage) {
  1882.                                         var resultRgb = [];
  1883.                                         var startRgb = this.hexToRgb(start);
  1884.                                         if (end == null) {
  1885.                                             return start;
  1886.                                         }
  1887.                                         var endRgb = this.hexToRgb(end);
  1888.                                         var totalR = endRgb[0] - startRgb[0];
  1889.                                         var totalG = endRgb[1] - startRgb[1];
  1890.                                         var totalB = endRgb[2] - startRgb[2];
  1891.                                         resultRgb.push(startRgb[0] + totalR * percentage);
  1892.                                         resultRgb.push(startRgb[1] + totalG * percentage);
  1893.                                         resultRgb.push(startRgb[2] + totalB * percentage);
  1894.                                         return this.rgbToHex(resultRgb[0], resultRgb[1], resultRgb[2])
  1895.                                     }
  1896.                                 }
  1897.                             });
  1898.     
  1899.                             factory('FunctionUtils', [], function () {
  1900.                                 return {
  1901.                                     /**
  1902.                                      * 获取方法的名字
  1903.                                      * @param func
  1904.                                      * @returns {*}
  1905.                                      */
  1906.                                     getFunctionName: function (func) {
  1907.                                         if (typeof func === 'function' || typeof func === 'object') {
  1908.                                             var name = ('' + func).match(/function\s*([\w\$]*)\s*\(/);
  1909.                                         }
  1910.                                         return func.name || name[1];
  1911.                                     },
  1912.                                     /**
  1913.                                      * 获取方法的参数名
  1914.                                      * @param func
  1915.                                      * @returns {*}
  1916.                                      */
  1917.                                     getFunctionParams: function (func) {
  1918.                                         if (typeof func === 'function' || typeof func === 'object') {
  1919.                                             var name = ('' + func).match(/function.*\(([^)]*)\)/);
  1920.                                             return name[1].replace(/( )|(\n)/g, '').split(',');
  1921.                                         }
  1922.                                     },
  1923.                                     /**
  1924.                                      * 通过方法的arguments获取调用该方法的函数
  1925.                                      * @param func_arguments
  1926.                                      * @returns {string}
  1927.                                      */
  1928.                                     getCallerName: function (func_arguments) {
  1929.                                         var caller = func_arguments.callee.caller;
  1930.                                         var callerName = '';
  1931.                                         if (caller) {
  1932.                                             callerName = this.getFunctionName(caller);
  1933.                                         }
  1934.                                         return callerName;
  1935.                                     },
  1936.                                     FunctionBuilder: function (func) {
  1937.                                         var _this = this;
  1938.                                         var fs = [];
  1939.                                         fs.push(func);
  1940.                                         var properties = ['push', 'unshift', 'slice', 'map', 'forEach', 'keys', 'find', 'concat', 'fill', 'shift', 'values'];
  1941.                                         map.call(properties, function (property) {
  1942.                                             if (typeof Array.prototype[property] === 'function') {
  1943.                                                 Object.defineProperty(_this, property, {
  1944.                                                     get: function () {
  1945.                                                         return function () {
  1946.                                                             fs[property].apply(fs, arguments);
  1947.                                                             return this;
  1948.                                                         }
  1949.                                                     }
  1950.                                                 });
  1951.                                             }
  1952.                                         });
  1953.                                         this.result = function (context) {
  1954.                                             var rfs = [];
  1955.                                             map.call(fs, function (f, index) {
  1956.                                                 if (typeof f === 'function') {
  1957.                                                     rfs.push(f);
  1958.                                                 }
  1959.                                             });
  1960.                                             return function () {
  1961.                                                 var declareVar = {
  1962.                                                     arguments: arguments,
  1963.                                                     this: this
  1964.                                                 };
  1965.                                                 map.call(rfs, function (f) {
  1966.                                                     var dv = f.apply(context || this, [declareVar]);
  1967.                                                     if (dv) {
  1968.                                                         map.call(Object.keys(dv), function (key) {
  1969.                                                             declareVar[key] = dv[key];
  1970.                                                         });
  1971.                                                     }
  1972.                                                 });
  1973.                                                 return declareVar.returnValue;
  1974.                                             }
  1975.                                         }
  1976.                                     },
  1977.                                     invokeMethods: function (context, methods, args) {
  1978.                                         if (!this.isArray(methods)) {
  1979.                                             return;
  1980.                                         }
  1981.                                         var results = [];
  1982.                                         var _this = this;
  1983.                                         this.ergodicArrayObject(context, methods, function (method) {
  1984.                                             if (!_this.isFunction(method)) {
  1985.                                                 return;
  1986.                                             }
  1987.                                             results.push(
  1988.                                                 method.apply(context, args)
  1989.                                             );
  1990.                                         });
  1991.                                         return results;
  1992.                                     }
  1993.                                 }
  1994.                             });
  1995.     
  1996.                             factory('UrlUtils', [], function () {
  1997.                                 return {
  1998.                                     urlMatching: function (url, matchUrl) {
  1999.                                         var pattern = new RegExp(matchUrl);
  2000.                                         return pattern.test(url);
  2001.                                     },
  2002.                                     getUrlWithoutParam: function (url) {
  2003.                                         return url.split('?')[0];
  2004.                                     },
  2005.                                     getParamFromUrl: function (url) {
  2006.                                         var params = [];
  2007.                                         var parts = url.split('?');
  2008.                                         if (parts.length < 2) {
  2009.                                             return params;
  2010.                                         }
  2011.                                         var paramsStr = parts[1].split('&');
  2012.                                         for (var i = 0; i < paramsStr.length; i++) {
  2013.                                             var index = paramsStr[i].indexOf('=');
  2014.                                             var ps = new Array(2);
  2015.                                             if (index !== -1) {
  2016.                                                 ps = [
  2017.                                                     paramsStr[i].substring(0, index),
  2018.                                                     paramsStr[i].substring(index + 1),
  2019.                                                 ];
  2020.                                             } else {
  2021.                                                 ps[0] = paramsStr[i];
  2022.                                             }
  2023.                                             params.push({
  2024.                                                 key: ps[0],
  2025.                                                 value: ps[1]
  2026.                                             });
  2027.                                         }
  2028.                                         return params;
  2029.                                     },
  2030.                                     margeUrlAndParams: function (url, params) {
  2031.                                         if (url.indexOf('?') !== -1 || !(params instanceof Array)) {
  2032.                                             return url;
  2033.                                         }
  2034.                                         var paramsStr = [];
  2035.                                         for (var i = 0; i < params.length; i++) {
  2036.                                             if (params[i].key !== null && params[i].value !== null) {
  2037.                                                 paramsStr.push(params[i].key + '=' + params[i].value);
  2038.                                             }
  2039.                                         }
  2040.                                         return url + '?' + paramsStr.join('&');
  2041.                                     }
  2042.                                 }
  2043.                             });
  2044.     
  2045.                             factory('PointUtils', [], function () {
  2046.                                 var Point2D = function (x, y) {
  2047.                                     this.x = x || 0;
  2048.                                     this.y = y || 0;
  2049.                                 };
  2050.                                 Point2D.prototype = {
  2051.                                     constructor: Point2D,
  2052.                                     /**
  2053.                                      * 获取指定距离和角度对应的平面点
  2054.                                      * @param distance
  2055.                                      * @param deg
  2056.                                      */
  2057.                                     getOtherPointFromDistanceAndDeg: function (distance, deg) {
  2058.                                         var radian = Math.PI / 180 * deg;
  2059.                                         var point = new this.constructor();
  2060.                                         point.x = distance * Math.sin(radian) + this.x;
  2061.                                         point.y = this.y - distance * Math.cos(radian);
  2062.                                         return point;
  2063.                                     },
  2064.                                     /**
  2065.                                      * 获取当前平面点与另一个平面点之间的距离
  2066.                                      * @param p
  2067.                                      * @returns {number}
  2068.                                      */
  2069.                                     getDistanceFromAnotherPoint: function (p) {
  2070.                                         return Math.sqrt((this.x - p.x) * (this.x - p.x) + (this.y - p.y) * (this.y - p.y));
  2071.                                     },
  2072.                                     /**
  2073.                                      * 获取当前平面点与另一个平面点之间的角度
  2074.                                      * @param p
  2075.                                      * @returns {number}
  2076.                                      */
  2077.                                     getDegFromAnotherPoint: function (p) {
  2078.                                         var usedPoint = new Point2D(p.x * 1000000 - this.x * 1000000, p.y * 1000000 - this.y * 1000000);
  2079.                                         var radian = Math.atan2(usedPoint.x * 1000000, usedPoint.y * 1000000);
  2080.                                         var deg = radian * 180 / Math.PI;
  2081.                                         return 180 - deg;
  2082.                                     },
  2083.                                     /**
  2084.                                      * 判断该点是否位于一矩形内部
  2085.                                      * @param x 矩形开始坐标x
  2086.                                      * @param y 矩形开始坐标y
  2087.                                      * @param width 矩形宽
  2088.                                      * @param height 矩形长
  2089.                                      * @returns {boolean}
  2090.                                      */
  2091.                                     isInRect: function (x, y, width, height) {
  2092.                                         var px = this.x;
  2093.                                         var py = this.y;
  2094.                                         if (px < x || px > x + width) {
  2095.                                             return false;
  2096.                                         }
  2097.                                         return !(py < y || py > y + height);
  2098.                                     }
  2099.                                 };
  2100.                                 return {
  2101.                                     Point2D: Point2D
  2102.                                 }
  2103.                             });
  2104.     
  2105.     
  2106.                             factory('PropExpand', ['BaseUtils', 'ObjectUtils', 'ArrayUtils', 'UrlUtils'],
  2107.                                 function (BaseUtils, ObjectUtils, ArrayUtils, UrlUtils) {
  2108.                                     return {
  2109.                                         Object: {
  2110.                                             getProperty: function (_self, propertyLink) {
  2111.                                                 return ObjectUtils.readLinkProperty(_self, propertyLink);
  2112.                                             },
  2113.                                             setProperty: function (_self, propertyLink, value) {
  2114.                                                 ObjectUtils.createLinkProperty(_self, propertyLink, value);
  2115.                                             },
  2116.                                             mapConvert: function (_self, mapper) {
  2117.     
  2118.                                             },
  2119.                                             keyMap: function (_self, cb) {
  2120.                                             },
  2121.                                             keyValues: function (_self, cb) {
  2122.                                             },
  2123.                                             keyFilter: function (_self, cb) {
  2124.                                             },
  2125.                                         },
  2126.                                         Array: {
  2127.                                             map: function () {
  2128.                                             },
  2129.                                             forEach: function () {
  2130.                                             },
  2131.                                             filter: function () {
  2132.                                             },
  2133.                                             reduce: function () {
  2134.                                             },
  2135.                                             keep: function () {
  2136.                                             },
  2137.                                             remove: function () {
  2138.                                             }
  2139.                                         },
  2140.                                         String: {
  2141.                                             join: function (_self, arr) {
  2142.                                             },
  2143.                                         }
  2144.                                     }
  2145.                                 });
  2146.     
  2147.                             _global.everyUtils = function () {
  2148.                                 if (BaseUtils.isArray(arguments[0])) {
  2149.                                     depend.call(arguments[2] || this, arguments[0], arguments[1]);
  2150.                                 } else if (BaseUtils.isFunction(arguments[0])) {
  2151.                                     var args = arguments;
  2152.                                     depend.call(arguments[1] || this, ['FunctionUtils'], function (FunctionUtils) {
  2153.                                         var depends = FunctionUtils.getFunctionParams(args[0]);
  2154.                                         depend(depends, args[0]);
  2155.                                     })
  2156.                                 }
  2157.                             };
  2158.     
  2159.                             _global.eUtils = (function () {
  2160.                                 var utils = {};
  2161.                                 if (_global.everyUtils) {
  2162.                                     _global.everyUtils([
  2163.                                         'ArrayUtils', 'ObjectUtils', 'BaseUtils', 'FunctionUtils', 'ColorUtils', 'PointUtils', 'UrlUtils'
  2164.                                     ], function (
  2165.                                         ArrayUtils,
  2166.                                         ObjectUtils,
  2167.                                         BaseUtils,
  2168.                                         FunctionUtils,
  2169.                                         ColorUtils,
  2170.                                         PointUtils,
  2171.                                         UrlUtils) {
  2172.                                         utils = {
  2173.                                             ArrayUtils: ArrayUtils,
  2174.                                             ObjectUtils: ObjectUtils,
  2175.                                             BaseUtils: BaseUtils,
  2176.                                             ColorUtils: ColorUtils,
  2177.                                             UrlUtils: UrlUtils,
  2178.                                             urlUtils: UrlUtils,
  2179.                                             PointUtils: PointUtils,
  2180.                                             FunctionUtils: FunctionUtils
  2181.                                         };
  2182.                                     });
  2183.                                 }
  2184.                                 var proxy = {};
  2185.                                 forEach.call(Object.keys(utils), function (utilName) {
  2186.                                     if (!utilName) {
  2187.                                         return;
  2188.                                     }
  2189.                                     Object.defineProperty(proxy, utilName, {
  2190.                                         get: function () {
  2191.                                             return utils[utilName];
  2192.                                         }
  2193.                                     });
  2194.                                     forEach.call(Object.keys(utils[utilName]), function (key) {
  2195.                                         if (!key) {
  2196.                                             return;
  2197.                                         }
  2198.                                         if (proxy[key]) {
  2199.                                             return;
  2200.                                         }
  2201.                                         Object.defineProperty(proxy, key, {
  2202.                                             get: function () {
  2203.                                                 return utils[utilName][key];
  2204.                                             }
  2205.                                         })
  2206.                                     })
  2207.                                 });
  2208.                                 return proxy;
  2209.                             })();
  2210.     
  2211.                             return _global.eUtils;
  2212.                         }));
  2213.     
  2214.                         /***/
  2215.     })
  2216.     /******/]);
  2217.     /************************************************************************/
  2218.     /******/ 	// The module cache
  2219.     /******/ 	var __webpack_module_cache__ = {};
  2220.     /******/
  2221.     /******/ 	// The require function
  2222.     /******/ 	function __webpack_require__(moduleId) {
  2223.     /******/ 		// Check if module is in cache
  2224.     /******/ 		if (__webpack_module_cache__[moduleId]) {
  2225.     /******/ 			return __webpack_module_cache__[moduleId].exports;
  2226.                         /******/
  2227.     }
  2228.     /******/ 		// Create a new module (and put it into the cache)
  2229.     /******/ 		var module = __webpack_module_cache__[moduleId] = {
  2230.     /******/ 			// no module.id needed
  2231.     /******/ 			// no module.loaded needed
  2232.     /******/ 			exports: {}
  2233.                         /******/
  2234.     };
  2235.     /******/
  2236.     /******/ 		// Execute the module function
  2237.     /******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  2238.     /******/
  2239.     /******/ 		// Return the exports of the module
  2240.     /******/ 		return module.exports;
  2241.                     /******/
  2242.     }
  2243.     /******/
  2244.     /************************************************************************/
  2245.     /******/ 	// module exports must be returned from runtime so entry inlining is disabled
  2246.     /******/ 	// startup
  2247.     /******/ 	// Load entry module and return exports
  2248.     /******/ 	return __webpack_require__(0);
  2249.                 /******/
  2250.     })()
  2251.                 ;
  2252.         });
  2253.     
  2254.     
  2255.     
  2256.     
  2257.     
  2258.         // var path = require('path')
  2259.         // // alert(path.join(__dirname, 'everyHook.js'))
  2260.         // require(path.join(__dirname, '/js/everyHook.js'))
  2261.         // // document.addEventListener('readystatechange', function () {
  2262.         // //     if (document.readyState === "interactive" || document.readyState === "complete") {
  2263.         // //         window.isDOMLoaded = true;
  2264.         // //     }
  2265.         // // });
  2266.         ~function (global) {
  2267.             var workerURLs = [];
  2268.             var extraElements = [];
  2269.             var suppressEvents = {};
  2270.             var helper = function (eHookContext, timerContext, util) {
  2271.                 return {
  2272.                     applyUI: function () {
  2273.                         var style = '._th-container ._th-item{margin-bottom:3px;position:relative;width:0;height:0;cursor:pointer;opacity:.3;background-color:#ffffff;border-radius:100%;text-align:center;line-height:30px;-webkit-transition:all .35s;-o-transition:all .35s;transition:all .35s;right:30px}._th-container ._th-item,._th-container ._th-click-hover,._th_cover-all-show-times ._th_times{-webkit-box-shadow:-3px 4px 12px -5px black;box-shadow:-3px 4px 12px -5px black}._th-container:hover ._th-item._item-x2{margin-left:18px;width:40px;height:40px;line-height:40px}._th-container:hover ._th-item._item-x-2{margin-left:17px;width:38px;height:38px;line-height:38px}._th-container:hover ._th-item._item-xx2{width:36px;height:36px;margin-left:16px;line-height:36px}._th-container:hover ._th-item._item-xx-2{width:32px;height:32px;line-height:32px;margin-left:14px}._th-container:hover ._th-item._item-reset{width:30px;line-height:30px;height:30px;margin-left:10px}._th-click-hover{position:relative;-webkit-transition:all .5s;-o-transition:all .5s;transition:all .5s;height:45px;width:45px;cursor:pointer;opacity:.3;border-radius:100%;background-color:#ffffff;text-align:center;line-height:45px;right:-10px}._th-container:hover{left:-5px}._th-container{font-size:12px;-webkit-transition:all .5s;-o-transition:all .5s;transition:all .5s;left:-35px;top:20%;position:fixed;-webkit-box-sizing:border-box;box-sizing:border-box;z-index:9999999999;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}._th-container ._th-item:hover{opacity:.8;background-color:#87CEFA;color:aliceblue}._th-container ._th-item:active{opacity:.9;background-color:#87CEFA;color:aliceblue}._th-container:hover ._th-click-hover{opacity:.8}._th-container:hover ._th-item{opacity:.6;right:0}._th-container ._th-click-hover:hover{opacity:.8;background-color:#87CEFA;color:aliceblue}._th_cover-all-show-times{position:fixed;top:0;right:0;width:100%;height:100%;z-index:9999999;opacity:1;font-weight:900;font-size:30px;color:#4f4f4f;background-color:rgba(0,0,0,0.1)}._th_cover-all-show-times._th_hidden{z-index:-99999999;opacity:0;-webkit-transition:1s all;-o-transition:1s all;transition:1s all}._th_cover-all-show-times ._th_times{width:300px;height:300px;border-radius:50%;background-color:rgba(127,255,212,0.51);text-align:center;line-height:300px;position:absolute;top:50%;right:50%;margin-top:-150px;margin-right:-150px}';
  2274.     
  2275.                         var displayNum = (1 / timerContext._percentage).toFixed(2);
  2276.     
  2277.                         // 在页面左边添加一个半圆便于修改
  2278.                         var html = '<div class="_th-container">\n' +
  2279.                             '    <div class="_th-click-hover _item-input">\n' +
  2280.                             '        x' + displayNum + '\n' +
  2281.                             '    </div>\n' +
  2282.                             '    <div class="_th-item _item-x2">&gt;</div>\n' +
  2283.                             '    <div class="_th-item _item-x-2">&lt;</div>\n' +
  2284.                             '    <div class="_th-item _item-xx2">&gt;&gt;</div>\n' +
  2285.                             '    <div class="_th-item _item-xx-2">&lt;&lt;</div>\n' +
  2286.                             '    <div class="_th-item _item-reset">O</div>\n' +
  2287.                             '</div>\n' +
  2288.                             '<div class="_th_cover-all-show-times _th_hidden">\n' +
  2289.                             '    <div class="_th_times">x' + displayNum + '</div>\n' +
  2290.                             '</div>' +
  2291.                             '';
  2292.                         var stylenode = document.createElement('style');
  2293.                         stylenode.setAttribute("type", "text/css");
  2294.                         if (stylenode.styleSheet) {// IE
  2295.                             stylenode.styleSheet.cssText = style;
  2296.                         } else {// w3c
  2297.                             var cssText = document.createTextNode(style);
  2298.                             stylenode.appendChild(cssText);
  2299.                         }
  2300.                         var node = document.createElement('div');
  2301.                         node.innerHTML = html;
  2302.     
  2303.                         var clickMapper = {
  2304.                             '_item-input': function () {
  2305.                                 changeTime();
  2306.                             },
  2307.                             '_item-x2': function () {
  2308.                                 changeTime(2, 0, true);
  2309.                             },
  2310.                             '_item-x-2': function () {
  2311.                                 changeTime(-2, 0, true);
  2312.                             },
  2313.                             '_item-xx2': function () {
  2314.                                 changeTime(0, 2);
  2315.                             },
  2316.                             '_item-xx-2': function () {
  2317.                                 changeTime(0, -2);
  2318.                             },
  2319.                             '_item-reset': function () {
  2320.                                 changeTime(0, 0, false, true);
  2321.                             }
  2322.                         };
  2323.     
  2324.                         Object.keys(clickMapper).forEach(function (className) {
  2325.                             var exec = clickMapper[className];
  2326.                             var targetEle = node.getElementsByClassName(className)[0];
  2327.                             if (targetEle) {
  2328.                                 targetEle.onclick = exec;
  2329.                             }
  2330.                         });
  2331.     
  2332.                         if (!global.isDOMLoaded) {
  2333.                             // document.head.appendChild(stylenode);
  2334.                             // document.body.appendChild(node);
  2335.                             global.isDOMRendered = true;
  2336.                             console.log('Time Hooker Works!');
  2337.                             // document.addEventListener('readystatechange', function () {
  2338.                             //     if ((document.readyState === "interactive" || document.readyState === "complete") && !global.isDOMRendered) {
  2339.     
  2340.                             //     }
  2341.                             // });
  2342.                         } else {
  2343.                             // document.head.appendChild(stylenode);
  2344.                             // document.body.appendChild(node);
  2345.                             global.isDOMRendered = true;
  2346.                             console.log('Time Hooker Works!');
  2347.                         }
  2348.                     },
  2349.                     applyGlobalAction: function (timer) {
  2350.                         // 界面半圆按钮点击的方法
  2351.                         timer.changeTime = function (anum, cnum, isa, isr) {
  2352.                             if (isr) {
  2353.                                 global.timer.change(1);
  2354.                                 return;
  2355.                             }
  2356.                             if (!global.timer) {
  2357.                                 return;
  2358.                             }
  2359.                             var result;
  2360.                             if (!anum && !cnum) {
  2361.                                 return
  2362.                                 // var t = prompt("输入欲改变计时器变化倍率（当前：" + 1 / timerContext._percentage + "）");
  2363.                                 // if (t == null) {
  2364.                                 //     return;
  2365.                                 // }
  2366.                                 // if (isNaN(parseFloat(t))) {
  2367.                                 //     alert("请输入正确的数字");
  2368.                                 //     timer.changeTime();
  2369.                                 //     return;
  2370.                                 // }
  2371.                                 // if (parseFloat(t) <= 0) {
  2372.                                 //     alert("倍率不能小于等于0");
  2373.                                 //     timer.changeTime();
  2374.                                 //     return;
  2375.                                 // }
  2376.                                 // result = 1 / parseFloat(t);
  2377.                             } else {
  2378.                                 if (isa && anum) {
  2379.                                     if (1 / timerContext._percentage <= 1 && anum < 0) {
  2380.                                         return;
  2381.                                     }
  2382.                                     result = 1 / (1 / timerContext._percentage + anum);
  2383.                                 } else {
  2384.                                     if (cnum <= 0) {
  2385.                                         cnum = 1 / -cnum
  2386.                                     }
  2387.                                     result = 1 / ((1 / timerContext._percentage) * cnum);
  2388.                                 }
  2389.                             }
  2390.                             timer.change(result);
  2391.                         };
  2392.                         global.changeTime = timer.changeTime;
  2393.                     },
  2394.                     applyHooking: function () {
  2395.                         var _this = this;
  2396.                         // 劫持循环计时器
  2397.                         eHookContext.hookReplace(window, 'setInterval', function (setInterval) {
  2398.                             return _this.getHookedTimerFunction('interval', setInterval);
  2399.                         });
  2400.                         // 劫持单次计时
  2401.                         eHookContext.hookReplace(window, 'setTimeout', function (setTimeout) {
  2402.                             return _this.getHookedTimerFunction('timeout', setTimeout)
  2403.                         });
  2404.                         // 劫持循环计时器的清除方法
  2405.                         eHookContext.hookBefore(window, 'clearInterval', function (method, args) {
  2406.                             _this.redirectNewestId(args);
  2407.                         });
  2408.                         // 劫持循环计时器的清除方法
  2409.                         eHookContext.hookBefore(window, 'clearTimeout', function (method, args) {
  2410.                             _this.redirectNewestId(args);
  2411.                         });
  2412.                         var newFunc = this.getHookedDateConstructor();
  2413.                         eHookContext.hookClass(window, 'Date', newFunc, '_innerDate', ['now']);
  2414.                         Date.now = function () {
  2415.                             // window.performance.now
  2416.                             return new Date().getTime();
  2417.                         };
  2418.                         eHookContext.hookedToString(timerContext._Date.now, Date.now);
  2419.                         var objToString = Object.prototype.toString;
  2420.     
  2421.                         Object.prototype.toString = function toString() {
  2422.                             'use strict';
  2423.                             if (this instanceof timerContext._mDate) {
  2424.                                 return '[object Date]';
  2425.                             } else {
  2426.                                 return objToString.call(this);
  2427.                             }
  2428.                         };
  2429.     
  2430.                         eHookContext.hookedToString(objToString, Object.prototype.toString);
  2431.                         eHookContext.hookedToString(timerContext._setInterval, setInterval);
  2432.                         eHookContext.hookedToString(timerContext._setTimeout, setTimeout);
  2433.                         eHookContext.hookedToString(timerContext._clearInterval, clearInterval);
  2434.                         timerContext._mDate = window.Date;
  2435.                         this.hookShadowRoot();
  2436.                     },
  2437.                     getHookedDateConstructor: function () {
  2438.                         return function () {
  2439.                             if (arguments.length === 1) {
  2440.                                 Object.defineProperty(this, '_innerDate', {
  2441.                                     configurable: false,
  2442.                                     enumerable: false,
  2443.                                     value: new timerContext._Date(arguments[0]),
  2444.                                     writable: false
  2445.                                 });
  2446.                                 return;
  2447.                             } else if (arguments.length > 1) {
  2448.                                 var definedValue;
  2449.                                 switch (arguments.length) {
  2450.                                     case 2:
  2451.                                         definedValue = new timerContext._Date(
  2452.                                             arguments[0],
  2453.                                             arguments[1]
  2454.                                         );
  2455.                                         break;
  2456.                                     case 3:
  2457.                                         definedValue = new timerContext._Date(
  2458.                                             arguments[0],
  2459.                                             arguments[1],
  2460.                                             arguments[2],
  2461.                                         );
  2462.                                         break;
  2463.                                     case 4:
  2464.                                         definedValue = new timerContext._Date(
  2465.                                             arguments[0],
  2466.                                             arguments[1],
  2467.                                             arguments[2],
  2468.                                             arguments[3],
  2469.                                         );
  2470.                                         break;
  2471.                                     case 5:
  2472.                                         definedValue = new timerContext._Date(
  2473.                                             arguments[0],
  2474.                                             arguments[1],
  2475.                                             arguments[2],
  2476.                                             arguments[3],
  2477.                                             arguments[4]
  2478.                                         );
  2479.                                         break;
  2480.                                     case 6:
  2481.                                         definedValue = new timerContext._Date(
  2482.                                             arguments[0],
  2483.                                             arguments[1],
  2484.                                             arguments[2],
  2485.                                             arguments[3],
  2486.                                             arguments[4],
  2487.                                             arguments[5]
  2488.                                         );
  2489.                                         break;
  2490.                                     default:
  2491.                                     case 7:
  2492.                                         definedValue = new timerContext._Date(
  2493.                                             arguments[0],
  2494.                                             arguments[1],
  2495.                                             arguments[2],
  2496.                                             arguments[3],
  2497.                                             arguments[4],
  2498.                                             arguments[5],
  2499.                                             arguments[6]
  2500.                                         );
  2501.                                         break;
  2502.                                 }
  2503.     
  2504.                                 Object.defineProperty(this, '_innerDate', {
  2505.                                     configurable: false,
  2506.                                     enumerable: false,
  2507.                                     value: definedValue,
  2508.                                     writable: false
  2509.                                 });
  2510.                                 return;
  2511.                             }
  2512.                             var now = timerContext._Date.now();
  2513.                             var passTime = now - timerContext.__lastDatetime;
  2514.                             var hookPassTime = passTime * (1 / timerContext._percentage);
  2515.                             // console.log(__this.__lastDatetime + hookPassTime, now,__this.__lastDatetime + hookPassTime - now);
  2516.                             Object.defineProperty(this, '_innerDate', {
  2517.                                 configurable: false,
  2518.                                 enumerable: false,
  2519.                                 value: new timerContext._Date(timerContext.__lastMDatetime + hookPassTime),
  2520.                                 writable: false
  2521.                             });
  2522.                         };
  2523.                     },
  2524.                     getHookedTimerFunction: function (type, timer) {
  2525.                         var property = '_' + type + 'Ids';
  2526.                         return function () {
  2527.                             var uniqueId = timerContext.genUniqueId();
  2528.                             var callback = arguments[0];
  2529.                             if (typeof callback === 'string') {
  2530.                                 callback += ';timer.notifyExec(' + uniqueId + ')';
  2531.                                 arguments[0] = callback;
  2532.                             }
  2533.                             if (typeof callback === 'function') {
  2534.                                 arguments[0] = function () {
  2535.                                     var returnValue = callback.apply(this, arguments);
  2536.                                     timerContext.notifyExec(uniqueId);
  2537.                                     return returnValue;
  2538.                                 }
  2539.                             }
  2540.                             // 储存原始时间间隔
  2541.                             var originMS = arguments[1];
  2542.                             // 获取变速时间间隔
  2543.                             arguments[1] *= timerContext._percentage;
  2544.                             var resultId = timer.apply(window, arguments);
  2545.                             // 保存每次使用计时器得到的id以及参数等
  2546.                             timerContext[property][resultId] = {
  2547.                                 args: arguments,
  2548.                                 originMS: originMS,
  2549.                                 originId: resultId,
  2550.                                 nowId: resultId,
  2551.                                 uniqueId: uniqueId,
  2552.                                 oldPercentage: timerContext._percentage,
  2553.                                 exceptNextFireTime: timerContext._Date.now() + originMS
  2554.                             };
  2555.                             return resultId;
  2556.                         };
  2557.                     },
  2558.                     redirectNewestId: function (args) {
  2559.                         var id = args[0];
  2560.                         if (timerContext._intervalIds[id]) {
  2561.                             args[0] = timerContext._intervalIds[id].nowId;
  2562.                             // 清除该记录id
  2563.                             delete timerContext._intervalIds[id];
  2564.                         }
  2565.                         if (timerContext._timeoutIds[id]) {
  2566.                             args[0] = timerContext._timeoutIds[id].nowId;
  2567.                             // 清除该记录id
  2568.                             delete timerContext._timeoutIds[id];
  2569.                         }
  2570.                     },
  2571.                     registerShortcutKeys: function (timer) {
  2572.                         // 快捷键注册(不可用)
  2573.                         addEventListener('keydown', function (e) {
  2574.                             switch (e.keyCode) {
  2575.                                 case 57:
  2576.                                     if (e.ctrlKey || e.altKey) {
  2577.                                         // custom
  2578.                                         timer.changeTime();
  2579.                                     }
  2580.                                     break;
  2581.                                 // [=]
  2582.                                 case 190:
  2583.                                 case 187: {
  2584.                                     if (e.ctrlKey) {
  2585.                                         // console.log('+2');
  2586.                                         timer.changeTime(2, 0, true);
  2587.                                     } else if (e.altKey) {
  2588.                                         // console.log('xx2');
  2589.                                         timer.changeTime(0, 2);
  2590.                                     }
  2591.                                     break;
  2592.                                 }
  2593.                                 // [-]
  2594.                                 case 188:
  2595.                                 case 189: {
  2596.                                     if (e.ctrlKey) {
  2597.                                         // console.log('-2');
  2598.                                         timer.changeTime(-2, 0, true);
  2599.                                     } else if (e.altKey) {
  2600.                                         // console.log('xx-2');
  2601.                                         timer.changeTime(0, -2);
  2602.                                     }
  2603.                                     break;
  2604.                                 }
  2605.                                 // [0]
  2606.                                 case 48: {
  2607.                                     if (e.ctrlKey || e.altKey) {
  2608.                                         // console.log('reset');
  2609.                                         timer.changeTime(0, 0, false, true);
  2610.                                     }
  2611.                                     break;
  2612.                                 }
  2613.                                 default:
  2614.                                 // console.log(e);
  2615.                             }
  2616.                         });
  2617.                     },
  2618.                     /**
  2619.                      * 当计时器速率被改变时调用的回调方法
  2620.                      * @param percentage
  2621.                      * @private
  2622.                      */
  2623.                     percentageChangeHandler: function (percentage) {
  2624.                         // 改变所有的循环计时
  2625.                         util.ergodicObject(timerContext, timerContext._intervalIds, function (idObj, id) {
  2626.                             idObj.args[1] = Math.floor((idObj.originMS || 1) * percentage);
  2627.                             // 结束原来的计时器
  2628.                             this._clearInterval.call(window, idObj.nowId);
  2629.                             // 新开一个计时器
  2630.                             idObj.nowId = this._setInterval.apply(window, idObj.args);
  2631.                         });
  2632.                         // 改变所有的延时计时
  2633.                         util.ergodicObject(timerContext, timerContext._timeoutIds, function (idObj, id) {
  2634.                             var now = this._Date.now();
  2635.                             var exceptTime = idObj.exceptNextFireTime;
  2636.                             var oldPercentage = idObj.oldPercentage;
  2637.                             var time = exceptTime - now;
  2638.                             if (time < 0) {
  2639.                                 time = 0;
  2640.                             }
  2641.                             var changedTime = Math.floor(percentage / oldPercentage * time);
  2642.                             idObj.args[1] = changedTime;
  2643.                             // 重定下次执行时间
  2644.                             idObj.exceptNextFireTime = now + changedTime;
  2645.                             idObj.oldPercentage = percentage;
  2646.                             // 结束原来的计时器
  2647.                             this._clearTimeout.call(window, idObj.nowId);
  2648.                             // 新开一个计时器
  2649.                             idObj.nowId = this._setTimeout.apply(window, idObj.args);
  2650.                         });
  2651.                     },
  2652.                     hookShadowRoot: function () {
  2653.                         var origin = Element.prototype.attachShadow;
  2654.                         eHookContext.hookAfter(Element.prototype, 'attachShadow',
  2655.                             function (m, args, result) {
  2656.                                 extraElements.push(result);
  2657.                                 return result;
  2658.                             }, false);
  2659.                         eHookContext.hookedToString(origin, Element.prototype.attachShadow);
  2660.                     },
  2661.                     hookDefine: function () {
  2662.                         const _this = this;
  2663.                         eHookContext.hookBefore(Object, 'defineProperty', function (m, args) {
  2664.                             var option = args[2];
  2665.                             var ele = args[0];
  2666.                             var key = args[1];
  2667.                             var afterArgs = _this.hookDefineDetails(ele, key, option);
  2668.                             afterArgs.forEach((arg, i) => {
  2669.                                 args[i] = arg;
  2670.                             })
  2671.                         });
  2672.                         eHookContext.hookBefore(Object, 'defineProperties', function (m, args) {
  2673.                             var option = args[1];
  2674.                             var ele = args[0];
  2675.                             if (ele && ele instanceof Element) {
  2676.                                 Object.keys(option).forEach(key => {
  2677.                                     var o = option[key];
  2678.                                     var afterArgs = _this.hookDefineDetails(ele, key, o);
  2679.                                     args[0] = afterArgs[0];
  2680.                                     delete option[key];
  2681.                                     option[afterArgs[1]] = afterArgs[2]
  2682.                                 })
  2683.                             }
  2684.                         })
  2685.                     },
  2686.                     hookDefineDetails: function (target, key, option) {
  2687.                         if (option && target && target instanceof Element && typeof key === 'string' && key.indexOf('on') >= 0) {
  2688.                             option.configurable = true;
  2689.                         }
  2690.                         if (target instanceof HTMLVideoElement && key === 'playbackRate') {
  2691.                             option.configurable = true;
  2692.                             console.warn('[Timer Hook]', '已阻止默认操作视频倍率');
  2693.                             key = 'playbackRate_hooked'
  2694.                         }
  2695.                         return [target, key, option];
  2696.                     },
  2697.                     suppressEvent: function (ele, eventName) {
  2698.                         if (ele) {
  2699.                             delete ele['on' + eventName];
  2700.                             delete ele['on' + eventName];
  2701.                             delete ele['on' + eventName];
  2702.                             ele['on' + eventName] = undefined;
  2703.                         }
  2704.                         if (!suppressEvents[eventName]) {
  2705.                             eHookContext.hookBefore(EventTarget.prototype, 'addEventListener',
  2706.                                 function (m, args) {
  2707.                                     var eName = args[0];
  2708.                                     if (eventName === eName) {
  2709.                                         console.warn(eventName, 'event suppressed.')
  2710.                                         args[0] += 'suppressed';
  2711.                                     }
  2712.                                 }, false);
  2713.                             suppressEvents[eventName] = true;
  2714.                         }
  2715.                     },
  2716.                     changePlaybackRate: function (ele, rate) {
  2717.                         delete ele.playbackRate;
  2718.                         delete ele.playbackRate;
  2719.                         delete ele.playbackRate;
  2720.                         ele.playbackRate = rate
  2721.                         if (rate !== 1) {
  2722.                             timerContext.defineProperty.call(Object, ele, 'playbackRate', {
  2723.                                 configurable: true,
  2724.                                 get: function () {
  2725.                                     return 1;
  2726.                                 },
  2727.                                 set: function () {
  2728.                                 }
  2729.                             });
  2730.                         }
  2731.                     }
  2732.                 }
  2733.             };
  2734.     
  2735.             var normalUtil = {
  2736.                 isInIframe: function () {
  2737.                     let is = global.parent !== global;
  2738.                     try {
  2739.                         is = is && global.parent.document.body.tagName !== 'FRAMESET'
  2740.                     } catch (e) {
  2741.                         // ignore
  2742.                     }
  2743.                     return is;
  2744.                 },
  2745.                 listenParentEvent: function (handler) {
  2746.                     global.addEventListener('message', function (e) {
  2747.                         var data = e.data;
  2748.                         var type = data.type || '';
  2749.                         if (type === 'changePercentage') {
  2750.                             handler(data.percentage || 0);
  2751.                         }
  2752.                     })
  2753.                 },
  2754.                 sentChangesToIframe: function (percentage) {
  2755.                     var iframes = document.querySelectorAll('iframe') || [];
  2756.                     var frames = document.querySelectorAll('frame');
  2757.                     console.error(iframes)
  2758.                     console.error(frames)
  2759.                     if (iframes.length) {
  2760.                         for (var i = 0; i < iframes.length; i++) {
  2761.                             iframes[i].contentWindow.postMessage(
  2762.                                 { type: 'changePercentage', percentage: percentage }, '*');
  2763.                         }
  2764.                     }
  2765.                     if (frames.length) {
  2766.                         for (var j = 0; j < frames.length; j++) {
  2767.                             frames[j].contentwindow.postMessage(
  2768.                                 { type: 'changePercentage', percentage: percentage }, '*');
  2769.                         }
  2770.                     }
  2771.                 }
  2772.             };
  2773.     
  2774.             var querySelectorAll = function (ele, selector, includeExtra) {
  2775.                 var elements = ele.querySelectorAll(selector);
  2776.                 elements = Array.prototype.slice.call(elements || []);
  2777.                 if (includeExtra) {
  2778.                     extraElements.forEach(function (element) {
  2779.                         elements = elements.concat(querySelectorAll(element, selector, false));
  2780.                     })
  2781.                 }
  2782.                 return elements;
  2783.             };
  2784.     
  2785.             var generate = function () {
  2786.                 return function (util) {
  2787.                     // disable worker
  2788.                     workerURLs.forEach(function (url) {
  2789.                         if (util.urlMatching(location.href, 'http.*://.*' + url + '.*')) {
  2790.                             window['Worker'] = undefined;
  2791.                             alert('Worker disabled');
  2792.                         }
  2793.                     });
  2794.                     var eHookContext = this;
  2795.                     var timerHooker = {
  2796.                         // 用于储存计时器的id和参数
  2797.                         _intervalIds: {},
  2798.                         _timeoutIds: {},
  2799.                         _auoUniqueId: 1,
  2800.                         // 计时器速率
  2801.                         __percentage: 1.0,
  2802.                         // 劫持前的原始的方法
  2803.                         _setInterval: window['setInterval'],
  2804.                         _clearInterval: window['clearInterval'],
  2805.                         _clearTimeout: window['clearTimeout'],
  2806.                         _setTimeout: window['setTimeout'],
  2807.                         _Date: window['Date'],
  2808.                         __lastDatetime: new Date().getTime(),
  2809.                         __lastMDatetime: new Date().getTime(),
  2810.                         videoSpeedInterval: 1000,
  2811.                         defineProperty: Object.defineProperty,
  2812.                         defineProperties: Object.defineProperties,
  2813.                         genUniqueId: function () {
  2814.                             return this._auoUniqueId++;
  2815.                         },
  2816.                         notifyExec: function (uniqueId) {
  2817.                             var _this = this;
  2818.                             if (uniqueId) {
  2819.                                 // 清除 timeout 所储存的记录
  2820.                                 var timeoutInfos = Object.values(this._timeoutIds).filter(
  2821.                                     function (info) {
  2822.                                         return info.uniqueId === uniqueId;
  2823.                                     }
  2824.                                 );
  2825.                                 timeoutInfos.forEach(function (info) {
  2826.                                     _this._clearTimeout.call(window, info.nowId);
  2827.                                     delete _this._timeoutIds[info.originId]
  2828.                                 })
  2829.                             }
  2830.                             // console.log(uniqueId, 'called')
  2831.                         },
  2832.                         /**
  2833.                          * 初始化方法
  2834.                          */
  2835.                         init: function () {
  2836.                             var timerContext = this;
  2837.                             var h = helper(eHookContext, timerContext, util);
  2838.     
  2839.                             h.hookDefine();
  2840.                             h.applyHooking();
  2841.     
  2842.                             // 设定百分比属性被修改的回调
  2843.                             Object.defineProperty(timerContext, '_percentage', {
  2844.                                 get: function () {
  2845.                                     return timerContext.__percentage;
  2846.                                 },
  2847.                                 set: function (percentage) {
  2848.                                     if (percentage === timerContext.__percentage) {
  2849.                                         return percentage;
  2850.                                     }
  2851.                                     h.percentageChangeHandler(percentage);
  2852.                                     timerContext.__percentage = percentage;
  2853.                                     return percentage;
  2854.                                 }
  2855.                             });
  2856.     
  2857.                             if (!normalUtil.isInIframe()) {
  2858.                                 console.log('[TimeHooker]', 'loading outer window...');
  2859.                                 h.applyUI();
  2860.                                 h.applyGlobalAction(timerContext);
  2861.                                 h.registerShortcutKeys(timerContext);
  2862.                             } else {
  2863.                                 console.log('[TimeHooker]', 'loading inner window...');
  2864.                                 normalUtil.listenParentEvent((function (percentage) {
  2865.                                     console.log('[TimeHooker]', 'Inner Changed', percentage)
  2866.                                     this.change(percentage);
  2867.                                 }).bind(this))
  2868.                             }
  2869.                         },
  2870.                         /**
  2871.                          * 调用该方法改变计时器速率
  2872.                          * @param percentage
  2873.                          */
  2874.                         change: function (percentage) {
  2875.                             this.__lastMDatetime = this._mDate.now();
  2876.                             this.__lastDatetime = this._Date.now();
  2877.                             this._percentage = percentage;
  2878.                             var oldNode = document.getElementsByClassName('_th-click-hover');
  2879.                             var oldNode1 = document.getElementsByClassName('_th_times');
  2880.                             var displayNum = (1 / this._percentage).toFixed(2);
  2881.                             (oldNode[0] || {}).innerHTML = 'x' + displayNum;
  2882.                             (oldNode1[0] || {}).innerHTML = 'x' + displayNum;
  2883.                             var a = document.getElementsByClassName('_th_cover-all-show-times')[0] || {};
  2884.                             a.className = '_th_cover-all-show-times';
  2885.                             this._setTimeout.bind(window)(function () {
  2886.                                 a.className = '_th_cover-all-show-times _th_hidden';
  2887.                             }, 2000);
  2888.                             // this.changeVideoSpeed();
  2889.                             normalUtil.sentChangesToIframe(percentage);
  2890.                         },
  2891.                         changeVideoSpeed: function () {
  2892.                             var timerContext = this;
  2893.                             var h = helper(eHookContext, timerContext, util);
  2894.                             var rate = 1 / this._percentage;
  2895.                             rate > 16 && (rate = 16);
  2896.                             rate < 0.065 && (rate = 0.065);
  2897.                             var videos = querySelectorAll(document, 'video', true) || [];
  2898.                             if (videos.length) {
  2899.                                 for (var i = 0; i < videos.length; i++) {
  2900.                                     h.changePlaybackRate(videos[i], rate);
  2901.                                 }
  2902.                             }
  2903.                         }
  2904.                     };
  2905.                     // 默认初始化
  2906.                     timerHooker.init();
  2907.                     return timerHooker;
  2908.                 }
  2909.             };
  2910.     
  2911.             if (global.eHook) {
  2912.                 global.eHook.plugins({
  2913.                     name: 'timer',
  2914.                     /**
  2915.                      * 插件装载
  2916.                      * @param util
  2917.                      */
  2918.                     mount: generate()
  2919.                 });
  2920.             }
  2921.         }(window);
  2922.         window.performance.now = Date.now;
  2923.     }
  2924.     // 设置延迟时间（毫秒）
  2925.     var delayMilliseconds = 5000; // 5秒
  2926.     // 使用setTimeout来延迟执行函数
  2927.     setTimeout(speedHook, delayMilliseconds);
  2928.  
  2929. })()

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址