@panpanzhao/component-ui 0.0.1

package/lib/utils/formula/evalutor.js

@@ -0,0 +1,1883 @@
+"use strict";
+
+exports.__esModule = true;
+exports.Evaluator = void 0;
+exports.createObject = createObject;
+var _moment = _interopRequireDefault(require("moment"));
+var _upperFirst = _interopRequireDefault(require("lodash/upperFirst"));
+var _padStart = _interopRequireDefault(require("lodash/padStart"));
+var _capitalize = _interopRequireDefault(require("lodash/capitalize"));
+var _escape = _interopRequireDefault(require("lodash/escape"));
+var _truncate = _interopRequireDefault(require("lodash/truncate"));
+var _uniqWith = _interopRequireDefault(require("lodash/uniqWith"));
+var _uniqBy = _interopRequireDefault(require("lodash/uniqBy"));
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var Evaluator = /*#__PURE__*/function () {
+  function Evaluator(context, options) {
+    if (options === void 0) {
+      options = {
+        defaultFilter: 'html'
+      };
+    }
+    this.options = options;
+    this.functions = {};
+    this.contextStack = [];
+    this.context = context;
+    this.contextStack.push(function (varname) {
+      return varname === '&' ? context : context === null || context === void 0 ? void 0 : context[varname];
+    });
+    this.filters = Object.assign(Object.assign(Object.assign({}, Evaluator.defaultFilters), this.filters), options === null || options === void 0 ? void 0 : options.filters);
+    this.functions = Object.assign(Object.assign(Object.assign({}, Evaluator.defaultFunctions), this.functions), options === null || options === void 0 ? void 0 : options.functions);
+  }
+  Evaluator.setDefaultFilters = function setDefaultFilters(filters) {
+    Evaluator.defaultFilters = Object.assign(Object.assign({}, Evaluator.defaultFilters), filters);
+  };
+  Evaluator.setDefaultFunctions = function setDefaultFunctions(funtions) {
+    Evaluator.defaultFunctions = Object.assign(Object.assign({}, Evaluator.defaultFunctions), funtions);
+  }
+  // 主入口
+  ;
+  var _proto = Evaluator.prototype;
+  _proto.evalute = function evalute(ast) {
+    if (ast && ast.type) {
+      var name = ast.type.replace(/(?:_|\-)(\w)/g, function (_, l) {
+        return l.toUpperCase();
+      });
+      var fn = this.functions[name] || this[name];
+      if (!fn) {
+        throw new Error(ast.type + " unkown.");
+      }
+      return fn.call(this, ast);
+    } else {
+      return ast;
+    }
+  };
+  _proto.document = function document(ast) {
+    var _this = this;
+    if (!ast.body.length) {
+      return undefined;
+    }
+    var isString = ast.body.length > 1;
+    var content = ast.body.map(function (item) {
+      var result = _this.evalute(item);
+      if (isString && result == null) {
+        // 不要出现 undefined, null 之类的文案
+        return '';
+      }
+      return result;
+    });
+    return content.length === 1 ? content[0] : content.join('');
+  };
+  _proto.filter = function filter(ast) {
+    var _this2 = this;
+    var input = this.evalute(ast.input);
+    var filters = ast.filters.concat();
+    var context = {
+      filter: undefined,
+      data: this.context,
+      restFilters: filters
+    };
+    while (filters.length) {
+      var filter = filters.shift();
+      var fn = this.filters[filter.name];
+      if (!fn) {
+        throw new Error("filter `" + filter.name + "` not exists.");
+      }
+      context.filter = filter;
+      input = fn.apply(context, [input].concat(filter.args.map(function (item) {
+        if ((item === null || item === void 0 ? void 0 : item.type) === 'mixed') {
+          return item.body.map(function (item) {
+            return typeof item === 'string' ? item : _this2.evalute(item);
+          }).join('');
+        } else if (item.type) {
+          return _this2.evalute(item);
+        }
+        return item;
+      })));
+    }
+    return input;
+  };
+  _proto.raw = function raw(ast) {
+    return ast.value;
+  };
+  _proto.script = function script(ast) {
+    var _a;
+    var defaultFilter = this.options.defaultFilter;
+    // 只给简单的变量取值用法自动补fitler
+    if (defaultFilter && ~['getter', 'variable'].indexOf((_a = ast.body) === null || _a === void 0 ? void 0 : _a.type)) {
+      ast.body = {
+        type: 'filter',
+        input: ast.body,
+        filters: [{
+          name: defaultFilter.replace(/^\s*\|\s*/, ''),
+          args: []
+        }]
+      };
+    }
+    return this.evalute(ast.body);
+  };
+  _proto.expressionList = function expressionList(ast) {
+    var _this3 = this;
+    return ast.body.reduce(function (prev, current) {
+      return _this3.evalute(current);
+    });
+  };
+  _proto.template = function template(ast) {
+    var _this4 = this;
+    return ast.body.map(function (arg) {
+      return _this4.evalute(arg);
+    }).join('');
+  };
+  _proto.templateRaw = function templateRaw(ast) {
+    return ast.value;
+  }
+  // 下标获取
+  ;
+  _proto.getter = function getter(ast) {
+    var _a;
+    var host = this.evalute(ast.host);
+    var key = this.evalute(ast.key);
+    if (typeof key === 'undefined' && ((_a = ast.key) === null || _a === void 0 ? void 0 : _a.type) === 'variable') {
+      key = ast.key.name;
+    }
+    return host === null || host === void 0 ? void 0 : host[key];
+  }
+  // 位操作如 +2 ~3 !
+  ;
+  _proto.unary = function unary(ast) {
+    var value = this.evalute(ast.value);
+    switch (ast.op) {
+      case '+':
+        return +value;
+      case '-':
+        return -value;
+      case '~':
+        return ~value;
+      case '!':
+        return !value;
+    }
+  };
+  _proto.formatNumber = function formatNumber(value, int) {
+    if (int === void 0) {
+      int = false;
+    }
+    var typeName = typeof value;
+    if (typeName === 'string') {
+      return (int ? parseInt(value, 10) : parseFloat(value)) || 0;
+    } else if (typeName === 'number' && int) {
+      return Math.round(value);
+    }
+    return value !== null && value !== void 0 ? value : 0;
+  };
+  _proto.power = function power(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    return Math.pow(this.formatNumber(left), this.formatNumber(right));
+  };
+  _proto.multiply = function multiply(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    return stripNumber(this.formatNumber(left) * this.formatNumber(right));
+  };
+  _proto.divide = function divide(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    return stripNumber(this.formatNumber(left) / this.formatNumber(right));
+  };
+  _proto.remainder = function remainder(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    return this.formatNumber(left) % this.formatNumber(right);
+  };
+  _proto.add = function add(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // 如果有一个不是数字就变成字符串拼接
+    if (isNaN(left) || isNaN(right)) {
+      return left + right;
+    }
+    return stripNumber(this.formatNumber(left) + this.formatNumber(right));
+  };
+  _proto.minus = function minus(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    return stripNumber(this.formatNumber(left) - this.formatNumber(right));
+  };
+  _proto.shift = function shift(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.formatNumber(this.evalute(ast.right), true);
+    if (ast.op === '<<') {
+      return left << right;
+    } else if (ast.op == '>>') {
+      return left >> right;
+    } else {
+      return left >>> right;
+    }
+  };
+  _proto.lt = function lt(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left < right;
+  };
+  _proto.gt = function gt(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left > right;
+  };
+  _proto.le = function le(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left <= right;
+  };
+  _proto.ge = function ge(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left >= right;
+  };
+  _proto.eq = function eq(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left == right;
+  };
+  _proto.ne = function ne(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left != right;
+  };
+  _proto.streq = function streq(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left === right;
+  };
+  _proto.strneq = function strneq(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    // todo 如果是日期的对比，这个地方可以优化一下。
+    return left !== right;
+  };
+  _proto.binary = function binary(ast) {
+    var left = this.evalute(ast.left);
+    var right = this.evalute(ast.right);
+    if (ast.op === '&') {
+      return left & right;
+    } else if (ast.op === '^') {
+      return left ^ right;
+    } else {
+      return left | right;
+    }
+  };
+  _proto.and = function and(ast) {
+    var left = this.evalute(ast.left);
+    return left && this.evalute(ast.right);
+  };
+  _proto.or = function or(ast) {
+    var left = this.evalute(ast.left);
+    return left || this.evalute(ast.right);
+  };
+  _proto.number = function number(ast) {
+    // todo 以后可以在这支持大数字。
+    return ast.value;
+  };
+  _proto.nsVariable = function nsVariable(ast) {
+    if (ast.namespace === 'window') {
+      this.contextStack.push(function (name) {
+        return name === '&' ? window : window[name];
+      });
+    } else if (ast.namespace === 'cookie') {
+      this.contextStack.push(function (name) {
+        return getCookie(name);
+      });
+    } else if (ast.namespace === 'ls' || ast.namespace === 'ss') {
+      var ns = ast.namespace;
+      this.contextStack.push(function (name) {
+        var raw = ns === 'ss' ? sessionStorage.getItem(name) : localStorage.getItem(name);
+        if (typeof raw === 'string') {
+          // 判断字符串是否一个纯数字字符串，如果是，则对比parse后的值和原值是否相同，
+          // 如果不同则返回原值，因为原值如果是一个很长的纯数字字符串，则 parse 后可能会丢失精度
+          if (/^\d+$/.test(raw)) {
+            var parsed = JSON.parse(raw);
+            return "" + parsed === raw ? parsed : raw;
+          }
+          return parseJson(raw, raw);
+        }
+        return undefined;
+      });
+    } else {
+      throw new Error('Unsupported namespace: ' + ast.namespace);
+    }
+    var result = this.evalute(ast.body);
+    this.contextStack.pop();
+    return result;
+  };
+  _proto.variable = function variable(ast) {
+    var contextGetter = this.contextStack[this.contextStack.length - 1];
+    return contextGetter(ast.name);
+  };
+  _proto.identifier = function identifier(ast) {
+    return ast.name;
+  };
+  _proto.array = function array(ast) {
+    var _this5 = this;
+    return ast.members.map(function (member) {
+      return _this5.evalute(member);
+    });
+  };
+  _proto.literal = function literal(ast) {
+    return ast.value;
+  };
+  _proto.string = function string(ast) {
+    return ast.value;
+  };
+  _proto.object = function object(ast) {
+    var _this6 = this;
+    var object = {};
+    ast.members.forEach(function (_ref) {
+      var key = _ref.key,
+        value = _ref.value;
+      object[_this6.evalute(key)] = _this6.evalute(value);
+    });
+    return object;
+  };
+  _proto.conditional = function conditional(ast) {
+    return this.evalute(ast.test) ? this.evalute(ast.consequent) : this.evalute(ast.alternate);
+  };
+  _proto.funcCall = function funcCall(ast) {
+    var _this7 = this;
+    var fnName = "fn" + ast.identifier;
+    var fn = this.functions[fnName] || this[fnName] || this.filters.hasOwnProperty(ast.identifier) && this.filters[ast.identifier];
+    if (!fn) {
+      throw new Error(ast.identifier + "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49");
+    }
+    var args = ast.args;
+    // 逻辑函数特殊处理，因为有时候有些运算是可以跳过的。
+    if (~['IF', 'AND', 'OR', 'XOR', 'IFS'].indexOf(ast.identifier)) {
+      args = args.map(function (a) {
+        return function () {
+          return _this7.evalute(a);
+        };
+      });
+    } else {
+      args = args.map(function (a) {
+        return _this7.evalute(a);
+      });
+    }
+    return fn.apply(this, args);
+  };
+  _proto.anonymousFunction = function anonymousFunction(ast) {
+    return ast;
+  };
+  _proto.callAnonymousFunction = function callAnonymousFunction(ast, args) {
+    var ctx = createObject(this.contextStack[this.contextStack.length - 1]('&') || {}, {});
+    ast.args.forEach(function (arg) {
+      if (arg.type !== 'variable') {
+        throw new Error('expected a variable as argument');
+      }
+      ctx[arg.name] = args.shift();
+    });
+    this.contextStack.push(function (varName) {
+      return varName === '&' ? ctx : ctx[varName];
+    });
+    var result = this.evalute(ast.return);
+    this.contextStack.pop();
+    return result;
+  }
+  /**
+   * 示例：IF(A, B, C)
+   *
+   * 如果满足条件A，则返回B，否则返回C，支持多层嵌套IF函数。
+   *
+   * 也可以用表达式如：A ? B : C
+   *
+   * @example IF(condition, consequent, alternate)
+   * @param {expression} condition - 条件表达式.
+   * @param {any} consequent 条件判断通过的返回结果
+   * @param {any} alternate 条件判断不通过的返回结果
+   * @namespace 逻辑函数
+   *
+   * @returns {any} 根据条件返回不同的结果
+   */;
+  _proto.fnIF = function fnIF(condition, trueValue, falseValue) {
+    return condition() ? trueValue() : falseValue();
+  }
+  /**
+   * 条件全部符合，返回 true，否则返回 false
+   *
+   * 示例：AND(语文成绩>80, 数学成绩>80)
+   *
+   * 语文成绩和数学成绩都大于 80，则返回 true，否则返回 false
+   *
+   * 也可以直接用表达式如：语文成绩>80 && 数学成绩>80
+   *
+   * @example AND(expression1, expression2, ...expressionN)
+   * @param {...expression} conditions - 条件表达式.
+   * @namespace 逻辑函数
+   *
+   * @returns {boolean}
+   */;
+  _proto.fnAND = function fnAND() {
+    for (var _len = arguments.length, condtions = new Array(_len), _key = 0; _key < _len; _key++) {
+      condtions[_key] = arguments[_key];
+    }
+    return condtions.every(function (c) {
+      return c();
+    });
+  }
+  /**
+   * 条件任意一个满足条件，返回 true，否则返回 false
+   *
+   * 示例：OR(语文成绩>80, 数学成绩>80)
+   *
+   * 语文成绩和数学成绩任意一个大于 80，则返回 true，否则返回 false
+   *
+   * 也可以直接用表达式如：语文成绩>80 || 数学成绩>80
+   *
+   * @example OR(expression1, expression2, ...expressionN)
+   * @param {...expression} conditions - 条件表达式.
+   * @namespace 逻辑函数
+   *
+   * @returns {boolean}
+   */;
+  _proto.fnOR = function fnOR() {
+    for (var _len2 = arguments.length, condtions = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      condtions[_key2] = arguments[_key2];
+    }
+    return condtions.some(function (c) {
+      return c();
+    });
+  }
+  /**
+   * 异或处理，多个表达式组中存在奇数个真时认为真。
+   *
+   * @example XOR(condition1, condition2)
+   * @param {expression} condition1 - 条件表达式1
+   * @param {expression} condition2 - 条件表达式2
+   * @namespace 逻辑函数
+   *
+   * @returns {boolean}
+   */;
+  _proto.fnXOR = function fnXOR() {
+    for (var _len3 = arguments.length, condtions = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      condtions[_key3] = arguments[_key3];
+    }
+    return !!(condtions.filter(function (c) {
+      return c();
+    }).length % 2);
+  }
+  /**
+   * 判断函数集合，相当于多个 else if 合并成一个。
+   *
+   * 示例：IFS(语文成绩 > 80, "优秀", 语文成绩 > 60, "良", "继续努力")
+   *
+   * 如果语文成绩大于 80，则返回优秀，否则判断大于 60 分，则返回良，否则返回继续努力。
+   *
+   * @example IFS(condition1, result1, condition2, result2,...conditionN, resultN)
+   * @param {...any} args - 条件，返回值集合
+   * @namespace 逻辑函数
+   * @returns {any} 第一个满足条件的结果，没有命中的返回 false。
+   */;
+  _proto.fnIFS = function fnIFS() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    if (args.length % 2) {
+      args.splice(args.length - 1, 0, function () {
+        return true;
+      });
+    }
+    while (args.length) {
+      var c = args.shift();
+      var v = args.shift();
+      if (c()) {
+        return v();
+      }
+    }
+    return;
+  }
+  /**
+   * 返回传入数字的绝对值
+   *
+   * @example ABS(num)
+   * @param {number} num - 数值
+   * @namespace 数学函数
+   *
+   * @returns {number} 传入数值的绝对值
+   */;
+  _proto.fnABS = function fnABS(a) {
+    a = this.formatNumber(a);
+    return Math.abs(a);
+  }
+  /**
+   * 获取最大值，如果只有一个参数且是数组，则计算这个数组内的值
+   *
+   * @example MAX(num1, num2, ...numN)
+   * @param {...number} num - 数值
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有传入值中最大的那个
+   */;
+  _proto.fnMAX = function fnMAX() {
+    var _this8 = this;
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
+    }
+    var arr = normalizeArgs(args);
+    return Math.max.apply(Math, arr.map(function (item) {
+      return _this8.formatNumber(item);
+    }));
+  }
+  /**
+   * 获取最小值，如果只有一个参数且是数组，则计算这个数组内的值
+   *
+   * @example MIN(num1, num2, ...numN)
+   * @param {...number} num - 数值
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有传入值中最小的那个
+   */;
+  _proto.fnMIN = function fnMIN() {
+    var _this9 = this;
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
+    }
+    var arr = normalizeArgs(args);
+    return Math.min.apply(Math, arr.map(function (item) {
+      return _this9.formatNumber(item);
+    }));
+  }
+  /**
+   * 求和，如果只有一个参数且是数组，则计算这个数组内的值
+   *
+   * @example SUM(num1, num2, ...numN)
+   * @param {...number} num - 数值
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有传入数值的总和
+   */;
+  _proto.fnSUM = function fnSUM() {
+    var _this10 = this;
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
+    }
+    var arr = normalizeArgs(args);
+    return arr.reduce(function (sum, a) {
+      return sum + _this10.formatNumber(a) || 0;
+    }, 0);
+  }
+  /**
+   * 将数值向下取整为最接近的整数
+   *
+   * @example INT(num)
+   * @param {number} num - 数值
+   * @namespace 数学函数
+   *
+   * @returns {number} 数值对应的整形
+   */;
+  _proto.fnINT = function fnINT(n) {
+    return Math.floor(this.formatNumber(n));
+  }
+  /**
+   * 返回两数相除的余数，参数 number 是被除数，divisor 是除数
+   *
+   * @example MOD(num, divisor)
+   * @param {number} num - 被除数
+   * @param {number} divisor - 除数
+   * @namespace 数学函数
+   *
+   * @returns {number} 两数相除的余数
+   */;
+  _proto.fnMOD = function fnMOD(a, b) {
+    return this.formatNumber(a) % this.formatNumber(b);
+  }
+  /**
+   * 圆周率 3.1415...
+   *
+   * @example PI()
+   * @namespace 数学函数
+   *
+   * @returns {number} 圆周率数值
+   */;
+  _proto.fnPI = function fnPI() {
+    return Math.PI;
+  }
+  /**
+   * 将数字四舍五入到指定的位数，可以设置小数位。
+   *
+   * @example ROUND(num[, numDigits = 2])
+   * @param {number} num - 要处理的数字
+   * @param {number} numDigits - 小数位数
+   * @namespace 数学函数
+   *
+   * @returns {number} 传入数值四舍五入后的结果
+   */;
+  _proto.fnROUND = function fnROUND(a, b) {
+    if (b === void 0) {
+      b = 2;
+    }
+    a = this.formatNumber(a);
+    b = this.formatNumber(b);
+    var bResult = Math.round(b);
+    if (bResult) {
+      var c = Math.pow(10, bResult);
+      return Math.round(a * c) / c;
+    }
+    return Math.round(a);
+  }
+  /**
+   * 将数字向下取整到指定的位数，可以设置小数位。
+   *
+   * @example FLOOR(num[, numDigits=2])
+   * @param {number} num - 要处理的数字
+   * @param {number} numDigits - 小数位数
+   * @namespace 数学函数
+   *
+   * @returns {number} 传入数值向下取整后的结果
+   */;
+  _proto.fnFLOOR = function fnFLOOR(a, b) {
+    if (b === void 0) {
+      b = 2;
+    }
+    a = this.formatNumber(a);
+    b = this.formatNumber(b);
+    var bResult = Math.round(b);
+    if (bResult) {
+      var c = Math.pow(10, bResult);
+      return Math.floor(a * c) / c;
+    }
+    return Math.floor(a);
+  }
+  /**
+   * 将数字向上取整到指定的位数，可以设置小数位。
+   *
+   * @example CEIL(num[, numDigits=2])
+   * @param {number} num - 要处理的数字
+   * @param {number} numDigits - 小数位数
+   * @namespace 数学函数
+   *
+   * @returns {number} 传入数值向上取整后的结果
+   */;
+  _proto.fnCEIL = function fnCEIL(a, b) {
+    if (b === void 0) {
+      b = 2;
+    }
+    a = this.formatNumber(a);
+    b = this.formatNumber(b);
+    var bResult = Math.round(b);
+    if (bResult) {
+      var c = Math.pow(10, bResult);
+      return Math.ceil(a * c) / c;
+    }
+    return Math.ceil(a);
+  }
+  /**
+   * 开平方，参数 number 为非负数
+   *
+   * @example SQRT(num)
+   * @param {number} num - 要处理的数字
+   * @namespace 数学函数
+   *
+   * @returns {number} 开平方的结果
+   */;
+  _proto.fnSQRT = function fnSQRT(n) {
+    return Math.sqrt(this.formatNumber(n));
+  }
+  /**
+   * 返回所有参数的平均值，如果只有一个参数且是数组，则计算这个数组内的值
+   *
+   * @example AVG(num1, num2, ...numN)
+   * @param {...number} num - 要处理的数字
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有数值的平均值
+   */;
+  _proto.fnAVG = function fnAVG() {
+    var _this11 = this;
+    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+      args[_key8] = arguments[_key8];
+    }
+    var arr = normalizeArgs(args);
+    return this.fnSUM.apply(this, arr.map(function (item) {
+      return _this11.formatNumber(item);
+    })) / arr.length;
+  }
+  /**
+   * 返回数据点与数据均值点之差（数据偏差）的平方和，如果只有一个参数且是数组，则计算这个数组内的值
+   *
+   * @example DEVSQ(num1, num2, ...numN)
+   * @param {...number} num - 要处理的数字
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有数值的平均值
+   */;
+  _proto.fnDEVSQ = function fnDEVSQ() {
+    var _this12 = this;
+    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+      args[_key9] = arguments[_key9];
+    }
+    if (args.length === 0) {
+      return null;
+    }
+    var arr = normalizeArgs(args);
+    var nums = arr.map(function (item) {
+      return _this12.formatNumber(item);
+    });
+    var sum = nums.reduce(function (sum, a) {
+      return sum + a || 0;
+    }, 0);
+    var mean = sum / nums.length;
+    var result = 0;
+    for (var _iterator = _createForOfIteratorHelperLoose(nums), _step; !(_step = _iterator()).done;) {
+      var num = _step.value;
+      result += Math.pow(num - mean, 2);
+    }
+    return result;
+  }
+  /**
+   * 数据点到其算术平均值的绝对偏差的平均值
+   *
+   * @example AVEDEV(num1, num2, ...numN)
+   * @param {...number} num - 要处理的数字
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有数值的平均值
+   */;
+  _proto.fnAVEDEV = function fnAVEDEV() {
+    var _this13 = this;
+    for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+      args[_key10] = arguments[_key10];
+    }
+    if (args.length === 0) {
+      return null;
+    }
+    var arr = args;
+    if (args.length === 1 && Array.isArray(args[0])) {
+      arr = args[0];
+    }
+    var nums = arr.map(function (item) {
+      return _this13.formatNumber(item);
+    });
+    var sum = nums.reduce(function (sum, a) {
+      return sum + a || 0;
+    }, 0);
+    var mean = sum / nums.length;
+    var result = 0;
+    for (var _iterator2 = _createForOfIteratorHelperLoose(nums), _step2; !(_step2 = _iterator2()).done;) {
+      var num = _step2.value;
+      result += Math.abs(num - mean);
+    }
+    return result / nums.length;
+  }
+  /**
+   * 数据点的调和平均值，如果只有一个参数且是数组，则计算这个数组内的值
+   *
+   * @example HARMEAN(num1, num2, ...numN)
+   * @param {...number} num - 要处理的数字
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有数值的平均值
+   */;
+  _proto.fnHARMEAN = function fnHARMEAN() {
+    var _this14 = this;
+    for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+      args[_key11] = arguments[_key11];
+    }
+    if (args.length === 0) {
+      return null;
+    }
+    var arr = args;
+    if (args.length === 1 && Array.isArray(args[0])) {
+      arr = args[0];
+    }
+    var nums = arr.map(function (item) {
+      return _this14.formatNumber(item);
+    });
+    var den = 0;
+    for (var _iterator3 = _createForOfIteratorHelperLoose(nums), _step3; !(_step3 = _iterator3()).done;) {
+      var num = _step3.value;
+      den += 1 / num;
+    }
+    return nums.length / den;
+  }
+  /**
+   * 数据集中第 k 个最大值
+   *
+   * @example LARGE(array, k)
+   * @param {array} nums - 要处理的数字
+   * @param {number}  k - 第几大
+   * @namespace 数学函数
+   *
+   * @returns {number} 所有数值的平均值
+   */;
+  _proto.fnLARGE = function fnLARGE(nums, k) {
+    var _this15 = this;
+    if (nums.length === 0) {
+      return null;
+    }
+    var numsFormat = nums.map(function (item) {
+      return _this15.formatNumber(item);
+    });
+    if (k < 0 || numsFormat.length < k) {
+      return null;
+    }
+    return numsFormat.sort(function (a, b) {
+      return b - a;
+    })[k - 1];
+  }
+  /**
+   * 将数值转为中文大写金额
+   *
+   * @example UPPERMONEY(num)
+   * @param {number} num - 要处理的数字
+   * @namespace 数学函数
+   *
+   * @returns {string} 数值中文大写字符
+   */;
+  _proto.fnUPPERMONEY = function fnUPPERMONEY(n) {
+    var _a;
+    n = this.formatNumber(n);
+    var maxLen = 14;
+    if (((_a = n.toString().split('.')[0]) === null || _a === void 0 ? void 0 : _a.length) > maxLen) {
+      return "\u6700\u5927\u6570\u989D\u53EA\u652F\u6301\u5230\u5146(\u65E2\u5C0F\u6570\u70B9\u524D" + maxLen + "\u4F4D)";
+    }
+    var fraction = ['角', '分'];
+    var digit = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
+    var unit = [['元', '万', '亿', '兆'], ['', '拾', '佰', '仟']];
+    var head = n < 0 ? '欠' : '';
+    n = Math.abs(n);
+    var s = '';
+    for (var i = 0; i < fraction.length; i++) {
+      s += (digit[Math.floor(n * 10 * Math.pow(10, i)) % 10] + fraction[i]).replace(/零./, '');
+    }
+    s = s || '整';
+    n = Math.floor(n);
+    for (var _i = 0; _i < unit[0].length && n > 0; _i++) {
+      var p = '';
+      for (var j = 0; j < unit[1].length && n > 0; j++) {
+        p = digit[n % 10] + unit[1][j] + p;
+        n = Math.floor(n / 10);
+      }
+      s = p.replace(/(零.)*零$/, '').replace(/^$/, '零') + unit[0][_i] + s;
+    }
+    return head + s.replace(/(零.)*零元/, '元').replace(/(零.)+/g, '零').replace(/^整$/, '零元整');
+  }
+  /**
+   * 返回大于等于 0 且小于 1 的均匀分布随机实数。每一次触发计算都会变化。
+   *
+   * 示例：`RAND()*100`
+   *
+   * 返回 0-100 之间的随机数
+   *
+   * @example RAND()
+   * @namespace 数学函数
+   *
+   * @returns {number} 随机数
+   */;
+  _proto.fnRAND = function fnRAND() {
+    return Math.random();
+  }
+  /**
+   * 取数据最后一个
+   *
+   * @example LAST(array)
+   * @param {...number} arr - 要处理的数组
+   * @namespace 数学函数
+   *
+   * @returns {any} 最后一个值
+   */;
+  _proto.fnLAST = function fnLAST(arr) {
+    return arr.length ? arr[arr.length - 1] : null;
+  }
+  // 文本函数
+  ;
+  _proto.normalizeText = function normalizeText(raw) {
+    if (raw instanceof Date) {
+      return (0, _moment.default)(raw).format();
+    }
+    return "" + raw;
+  }
+  /**
+   * 返回传入文本左侧的指定长度字符串。
+   *
+   * @example LEFT(text, len)
+   * @param {string} text - 要处理的文本
+   * @param {number} len - 要处理的长度
+   * @namespace 文本函数
+   *
+   * @returns {string} 对应字符串
+   */;
+  _proto.fnLEFT = function fnLEFT(text, len) {
+    text = this.normalizeText(text);
+    return text.substring(0, len);
+  }
+  /**
+   * 返回传入文本右侧的指定长度字符串。
+   *
+   * @example RIGHT(text, len)
+   * @param {string} text - 要处理的文本
+   * @param {number} len - 要处理的长度
+   * @namespace 文本函数
+   *
+   * @returns {string} 对应字符串
+   */;
+  _proto.fnRIGHT = function fnRIGHT(text, len) {
+    text = this.normalizeText(text);
+    return text.substring(text.length - len, text.length);
+  }
+  /**
+   * 计算文本的长度
+   *
+   * @example LEN(text)
+   * @param {string} text - 要处理的文本
+   * @namespace 文本函数
+   *
+   * @returns {number} 长度
+   */;
+  _proto.fnLEN = function fnLEN(text) {
+    text = this.normalizeText(text);
+    return text === null || text === void 0 ? void 0 : text.length;
+  }
+  /**
+   * 计算文本集合中所有文本的长度
+   *
+   * @example LENGTH(textArr)
+   * @param {string[]} textArr - 要处理的文本集合
+   * @namespace 文本函数
+   *
+   * @returns {number[]} 长度集合
+   */;
+  _proto.fnLENGTH = function fnLENGTH() {
+    for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+      args[_key12] = arguments[_key12];
+    }
+    return this.fnLEN.call(this, args);
+  }
+  /**
+   * 判断文本是否为空
+   *
+   * @example ISEMPTY(text)
+   * @param {string} text - 要处理的文本
+   * @namespace 文本函数
+   *
+   * @returns {boolean} 判断结果
+   */;
+  _proto.fnISEMPTY = function fnISEMPTY(text) {
+    return !text || !String(text).trim();
+  }
+  /**
+   * 将多个传入值连接成文本
+   *
+   * @example CONCATENATE(text1, text2, ...textN)
+   * @param {...string} text - 文本集合
+   * @namespace 文本函数
+   *
+   * @returns {string} 连接后的文本
+   */;
+  _proto.fnCONCATENATE = function fnCONCATENATE() {
+    for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+      args[_key13] = arguments[_key13];
+    }
+    return args.join('');
+  }
+  /**
+   * 返回计算机字符集的数字代码所对应的字符。
+   *
+   * `CHAR(97)` 等价于 "a"
+   *
+   * @example CHAR(code)
+   * @param {number} code - 编码值
+   * @namespace 文本函数
+   *
+   * @returns {string} 指定位置的字符
+   */;
+  _proto.fnCHAR = function fnCHAR(code) {
+    return String.fromCharCode(code);
+  }
+  /**
+   * 将传入文本转成小写
+   *
+   * @example LOWER(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 结果文本
+   */;
+  _proto.fnLOWER = function fnLOWER(text) {
+    text = this.normalizeText(text);
+    return text.toLowerCase();
+  }
+  /**
+   * 将传入文本转成大写
+   *
+   * @example UPPER(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 结果文本
+   */;
+  _proto.fnUPPER = function fnUPPER(text) {
+    text = this.normalizeText(text);
+    return text.toUpperCase();
+  }
+  /**
+   * 将传入文本首字母转成大写
+   *
+   * @example UPPERFIRST(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 结果文本
+   */;
+  _proto.fnUPPERFIRST = function fnUPPERFIRST(text) {
+    text = this.normalizeText(text);
+    return (0, _upperFirst.default)(text);
+  }
+  /**
+   * 向前补齐文本长度
+   *
+   * 示例 `PADSTART("6", 2, "0")`
+   *
+   * 返回 `06`
+   *
+   * @example PADSTART(text)
+   * @param {string} text - 文本
+   * @param {number} num - 目标长度
+   * @param {string} pad - 用于补齐的文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 结果文本
+   */;
+  _proto.fnPADSTART = function fnPADSTART(text, num, pad) {
+    text = this.normalizeText(text);
+    return (0, _padStart.default)(text, num, pad);
+  }
+  /**
+   * 将文本转成标题
+   *
+   * 示例 `CAPITALIZE("star")`
+   *
+   * 返回 `Star`
+   *
+   * @example CAPITALIZE(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 结果文本
+   */;
+  _proto.fnCAPITALIZE = function fnCAPITALIZE(text) {
+    text = this.normalizeText(text);
+    return (0, _capitalize.default)(text);
+  }
+  /**
+   * 对文本进行 HTML 转义
+   *
+   * 示例 `ESCAPE("<star>&")`
+   *
+   * 返回 `&lt;start&gt;&amp;`
+   *
+   * @example ESCAPE(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 结果文本
+   */;
+  _proto.fnESCAPE = function fnESCAPE(text) {
+    text = this.normalizeText(text);
+    return (0, _escape.default)(text);
+  }
+  /**
+   * 对文本长度进行截断
+   *
+   * 示例 `TRUNCATE("amis.baidu.com", 6)`
+   *
+   * 返回 `amis...`
+   *
+   * @example TRUNCATE(text, 6)
+   * @param {string} text - 文本
+   * @param {number} text - 最长长度
+   * @namespace 文本函数
+   *
+   * @returns {string} 结果文本
+   */;
+  _proto.fnTRUNCATE = function fnTRUNCATE(text, length) {
+    text = this.normalizeText(text);
+    return (0, _truncate.default)(text, {
+      length: length
+    });
+  }
+  /**
+   *  取在某个分隔符之前的所有字符串
+   *
+   * @example  BEFORELAST(text, '.')
+   * @param {string} text - 文本
+   * @param {string} delimiter - 结束文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 判断结果
+   */;
+  _proto.fnBEFORELAST = function fnBEFORELAST(text, delimiter) {
+    if (delimiter === void 0) {
+      delimiter = '.';
+    }
+    text = this.normalizeText(text);
+    return text.split(delimiter).slice(0, -1).join(delimiter) || text + '';
+  }
+  /**
+   * 将文本根据指定片段分割成数组
+   *
+   * 示例：`SPLIT("a,b,c", ",")`
+   *
+   * 返回 `["a", "b", "c"]`
+   *
+   * @example SPLIT(text, ',')
+   * @param {string} text - 文本
+   * @param {string} delimiter - 文本片段
+   * @namespace 文本函数
+   *
+   * @returns {Array<string>} 文本集
+   */;
+  _proto.fnSPLIT = function fnSPLIT(text, sep) {
+    if (sep === void 0) {
+      sep = ',';
+    }
+    text = this.normalizeText(text);
+    return text.split(sep);
+  }
+  /**
+   * 将文本去除前后空格
+   *
+   * @example TRIM(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 处理后的文本
+   */;
+  _proto.fnTRIM = function fnTRIM(text) {
+    text = this.normalizeText(text);
+    return text.trim();
+  }
+  /**
+   * 去除文本中的 HTML 标签
+   *
+   * 示例：`STRIPTAG("<b>amis</b>")`
+   *
+   * 返回：`amis`
+   *
+   * @example STRIPTAG(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 处理后的文本
+   */;
+  _proto.fnSTRIPTAG = function fnSTRIPTAG(text) {
+    text = this.normalizeText(text);
+    return text.replace(/<\/?[^>]+(>|$)/g, '');
+  }
+  /**
+   * 将字符串中的换行转成 HTML `<br>`，用于简单换行的场景
+   *
+   * 示例：`LINEBREAK("\n")`
+   *
+   * 返回：`<br/>`
+   *
+   * @example LINEBREAK(text)
+   * @param {string} text - 文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 处理后的文本
+   */;
+  _proto.fnLINEBREAK = function fnLINEBREAK(text) {
+    text = this.normalizeText(text);
+    return text.replace(/(?:\r\n|\r|\n)/g, '<br/>');
+  }
+  /**
+   * 判断字符串(text)是否以特定字符串(startString)开始，是则返回 True，否则返回 False
+   *
+   * @example STARTSWITH(text, '片段')
+   * @param {string} text - 文本
+   * @param {string} startString - 起始文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 判断结果
+   */;
+  _proto.fnSTARTSWITH = function fnSTARTSWITH(text, search) {
+    if (!search) {
+      return false;
+    }
+    text = this.normalizeText(text);
+    return text.indexOf(search) === 0;
+  }
+  /**
+   * 判断字符串(text)是否以特定字符串(endString)结束，是则返回 True，否则返回 False
+   *
+   * @example ENDSWITH(text, '片段')
+   * @param {string} text - 文本
+   * @param {string} endString - 结束文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 判断结果
+   */;
+  _proto.fnENDSWITH = function fnENDSWITH(text, search) {
+    if (!search) {
+      return false;
+    }
+    text = this.normalizeText(text);
+    return text.indexOf(search, text.length - search.length) !== -1;
+  }
+  /**
+   * 判断参数 1 中的文本是否包含参数 2 中的文本。
+   *
+   * @example CONTAINS(text, searchText)
+   * @param {string} text - 文本
+   * @param {string} searchText - 搜索文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 判断结果
+   */;
+  _proto.fnCONTAINS = function fnCONTAINS(text, search) {
+    if (!search) {
+      return false;
+    }
+    text = this.normalizeText(text);
+    return !!~text.indexOf(search);
+  }
+  /**
+   * 对文本进行全量替换。
+   *
+   * @example REPLACE(text, search, replace)
+   * @param {string} text - 要处理的文本
+   * @param {string} search - 要被替换的文本
+   * @param {string} replace - 要替换的文本
+   * @namespace 文本函数
+   *
+   * @returns {string} 处理结果
+   */;
+  _proto.fnREPLACE = function fnREPLACE(text, search, replace) {
+    text = this.normalizeText(text);
+    var result = text;
+    while (true) {
+      var idx = result.indexOf(search);
+      if (!~idx) {
+        break;
+      }
+      result = result.substring(0, idx) + replace + result.substring(idx + search.length);
+    }
+    return result;
+  }
+  /**
+   * 对文本进行搜索，返回命中的位置
+   *
+   * @example SEARCH(text, search, 0)
+   * @param {string} text - 要处理的文本
+   * @param {string} search - 用来搜索的文本
+   * @param {number} start - 起始位置
+   * @namespace 文本函数
+   *
+   * @returns {number} 命中的位置
+   */;
+  _proto.fnSEARCH = function fnSEARCH(text, search, start) {
+    if (start === void 0) {
+      start = 0;
+    }
+    text = this.normalizeText(text);
+    start = this.formatNumber(start);
+    var idx = text.indexOf(search, start);
+    if (~idx) {
+      return idx;
+    }
+    return -1;
+  }
+  /**
+   * 返回文本字符串中从指定位置开始的特定数目的字符
+   *
+   * @example MID(text, from, len)
+   * @param {string} text - 要处理的文本
+   * @param {number} from - 起始位置
+   * @param {number} len - 处理长度
+   * @namespace 文本函数
+   *
+   * @returns {number} 命中的位置
+   */;
+  _proto.fnMID = function fnMID(text, from, len) {
+    text = this.normalizeText(text);
+    return text.substring(from, from + len);
+  }
+  /**
+   * 返回路径中的文件名
+   *
+   * 示例：`/home/amis/a.json`
+   *
+   * 返回：a.json`
+   *
+   * @example BASENAME(text)
+   * @param {string} text - 要处理的文本
+   * @namespace 文本函数
+   *
+   * @returns {string}  文件名
+   */;
+  _proto.fnBASENAME = function fnBASENAME(text) {
+    text = this.normalizeText(text);
+    return text.split(/[\\/]/).pop();
+  }
+  // 日期函数
+  /**
+   * 创建日期对象，可以通过特定格式的字符串，或者数值。
+   *
+   * 需要注意的是，其中月份的数值是从0开始的，也就是说，
+   * 如果是12月份，你应该传入数值11。
+   *
+   * @example DATE(2021, 11, 6, 8, 20, 0)
+   * @example DATE('2021-12-06 08:20:00')
+   * @namespace 日期函数
+   *
+   * @returns {Date} 日期对象
+   */;
+  _proto.fnDATE = function fnDATE(year, month, day, hour, minute, second) {
+    if (month === undefined) {
+      return new Date(year);
+    }
+    return new Date(year, month, day, hour, minute, second);
+  }
+  /**
+   * 返回时间的时间戳
+   *
+   * @example TIMESTAMP(date[, format = "X"])
+   * @example TIMESTAMP(date, 'x')
+   * @namespace 日期函数
+   * @param {date} date 日期对象
+   * @param {string} format 时间戳格式，带毫秒传入 'x'。默认为 'X' 不带毫秒的。
+   *
+   * @returns {number} 时间戳
+   */;
+  _proto.fnTIMESTAMP = function fnTIMESTAMP(date, format) {
+    return parseInt((0, _moment.default)(date).format(format === 'x' ? 'x' : 'X'), 10);
+  }
+  /**
+   * 返回今天的日期
+   *
+   * @example TODAY()
+   * @namespace 日期函数
+   *
+   * @returns {number} 日期
+   */;
+  _proto.fnTODAY = function fnTODAY() {
+    return new Date();
+  }
+  /**
+   * 返回现在的日期
+   *
+   * @example NOW()
+   * @namespace 日期函数
+   *
+   * @returns {number} 日期
+   */;
+  _proto.fnNOW = function fnNOW() {
+    return new Date();
+  }
+  /**
+   * 将日期转成日期字符串
+   *
+   * @example DATETOSTR(date[, format="YYYY-MM-DD HH:mm:ss"])
+   * @example DATETOSTR(date, 'YYYY-MM-DD')
+   * @namespace 日期函数
+   * @param {date} date 日期对象
+   * @param {string} format 日期格式，默认为 "YYYY-MM-DD HH:mm:ss"
+   *
+   * @returns {number} 日期字符串
+   */;
+  _proto.fnDATETOSTR = function fnDATETOSTR(date, format) {
+    if (format === void 0) {
+      format = 'YYYY-MM-DD HH:mm:ss';
+    }
+    return (0, _moment.default)(date).format(format);
+  }
+  /**
+   * 返回日期的指定范围的开端
+   *
+   * @namespace 日期函数
+   * @example STARTOF(date[unit = "day"])
+   * @param {date} date 日期对象
+   * @param {string} unit 比如可以传入 'day'、'month'、'year' 或者 `week` 等等
+   * @returns {date} 新的日期对象
+   */;
+  _proto.fnSTARTOF = function fnSTARTOF(date, unit) {
+    return (0, _moment.default)(date).startOf(unit || 'day').toDate();
+  }
+  /**
+   * 返回日期的指定范围的末尾
+   * @namespace 日期函数
+   * @example ENDOF(date[unit = "day"])
+   * @param {date} date 日期对象
+   * @param {string} unit 比如可以传入 'day'、'month'、'year' 或者 `week` 等等
+   * @returns {date} 新的日期对象
+   */;
+  _proto.fnENDOF = function fnENDOF(date, unit) {
+    return (0, _moment.default)(date).endOf(unit || 'day').toDate();
+  };
+  _proto.normalizeDate = function normalizeDate(raw) {
+    if (typeof raw === 'number' || !isNaN(raw)) {
+      return new Date(Number(raw));
+    }
+    if (typeof raw === 'string') {
+      var formats = ['', 'YYYY-MM-DD HH:mm:ss', 'X'];
+      while (formats.length) {
+        var format = formats.shift();
+        var date = (0, _moment.default)(raw, format);
+        if (date.isValid()) {
+          return date.toDate();
+        }
+      }
+    }
+    return raw;
+  }
+  /**
+   * 返回日期的年份
+   * @namespace 日期函数
+   * @example YEAR(date)
+   * @param {date} date 日期对象
+   * @returns {number} 数值
+   */;
+  _proto.fnYEAR = function fnYEAR(date) {
+    date = this.normalizeDate(date);
+    return date.getFullYear();
+  }
+  /**
+   * 返回日期的月份，这里就是自然月份。
+   *
+   * @namespace 日期函数
+   * @example MONTH(date)
+   * @param {date} date 日期对象
+   * @returns {number} 数值
+   */;
+  _proto.fnMONTH = function fnMONTH(date) {
+    date = this.normalizeDate(date);
+    return date.getMonth() + 1;
+  }
+  /**
+   * 返回日期的天
+   * @namespace 日期函数
+   * @example DAY(date)
+   * @param {date} date 日期对象
+   * @returns {number} 数值
+   */;
+  _proto.fnDAY = function fnDAY(date) {
+    date = this.normalizeDate(date);
+    return date.getDate();
+  }
+  /**
+   * 返回日期的小时
+   * @param {date} date 日期对象
+   * @namespace 日期函数
+   * @example HOUR(date)
+   * @returns {number} 数值
+   */;
+  _proto.fnHOUR = function fnHOUR(date) {
+    date = this.normalizeDate(date);
+    return date.getHours();
+  }
+  /**
+   * 返回日期的分
+   * @param {date} date 日期对象
+   * @namespace 日期函数
+   * @example MINUTE(date)
+   * @returns {number} 数值
+   */;
+  _proto.fnMINUTE = function fnMINUTE(date) {
+    date = this.normalizeDate(date);
+    return date.getMinutes();
+  }
+  /**
+   * 返回日期的秒
+   * @param {date} date 日期对象
+   * @namespace 日期函数
+   * @example SECOND(date)
+   * @returns {number} 数值
+   */;
+  _proto.fnSECOND = function fnSECOND(date) {
+    date = this.normalizeDate(date);
+    return date.getSeconds();
+  }
+  /**
+   * 返回两个日期相差多少年
+   * @param {date} endDate 日期对象
+   * @param {date} startDate 日期对象
+   * @namespace 日期函数
+   * @example YEARS(endDate, startDate)
+   * @returns {number} 数值
+   */;
+  _proto.fnYEARS = function fnYEARS(endDate, startDate) {
+    endDate = this.normalizeDate(endDate);
+    startDate = this.normalizeDate(startDate);
+    return (0, _moment.default)(endDate).diff((0, _moment.default)(startDate), 'year');
+  }
+  /**
+   * 返回两个日期相差多少分钟
+   * @param {date} endDate 日期对象
+   * @param {date} startDate 日期对象
+   * @namespace 日期函数
+   * @example MINUTES(endDate, startDate)
+   * @returns {number} 数值
+   */;
+  _proto.fnMINUTES = function fnMINUTES(endDate, startDate) {
+    endDate = this.normalizeDate(endDate);
+    startDate = this.normalizeDate(startDate);
+    return (0, _moment.default)(endDate).diff((0, _moment.default)(startDate), 'minutes');
+  }
+  /**
+   * 返回两个日期相差多少天
+   * @param {date} endDate 日期对象
+   * @param {date} startDate 日期对象
+   * @namespace 日期函数
+   * @example DAYS(endDate, startDate)
+   * @returns {number} 数值
+   */;
+  _proto.fnDAYS = function fnDAYS(endDate, startDate) {
+    endDate = this.normalizeDate(endDate);
+    startDate = this.normalizeDate(startDate);
+    return (0, _moment.default)(endDate).diff((0, _moment.default)(startDate), 'days');
+  }
+  /**
+   * 返回两个日期相差多少小时
+   * @param {date} endDate 日期对象
+   * @param {date} startDate 日期对象
+   * @namespace 日期函数
+   * @example HOURS(endDate, startDate)
+   * @returns {number} 数值
+   */;
+  _proto.fnHOURS = function fnHOURS(endDate, startDate) {
+    endDate = this.normalizeDate(endDate);
+    startDate = this.normalizeDate(startDate);
+    return (0, _moment.default)(endDate).diff((0, _moment.default)(startDate), 'hour');
+  }
+  /**
+   * 修改日期，对日期进行加减天、月份、年等操作
+   *
+   * 示例：
+   *
+   * DATEMODIFY(A, -2, 'month')
+   *
+   * 对日期 A 进行往前减2月的操作。
+   *
+   * @param {date} date 日期对象
+   * @param {number} num 数值
+   * @param {string} unit 单位：支持年、月、天等等
+   * @namespace 日期函数
+   * @example DATEMODIFY(date, 2, 'days')
+   * @returns {date} 日期对象
+   */;
+  _proto.fnDATEMODIFY = function fnDATEMODIFY(date, num, format) {
+    date = this.normalizeDate(date);
+    return (0, _moment.default)(date).add(num, format).toDate();
+  }
+  /**
+   * 将字符日期转成日期对象，可以指定日期格式。
+   *
+   * 示例：STRTODATE('2021/12/6', 'YYYY/MM/DD')
+   *
+   * @param {string} value 日期字符
+   * @param {string} format 日期格式
+   * @namespace 日期函数
+   * @example STRTODATE(value[, format=""])
+   * @returns {date} 日期对象
+   */;
+  _proto.fnSTRTODATE = function fnSTRTODATE(value, format) {
+    if (format === void 0) {
+      format = '';
+    }
+    return (0, _moment.default)(value, format).toDate();
+  }
+  /**
+   * 判断两个日期，是否第一个日期在第二个日期的前面
+   *
+   * @param {date} a 第一个日期
+   * @param {date} b 第二个日期
+   * @param {string} unit 单位，默认是 'day'， 即之比较到天
+   * @namespace 日期函数
+   * @example ISBEFORE(a, b)
+   * @returns {boolean} 判断结果
+   */;
+  _proto.fnISBEFORE = function fnISBEFORE(a, b, unit) {
+    if (unit === void 0) {
+      unit = 'day';
+    }
+    a = this.normalizeDate(a);
+    b = this.normalizeDate(b);
+    return (0, _moment.default)(a).isBefore((0, _moment.default)(b), unit);
+  }
+  /**
+   * 判断两个日期，是否第一个日期在第二个日期的后面
+   *
+   * @param {date} a 第一个日期
+   * @param {date} b 第二个日期
+   * @param {string} unit 单位，默认是 'day'， 即之比较到天
+   * @namespace 日期函数
+   * @example ISAFTER(a, b)
+   * @returns {boolean} 判断结果
+   */;
+  _proto.fnISAFTER = function fnISAFTER(a, b, unit) {
+    if (unit === void 0) {
+      unit = 'day';
+    }
+    a = this.normalizeDate(a);
+    b = this.normalizeDate(b);
+    return (0, _moment.default)(a).isAfter((0, _moment.default)(b), unit);
+  }
+  /**
+   * 判断两个日期，是否第一个日期在第二个日期的前面或者相等
+   *
+   * @param {date} a 第一个日期
+   * @param {date} b 第二个日期
+   * @param {string} unit 单位，默认是 'day'， 即之比较到天
+   * @namespace 日期函数
+   * @example ISSAMEORBEFORE(a, b)
+   * @returns {boolean} 判断结果
+   */;
+  _proto.fnISSAMEORBEFORE = function fnISSAMEORBEFORE(a, b, unit) {
+    if (unit === void 0) {
+      unit = 'day';
+    }
+    a = this.normalizeDate(a);
+    b = this.normalizeDate(b);
+    return (0, _moment.default)(a).isSameOrBefore((0, _moment.default)(b), unit);
+  }
+  /**
+   * 判断两个日期，是否第一个日期在第二个日期的后面或者相等
+   *
+   * @param {date} a 第一个日期
+   * @param {date} b 第二个日期
+   * @param {string} unit 单位，默认是 'day'， 即之比较到天
+   * @namespace 日期函数
+   * @example ISSAMEORAFTER(a, b)
+   * @returns {boolean} 判断结果
+   */;
+  _proto.fnISSAMEORAFTER = function fnISSAMEORAFTER(a, b, unit) {
+    if (unit === void 0) {
+      unit = 'day';
+    }
+    a = this.normalizeDate(a);
+    b = this.normalizeDate(b);
+    return (0, _moment.default)(a).isSameOrAfter((0, _moment.default)(b), unit);
+  }
+  /**
+   * 返回数组的长度
+   *
+   * @param {Array<any>} arr 数组
+   * @namespace 数组
+   * @example COUNT(arr)
+   * @returns {boolean} 结果
+   */;
+  _proto.fnCOUNT = function fnCOUNT(value) {
+    return Array.isArray(value) ? value.length : value ? 1 : 0;
+  }
+  /**
+   * 数组做数据转换，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。
+   *
+   * @param {Array<any>} arr 数组
+   * @param {Function<any>} iterator 箭头函数
+   * @namespace 数组
+   * @example ARRAYMAP(arr, item => item)
+   * @returns {boolean} 结果
+   */;
+  _proto.fnARRAYMAP = function fnARRAYMAP(value, iterator) {
+    var _this16 = this;
+    if (!iterator || iterator.type !== 'anonymous_function') {
+      throw new Error('expected an anonymous function get ' + iterator);
+    }
+    return (Array.isArray(value) ? value : []).map(function (item, index, arr) {
+      return _this16.callAnonymousFunction(iterator, [item, index, arr]);
+    });
+  }
+  /**
+   * 数据做数据过滤，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。
+   * 将第二个箭头函数返回为 false 的成员过滤掉。
+   *
+   * @param {Array<any>} arr 数组
+   * @param {Function<any>} iterator 箭头函数
+   * @namespace 数组
+   * @example ARRAYFILTER(arr, item => item)
+   * @returns {boolean} 结果
+   */;
+  _proto.fnARRAYFILTER = function fnARRAYFILTER(value, iterator) {
+    var _this17 = this;
+    if (!iterator || iterator.type !== 'anonymous_function') {
+      throw new Error('expected an anonymous function get ' + iterator);
+    }
+    return (Array.isArray(value) ? value : []).filter(function (item, index, arr) {
+      return _this17.callAnonymousFunction(iterator, [item, index, arr]);
+    });
+  }
+  /**
+   * 数组过滤掉 false、null、0 和 ""
+   *
+   * 示例：
+   *
+   * COMPACT([0, 1, false, 2, '', 3]) 得到 [1, 2, 3]
+   *
+   * @param {Array<any>} arr 数组
+   * @namespace 数组
+   * @example COMPACT(arr)
+   * @returns {Array<any>} 结果
+   */;
+  _proto.fnCOMPACT = function fnCOMPACT(arr) {
+    if (Array.isArray(arr)) {
+      var resIndex = 0;
+      var result = [];
+      for (var _iterator4 = _createForOfIteratorHelperLoose(arr), _step4; !(_step4 = _iterator4()).done;) {
+        var item = _step4.value;
+        if (item) {
+          result[resIndex++] = item;
+        }
+      }
+      return result;
+    } else {
+      return [];
+    }
+  }
+  /**
+   * 数组转成字符串
+   *
+   * 示例：
+   *
+   * JOIN(['a', 'b', 'c'], '=') 得到 'a=b=c'
+   *
+   * @param {Array<any>} arr 数组
+   * @param { String} separator 分隔符
+   * @namespace 数组
+   * @example JOIN(arr, string)
+   * @returns {String} 结果
+   */;
+  _proto.fnJOIN = function fnJOIN(arr, separator) {
+    if (separator === void 0) {
+      separator = '';
+    }
+    if (Array.isArray(arr)) {
+      return arr.join(separator);
+    } else {
+      return '';
+    }
+  }
+  /**
+   * 数组合并
+   *
+   * 示例：
+   *
+   * CONCAT(['a', 'b', 'c'], ['1'], ['3']) 得到 ['a', 'b', 'c', '1', '3']
+   *
+   * @param {Array<any>} arr 数组
+   * @namespace 数组
+   * @example CONCAT(['a', 'b', 'c'], ['1'], ['3'])
+   * @returns {Array<any>} 结果
+   */;
+  _proto.fnCONCAT = function fnCONCAT() {
+    for (var _len14 = arguments.length, arr = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+      arr[_key14] = arguments[_key14];
+    }
+    if ((arr === null || arr === void 0 ? void 0 : arr[0]) && !Array.isArray(arr[0])) {
+      arr[0] = [arr[0]];
+    }
+    return arr.reduce(function (a, b) {
+      return a.concat(b);
+    }, []).filter(function (item) {
+      return item;
+    });
+  }
+  /**
+   * 数组去重，第二个参数「field」，可指定根据该字段去重
+   *
+   * 示例：
+   *
+   * UNIQ([{a: '1'}, {b: '2'}, {a: '1'}]， 'id')
+   *
+   * @param {Array<any>} arr 数组
+   * @param {string} field 字段
+   * @namespace 数组
+   * @example UNIQ([{a: '1'}, {b: '2'}, {a: '1'}])
+   * @example UNIQ([{a: '1'}, {b: '2'}, {a: '1'}], 'x')
+   * @returns {Array<any>} 结果
+   */;
+  _proto.fnUNIQ = function fnUNIQ(arr, field) {
+    return field ? (0, _uniqBy.default)(arr, field) : (0, _uniqWith.default)(arr, _isEqual.default);
+  }
+  /**
+   * 判断是否为类型支持：string, number, array, date, plain-object。
+   *
+   * @param {string} 判断对象
+   * @namespace 其他
+   * @example ISTYPE([{a: '1'}, {b: '2'}, {a: '1'}], 'array')
+   * @returns {boolean} 结果结果
+   */;
+  _proto.fnISTYPE = function fnISTYPE(target, type) {
+    switch (type) {
+      case 'string':
+        return typeof target === 'string';
+      case 'number':
+        return typeof target === 'number';
+      case 'array':
+        return Array.isArray(target);
+      case 'date':
+        return !!(target && target instanceof Date);
+      case 'plain-object':
+        return (0, _isPlainObject.default)(target);
+      case 'nil':
+        return !target;
+    }
+    return false;
+  };
+  return Evaluator;
+}();
+exports.Evaluator = Evaluator;
+Evaluator.defaultFilters = {};
+Evaluator.defaultFunctions = {};
+function getCookie(name) {
+  var value = "; " + document.cookie;
+  var parts = value.split("; " + name + "=");
+  if (parts.length === 2) {
+    return parts.pop().split(';').shift();
+  }
+  return undefined;
+}
+function parseJson(str, defaultValue) {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+function stripNumber(number) {
+  if (typeof number === 'number' && !Number.isInteger(number)) {
+    return parseFloat(number.toPrecision(16));
+  } else {
+    return number;
+  }
+}
+// 如果只有一个成员，同时第一个成员为 args
+// 则把它展开，当成是多个参数，毕竟公式里面还不支持 ...args 语法，
+function normalizeArgs(args) {
+  if (args.length === 1 && Array.isArray(args[0])) {
+    args = args[0];
+  }
+  return args;
+}
+function createObject(superProps, props, properties) {
+  var obj = superProps ? Object.create(superProps, Object.assign(Object.assign({}, properties), {
+    __super: {
+      value: superProps,
+      writable: false,
+      enumerable: false
+    }
+  })) : Object.create(Object.prototype, properties);
+  props && Object.keys(props).forEach(function (key) {
+    return obj[key] = props[key];
+  });
+  return obj;
+}