@panpanzhao/component-ui 0.0.2 → 0.0.4

package/lib/components/formula.js

@@ -0,0 +1,2655 @@
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "/dist/";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 72);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = require("@vue/babel-helper-vue-jsx-merge-props");
+
+/***/ }),
+
+/***/ 21:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/input");
+
+/***/ }),
+
+/***/ 28:
+/***/ (function(module, exports) {
+
+module.exports = require("codemirror");
+
+/***/ }),
+
+/***/ 5:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/tabs");
+
+/***/ }),
+
+/***/ 58:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/tree");
+
+/***/ }),
+
+/***/ 59:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/badge");
+
+/***/ }),
+
+/***/ 6:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/tab-pane");
+
+/***/ }),
+
+/***/ 60:
+/***/ (function(module, exports) {
+
+module.exports = require("@panpanzhao/component-ui/lib/utils/helper");
+
+/***/ }),
+
+/***/ 61:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/message");
+
+/***/ }),
+
+/***/ 65:
+/***/ (function(module, exports) {
+
+module.exports = require("codemirror/mode/javascript/javascript");
+
+/***/ }),
+
+/***/ 66:
+/***/ (function(module, exports) {
+
+module.exports = require("codemirror/mode/htmlmixed/htmlmixed");
+
+/***/ }),
+
+/***/ 67:
+/***/ (function(module, exports) {
+
+module.exports = require("codemirror/addon/mode/simple");
+
+/***/ }),
+
+/***/ 68:
+/***/ (function(module, exports) {
+
+module.exports = require("codemirror/addon/mode/multiplex");
+
+/***/ }),
+
+/***/ 7:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/collapse");
+
+/***/ }),
+
+/***/ 72:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXTERNAL MODULE: external "@vue/babel-helper-vue-jsx-merge-props"
+var babel_helper_vue_jsx_merge_props_ = __webpack_require__(0);
+var babel_helper_vue_jsx_merge_props_default = /*#__PURE__*/__webpack_require__.n(babel_helper_vue_jsx_merge_props_);
+
+// EXTERNAL MODULE: external "codemirror"
+var external_codemirror_ = __webpack_require__(28);
+var external_codemirror_default = /*#__PURE__*/__webpack_require__.n(external_codemirror_);
+
+// EXTERNAL MODULE: external "codemirror/mode/javascript/javascript"
+var javascript_ = __webpack_require__(65);
+
+// EXTERNAL MODULE: external "codemirror/mode/htmlmixed/htmlmixed"
+var htmlmixed_ = __webpack_require__(66);
+
+// EXTERNAL MODULE: external "codemirror/addon/mode/simple"
+var simple_ = __webpack_require__(67);
+
+// EXTERNAL MODULE: external "codemirror/addon/mode/multiplex"
+var multiplex_ = __webpack_require__(68);
+
+// CONCATENATED MODULE: ./src/components/formula/src/codeMirror.js
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+
+
+
+
+/* harmony default export */ var codeMirror = ({
+  name: "CodeMirror",
+  inheritAttrs: false,
+  components: {},
+  props: {
+    className: String,
+    value: String,
+    options: Object,
+    editorFactory: Function,
+    editorDidMount: Function,
+    on: {
+      type: Object,
+      default: function _default() {
+        return {};
+      }
+    }
+  },
+  watch: {
+    value: function value(val) {
+      this.setValue(val);
+    }
+  },
+  data: function data() {
+    return {
+      editor: null,
+      unmounted: false
+    };
+  },
+  mounted: function mounted() {
+    var _this = this;
+    return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!_this.unmounted) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return");
+          case 2:
+            _this.editor = _this.editorFactory && _this.editorFactory(_this.$refs.codeMirrorRef, external_codemirror_default.a, _this.options) || external_codemirror_default()(_this.$refs.codeMirrorRef, {
+              value: _this.value || ''
+            });
+            _this.editorDidMount(external_codemirror_default.a, _this.editor);
+            _this.editor.on('change', _this.handleChange);
+            _this.editor.on('blur', _this.handleBlur);
+            _this.editor.on('focus', _this.handleFocus);
+            _this.$nextTick(function () {
+              _this.editor.refresh();
+            });
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  },
+  beforeDestroy: function beforeDestroy() {
+    this.unmounted = true;
+    this.editor.off('change', this.handleChange);
+    this.editor.off('blur', this.handleBlur);
+    this.editor.off('focus', this.handleFocus);
+  },
+  methods: {
+    setValue: function setValue(value) {
+      var doc = this.editor.getDoc();
+      if (value && value !== doc.getValue()) {
+        var cursor = doc.getCursor();
+        doc.setValue(value);
+        doc.setCursor(cursor);
+      }
+    },
+    handleChange: function handleChange(editor) {
+      this.$emit("change", editor.getValue());
+    },
+    handleBlur: function handleBlur(editor) {
+      this.$emit("blur", editor);
+    },
+    handleFocus: function handleFocus(editor) {
+      this.$emit("focus", editor);
+    }
+  },
+  render: function render(h) {
+    return h("div", {
+      "ref": "codeMirrorRef",
+      "class": ["formula-codeMirror", this.className]
+    });
+  }
+});
+// EXTERNAL MODULE: external "element-ui/lib/input"
+var input_ = __webpack_require__(21);
+var input_default = /*#__PURE__*/__webpack_require__.n(input_);
+
+// EXTERNAL MODULE: external "element-ui/lib/collapse"
+var collapse_ = __webpack_require__(7);
+var collapse_default = /*#__PURE__*/__webpack_require__.n(collapse_);
+
+// EXTERNAL MODULE: external "element-ui/lib/collapse-item"
+var collapse_item_ = __webpack_require__(8);
+var collapse_item_default = /*#__PURE__*/__webpack_require__.n(collapse_item_);
+
+// CONCATENATED MODULE: ./src/components/formula/src/funcList.js
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+
+
+/* harmony default export */ var funcList = ({
+  name: "FuncList",
+  componentName: "FuncList",
+  components: {
+    elInput: input_default.a,
+    elCollapse: collapse_default.a,
+    elCollapseItem: collapse_item_default.a
+  },
+  props: {
+    className: String,
+    data: Array
+  },
+  data: function data() {
+    return {
+      filteredFuncs: [],
+      activeFunc: null,
+      searchVal: null
+    };
+  },
+  created: function created() {
+    this.filteredFuncs = this.data || [];
+  },
+  methods: {
+    handleSearch: function handleSearch(val) {
+      this.searchVal = val;
+      var filtered = this.data.map(function (group) {
+        return _extends({}, group, {
+          items: val ? group.items.filter(function (item) {
+            return ~item.name.indexOf(val.toUpperCase());
+          }) : group.items
+        });
+      }).filter(function (group) {
+        return group.items.length;
+      });
+      console.log(filtered);
+      this.filteredFuncs = filtered;
+    },
+    setActiveFunc: function setActiveFunc(item) {
+      console.log(item);
+      this.activeFunc = item;
+    },
+    onSelect: function onSelect(item) {
+      this.$emit("select", item);
+    }
+  },
+  render: function render(h) {
+    var _this = this;
+    var Param = {
+      attrs: Object.assign({}, this.$attrs),
+      on: Object.assign({}, this.$listeners),
+      slots: this.$slots,
+      scopedSlots: this.$scopedSlots
+    };
+    return h("div", {
+      "class": ["FormulaEditor-FuncList", this.className]
+    }, [h("div", {
+      "class": "FormulaEditor-panel"
+    }, [h("div", {
+      "class": "FormulaEditor-panel-header"
+    }, ["\u51FD\u6570"]), h("div", {
+      "class": "FormulaEditor-panel-body"
+    }, [h("div", {
+      "class": "FormulaEditor-FuncList-searchBox"
+    }, [h("el-input", {
+      "attrs": {
+        "value": this.searchVal,
+        "prefix-icon": "el-icon-search",
+        "clearable": true
+      },
+      "on": {
+        "input": this.handleSearch
+      }
+    })]), h("div", {
+      "class": ["FormulaEditor-FuncList-body"]
+    }, [h("el-collapse", {
+      "attrs": {
+        "accordion": true
+      }
+    }, [this.filteredFuncs.map(function (group) {
+      return h("el-collapse-item", {
+        "attrs": {
+          "name": group.groupName,
+          "title": group.groupName
+        }
+      }, [group.items.map(function (item) {
+        return h("div", {
+          "class": ["FormulaEditor-FuncList-item", {
+            'is-active': item.name === (_this.activeFunc && _this.activeFunc.name)
+          }],
+          "on": {
+            "mouseenter": function mouseenter() {
+              return _this.setActiveFunc(item);
+            },
+            "click": function click() {
+              return _this.onSelect(item);
+            }
+          },
+          "key": item.name
+        }, [item.name]);
+      })]);
+    })])])])]), h("div", {
+      "class": "FormulaEditor-panel"
+    }, [h("div", {
+      "class": "FormulaEditor-panel-header"
+    }, [this.activeFunc && this.activeFunc.name || '']), h("div", {
+      "class": "FormulaEditor-panel-body"
+    }, [this.activeFunc ? h("div", {
+      "class": ["FormulaEditor-FuncList-doc"]
+    }, [h("pre", [h("code", [this.activeFunc.example])]), h("div", {
+      "class": "FormulaEditor-FuncList-doc-desc"
+    }, [this.activeFunc.description])]) : h("div")])])]);
+  }
+});
+// EXTERNAL MODULE: external "element-ui/lib/tabs"
+var tabs_ = __webpack_require__(5);
+var tabs_default = /*#__PURE__*/__webpack_require__.n(tabs_);
+
+// EXTERNAL MODULE: external "element-ui/lib/tab-pane"
+var tab_pane_ = __webpack_require__(6);
+var tab_pane_default = /*#__PURE__*/__webpack_require__.n(tab_pane_);
+
+// EXTERNAL MODULE: external "element-ui/lib/tree"
+var tree_ = __webpack_require__(58);
+var tree_default = /*#__PURE__*/__webpack_require__.n(tree_);
+
+// EXTERNAL MODULE: external "element-ui/lib/badge"
+var badge_ = __webpack_require__(59);
+var badge_default = /*#__PURE__*/__webpack_require__.n(badge_);
+
+// EXTERNAL MODULE: external "@panpanzhao/component-ui/lib/utils/helper"
+var helper_ = __webpack_require__(60);
+
+// CONCATENATED MODULE: ./src/components/formula/src/variableList.js
+
+
+
+
+
+
+
+
+/* harmony default export */ var variableList = ({
+  name: "VariableList",
+  componentName: "VariableList",
+  components: {
+    elInput: input_default.a,
+    elTabs: tabs_default.a,
+    elTabPane: tab_pane_default.a,
+    elTree: tree_default.a,
+    elBadge: badge_default.a
+  },
+  props: {
+    className: String,
+    itemClassName: String,
+    classPrefix: {
+      type: String,
+      default: "FormulaEditor-VariableList"
+    },
+    selectMode: String,
+    data: Array,
+    itemRender: Function,
+    selfVariableName: String
+  },
+  data: function data() {
+    return {
+      searchVal: null,
+      filterVars: []
+    };
+  },
+  created: function created() {
+    this.filterVars = this.data || [];
+  },
+  methods: {
+    handleSearch: function handleSearch(val) {
+      this.searchVal = val;
+      var filtered = Object(helper_["findTree"])(this.data, function (i) {
+        return ~i.label.indexOf(val);
+      });
+      this.filterVars = !val ? this.data : filtered ? [filtered] : [];
+    },
+    onSelect: function onSelect(item) {
+      this.$emit("select", item);
+    },
+    handleTree: function handleTree(data, node) {
+      this.onSelect(data);
+    },
+    renderSearchBox: function renderSearchBox(h) {
+      return h("div", {
+        "class": "FormulaEditor-VariableList-searchBox"
+      }, [h("el-input", {
+        "attrs": {
+          "value": this.searchVal,
+          "prefix-icon": "el-icon-search",
+          "clearable": true
+        },
+        "on": {
+          "input": this.handleSearch
+        }
+      })]);
+    },
+    renderItem: function renderItem(h, _ref) {
+      var node = _ref.node,
+        data = _ref.data,
+        store = _ref.store;
+      if (typeof this.itemRender === 'function') {
+        return this.itemRender.call(this, h, {
+          node: node,
+          data: data,
+          store: store
+        });
+      }
+      return h("span", {
+        "class": [this.classPrefix + "-item", this.itemClassName]
+      }, [data.label && this.selfVariableName && data.value === this.selfVariableName && h("el-badge", {
+        "attrs": {
+          "value": "self"
+        }
+      }, [h("label", [data.label])]), data.label && (!this.selfVariableName || data.value !== this.selfVariableName) && h("label", [data.label]), data.tag ? h("span", {
+        "class": this.classPrefix + "-item-tag"
+      }, [data.tag]) : null]);
+    },
+    renderTab: function renderTab(h) {
+      var _this = this;
+      return h("el-tabs", {
+        "class": [this.classPrefix + "-base " + this.classPrefix + "-tabs"]
+      }, [this.filterVars.map(function (item, index) {
+        return h("el-tab-pane", {
+          "class": _this.classPrefix + "-tab",
+          "key": index,
+          "attrs": {
+            "label": item.label
+          }
+        }, [h("VariableList", babel_helper_vue_jsx_merge_props_default()([{
+          "attrs": {
+            "classPrefix": _this.classPrefix + "-sub-",
+            "className": _this.classPrefix + "-sub",
+            "selectMode": item.selectMode,
+            "data": item.children,
+            "selfVariableName": _this.selfVariableName
+          }
+        }, {
+          "on": {
+            select: _this.onSelect
+          }
+        }]))]);
+      })]);
+    },
+    renderTree: function renderTree(h) {
+      return h("div", {
+        "class": "FormulaEditor-VariableList-body"
+      }, [this.renderSearchBox(h), h("el-tree", babel_helper_vue_jsx_merge_props_default()([{
+        "class": [this.classPrefix + "-base", "is-scrollable"],
+        "attrs": {
+          "expand-on-click-node": false,
+          "default-expand-all": true,
+          "data": this.filterVars,
+          "render-content": this.renderItem
+        }
+      }, {
+        "on": {
+          "node-click": this.handleTree
+        }
+      }]))]);
+    },
+    renderOption: function renderOption(h, _ref2) {
+      var _this2 = this;
+      var data = _ref2.data;
+      if (Array.isArray(data.children)) {
+        return h("div", {
+          "class": "GroupedSelection-group"
+        }, [h("div", {
+          "class": "GroupedSelection-itemLabel"
+        }, [this.renderItem(h, {
+          data: data
+        })]), h("div", {
+          "class": "GroupedSelection-items"
+        }, [data.children && data.children.map(function (child) {
+          return _this2.renderOption(h, {
+            data: child
+          });
+        })])]);
+      }
+      return h("div", {
+        "class": ["GroupedSelection-item"],
+        "on": {
+          "click": function click() {
+            return _this2.onSelect(data);
+          }
+        }
+      }, [h("div", {
+        "class": "GroupedSelection-itemLabel"
+      }, [this.renderItem(h, {
+        data: data
+      })])]);
+    },
+    renderContent: function renderContent(h) {
+      var _this3 = this;
+      if (this.selectMode === 'tree') {
+        return this.renderTree(h);
+      }
+      return h("div", {
+        "class": "FormulaEditor-VariableList-body"
+      }, [this.renderSearchBox(h), h("div", {
+        "class": ["GroupedSelection", this.classPrefix + "-base", 'is-scrollable']
+      }, [this.filterVars.map(function (item) {
+        return _this3.renderOption(h, {
+          data: item
+        });
+      })])]);
+    }
+  },
+  render: function render(h) {
+    return h("div", {
+      "class": ["FormulaEditor-VariableList", this.selectMode && "FormulaEditor-VariableList-" + this.selectMode, this.className]
+    }, [this.selectMode === 'tabs' ? this.renderTab(h) : this.renderContent(h)]);
+  }
+});
+// CONCATENATED MODULE: ./src/components/formula/src/plugin.js
+/**
+ * @file 扩展 codemirror
+ */
+
+/**
+ * 遍历树
+ * @param tree
+ * @param iterator
+ */
+function eachTree(tree, iterator, level, paths) {
+  if (level === void 0) {
+    level = 1;
+  }
+  if (paths === void 0) {
+    paths = [];
+  }
+  tree.map(function (item, index) {
+    var currentPath = paths.concat(item);
+    iterator(item, index, level, currentPath);
+    if (item.children && item.children.splice) {
+      eachTree(item.children, iterator, level + 1, currentPath);
+    }
+  });
+}
+function replaceStrByIndex(str, idx, key, replaceKey) {
+  var from = str.slice(0, idx);
+  var left = str.slice(idx);
+  return from + left.replace(key, replaceKey);
+}
+function getRegExpByMode(evalMode, key) {
+  var reg = evalMode ? "\\b" + key + "\\b" : "\\$\\{[^\\{\\}]*\\b" + key + "\\b[^\\{\\}]*\\}";
+  return new RegExp(reg);
+}
+function plugin_editorFactory(dom, cm, props) {
+  registerLaunguageMode(cm);
+  return cm(dom, {
+    value: props && props.value || '',
+    autofocus: true,
+    mode: props && props.evalMode ? 'text/formula' : 'text/formula-template'
+  });
+}
+var FormulaPlugin = /*#__PURE__*/function () {
+  function FormulaPlugin(editor, cm, getProps) {
+    this.editor = editor;
+    this.cm = cm;
+    this.getProps = getProps;
+    // editor.on('change', this.autoMarkText);
+    this.autoMarkText();
+  }
+  var _proto = FormulaPlugin.prototype;
+  _proto.autoMarkText = function autoMarkText() {
+    var _this$getProps = this.getProps(),
+      functions = _this$getProps.functions,
+      variables = _this$getProps.variables,
+      value = _this$getProps.value;
+    if (value) {
+      // todo functions 也需要自动替换
+      this.autoMark(variables);
+      this.focus(value);
+    }
+  }
+  // 计算 `${`、`}` 括号的位置，如 ${a}+${b}, 结果是 [ { from: 0, to: 3 }, { from: 5, to: 8 } ]
+  ;
+  _proto.computedBracesPosition = function computedBracesPosition(exp) {
+    var braces = [];
+    exp === null || exp === void 0 ? void 0 : exp.replace(/\$\{/g, function (val, offset) {
+      if (val) {
+        var charArr = exp.slice(offset + val.length).split('');
+        var cache = ['${'];
+        for (var index = 0; index < charArr.length; index++) {
+          var char = charArr[index];
+          if (char === '$' && charArr[index + 1] === '{') {
+            cache.push('${');
+          } else if (char === '}') {
+            cache.pop();
+          }
+          if (cache.length === 0) {
+            braces.push({
+              begin: offset + 2,
+              end: index + offset + 2
+            });
+            break;
+          }
+        }
+      }
+      return '';
+    });
+    return braces;
+  }
+  // 判断字符串是否在 ${} 中
+  ;
+  _proto.checkStrIsInBraces = function checkStrIsInBraces(_ref, braces) {
+    var from = _ref[0],
+      to = _ref[1];
+    var isIn = false;
+    if (braces.length) {
+      for (var index = 0; index < braces.length; index++) {
+        var brace = braces[index];
+        if (from >= brace.begin && to <= brace.end) {
+          isIn = true;
+          break;
+        }
+      }
+    }
+    return isIn;
+  };
+  _proto.insertBraces = function insertBraces(originFrom, originTo) {
+    var str = this.editor.getValue();
+    var braces = this.computedBracesPosition(str);
+    if (!this.checkStrIsInBraces([originFrom.ch, originTo.ch], braces)) {
+      this.editor.setCursor({
+        line: originFrom.line,
+        ch: originFrom.ch
+      });
+      this.editor.replaceSelection('${');
+      this.editor.setCursor({
+        line: originTo.line,
+        ch: originTo.ch + 2
+      });
+      this.editor.replaceSelection('}');
+    }
+  };
+  _proto.insertContent = function insertContent(value, type) {
+    var from = this.editor.getCursor();
+    var _this$getProps2 = this.getProps(),
+      evalMode = _this$getProps2.evalMode;
+    if (type === 'variable') {
+      this.editor.replaceSelection(value.key);
+      var to = this.editor.getCursor();
+      this.markText(from, to, value.name, 'cm-field');
+      !evalMode && this.insertBraces(from, to);
+    } else if (type === 'func') {
+      this.editor.replaceSelection(value + "()");
+      var _to = this.editor.getCursor();
+      this.markText(from, {
+        line: _to.line,
+        ch: _to.ch - 2
+      }, value, 'cm-func');
+      this.editor.setCursor({
+        line: _to.line,
+        ch: _to.ch - 1
+      });
+      if (!evalMode) {
+        this.insertBraces(from, _to);
+        this.editor.setCursor({
+          line: _to.line,
+          ch: _to.ch + 1
+        });
+      }
+    } else if (typeof value === 'string') {
+      this.editor.replaceSelection(value);
+    }
+    this.editor.focus();
+  };
+  _proto.markText = function markText(from, to, label, className) {
+    if (className === void 0) {
+      className = 'cm-func';
+    }
+    var text = document.createElement('span');
+    text.className = className;
+    text.innerText = label;
+    this.editor.markText(from, to, {
+      atomic: true,
+      replacedWith: text
+    });
+  };
+  _proto.autoMark = function autoMark(variables) {
+    var _this = this;
+    if (!Array.isArray(variables) || !variables.length) {
+      return;
+    }
+    var varMap = {};
+    eachTree(variables, function (item) {
+      if (item.value) {
+        varMap[item.value] = item.label;
+      }
+    });
+    var vars = Object.keys(varMap).sort(function (a, b) {
+      return b.length - a.length;
+    });
+    var editor = this.editor;
+    var lines = editor.lineCount();
+    var _this$getProps3 = this.getProps(),
+      _this$getProps3$evalM = _this$getProps3.evalMode,
+      evalMode = _this$getProps3$evalM === void 0 ? true : _this$getProps3$evalM;
+    var _loop = function _loop(line) {
+      var content = editor.getLine(line);
+      // 标记方法调用
+      content.replace(/([A-Z]+)\s*\(/g, function (_, func, pos) {
+        _this.markText({
+          line: line,
+          ch: pos
+        }, {
+          line: line,
+          ch: pos + func.length
+        }, func, 'cm-func');
+        return _;
+      });
+      var REPLACE_KEY = 'AMIS_FORMULA_REPLACE_KEY';
+      // 标记变量
+      vars.forEach(function (v) {
+        var from = 0;
+        var idx = -1;
+        while (~(idx = content.indexOf(v, from))) {
+          var encode = replaceStrByIndex(content, idx, v, REPLACE_KEY);
+          var reg = getRegExpByMode(evalMode, REPLACE_KEY);
+          if (reg.test(encode)) {
+            _this.markText({
+              line: line,
+              ch: idx
+            }, {
+              line: line,
+              ch: idx + v.length
+            }, varMap[v], 'cm-field');
+          }
+          from = idx + v.length;
+        }
+      });
+    };
+    for (var line = 0; line < lines; line++) {
+      _loop(line);
+    }
+  }
+  // 焦点放在最后
+  ;
+  _proto.focus = function focus(value) {
+    this.editor.setCursor({
+      line: 0,
+      ch: (value === null || value === void 0 ? void 0 : value.length) || 0
+    });
+  };
+  _proto.dispose = function dispose() {};
+  _proto.validate = function validate() {};
+  return FormulaPlugin;
+}();
+var modeRegisted = false;
+function registerLaunguageMode(cm) {
+  if (modeRegisted) {
+    return;
+  }
+  modeRegisted = true;
+  // 对应 evalMode
+  cm.defineMode('formula', function (config, parserConfig) {
+    var formula = cm.getMode(config, 'javascript');
+    if (!parserConfig || !parserConfig.base) return formula;
+    debugger;
+    return cm.multiplexingMode(cm.getMode(config, parserConfig.base), {
+      open: '${',
+      close: '}',
+      mode: formula
+    });
+  });
+  cm.defineMIME('text/formula', {
+    name: 'formula'
+  });
+  cm.defineMIME('text/formula-template', {
+    name: 'formula',
+    base: 'htmlmixed'
+  });
+}
+// CONCATENATED MODULE: ./src/utils/formula/doc.js
+/**
+ * 公式文档 请运行 `npm run genDoc` 自动生成
+ */
+/* harmony default export */ var doc = ([{
+  name: "IF",
+  description: "示例：IF(A, B, C)\n\n如果满足条件A，则返回B，否则返回C，支持多层嵌套IF函数。\n\n也可以用表达式如：A ? B : C",
+  example: "IF(condition, consequent, alternate)",
+  params: [{
+    type: "expression",
+    name: "condition",
+    description: "条件表达式."
+  }, {
+    type: "any",
+    name: "consequent",
+    description: "条件判断通过的返回结果"
+  }, {
+    type: "any",
+    name: "alternate",
+    description: "条件判断不通过的返回结果"
+  }],
+  returns: {
+    type: "any",
+    description: "根据条件返回不同的结果"
+  },
+  namespace: "逻辑函数"
+}, {
+  name: "AND",
+  description: "条件全部符合，返回 true，否则返回 false\n\n示例：AND(语文成绩>80, 数学成绩>80)\n\n语文成绩和数学成绩都大于 80，则返回 true，否则返回 false\n\n也可以直接用表达式如：语文成绩>80 && 数学成绩>80",
+  example: "AND(expression1, expression2, ...expressionN)",
+  params: [{
+    type: "...expression",
+    name: "conditions",
+    description: "条件表达式."
+  }],
+  returns: {
+    type: "boolean",
+    description: null
+  },
+  namespace: "逻辑函数"
+}, {
+  name: "OR",
+  description: "条件任意一个满足条件，返回 true，否则返回 false\n\n示例：OR(语文成绩>80, 数学成绩>80)\n\n语文成绩和数学成绩任意一个大于 80，则返回 true，否则返回 false\n\n也可以直接用表达式如：语文成绩>80 || 数学成绩>80",
+  example: "OR(expression1, expression2, ...expressionN)",
+  params: [{
+    type: "...expression",
+    name: "conditions",
+    description: "条件表达式."
+  }],
+  returns: {
+    type: "boolean",
+    description: null
+  },
+  namespace: "逻辑函数"
+}, {
+  name: "XOR",
+  description: "异或处理，多个表达式组中存在奇数个真时认为真。",
+  example: "XOR(condition1, condition2)",
+  params: [{
+    type: "expression",
+    name: "condition1",
+    description: "条件表达式1"
+  }, {
+    type: "expression",
+    name: "condition2",
+    description: "条件表达式2"
+  }],
+  returns: {
+    type: "boolean",
+    description: null
+  },
+  namespace: "逻辑函数"
+}, {
+  name: "IFS",
+  description: "判断函数集合，相当于多个 else if 合并成一个。\n\n示例：IFS(语文成绩 > 80, \"优秀\", 语文成绩 > 60, \"良\", \"继续努力\")\n\n如果语文成绩大于 80，则返回优秀，否则判断大于 60 分，则返回良，否则返回继续努力。",
+  example: "IFS(condition1, result1, condition2, result2,...conditionN, resultN)",
+  params: [{
+    type: "...any",
+    name: "args",
+    description: "条件，返回值集合"
+  }],
+  returns: {
+    type: "any",
+    description: "第一个满足条件的结果，没有命中的返回 false。"
+  },
+  namespace: "逻辑函数"
+}, {
+  name: "ABS",
+  description: "返回传入数字的绝对值",
+  example: "ABS(num)",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "数值"
+  }],
+  returns: {
+    type: "number",
+    description: "传入数值的绝对值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "MAX",
+  description: "获取最大值，如果只有一个参数且是数组，则计算这个数组内的值",
+  example: "MAX(num1, num2, ...numN)",
+  params: [{
+    type: "...number",
+    name: "num",
+    description: "数值"
+  }],
+  returns: {
+    type: "number",
+    description: "所有传入值中最大的那个"
+  },
+  namespace: "数学函数"
+}, {
+  name: "MIN",
+  description: "获取最小值，如果只有一个参数且是数组，则计算这个数组内的值",
+  example: "MIN(num1, num2, ...numN)",
+  params: [{
+    type: "...number",
+    name: "num",
+    description: "数值"
+  }],
+  returns: {
+    type: "number",
+    description: "所有传入值中最小的那个"
+  },
+  namespace: "数学函数"
+}, {
+  name: "SUM",
+  description: "求和，如果只有一个参数且是数组，则计算这个数组内的值",
+  example: "SUM(num1, num2, ...numN)",
+  params: [{
+    type: "...number",
+    name: "num",
+    description: "数值"
+  }],
+  returns: {
+    type: "number",
+    description: "所有传入数值的总和"
+  },
+  namespace: "数学函数"
+}, {
+  name: "INT",
+  description: "将数值向下取整为最接近的整数",
+  example: "INT(num)",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "数值"
+  }],
+  returns: {
+    type: "number",
+    description: "数值对应的整形"
+  },
+  namespace: "数学函数"
+}, {
+  name: "MOD",
+  description: "返回两数相除的余数，参数 number 是被除数，divisor 是除数",
+  example: "MOD(num, divisor)",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "被除数"
+  }, {
+    type: "number",
+    name: "divisor",
+    description: "除数"
+  }],
+  returns: {
+    type: "number",
+    description: "两数相除的余数"
+  },
+  namespace: "数学函数"
+}, {
+  name: "PI",
+  description: "圆周率 3.1415...",
+  example: "PI()",
+  params: [],
+  returns: {
+    type: "number",
+    description: "圆周率数值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "ROUND",
+  description: "将数字四舍五入到指定的位数，可以设置小数位。",
+  example: "ROUND(num[, numDigits = 2])",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "要处理的数字"
+  }, {
+    type: "number",
+    name: "numDigits",
+    description: "小数位数"
+  }],
+  returns: {
+    type: "number",
+    description: "传入数值四舍五入后的结果"
+  },
+  namespace: "数学函数"
+}, {
+  name: "FLOOR",
+  description: "将数字向下取整到指定的位数，可以设置小数位。",
+  example: "FLOOR(num[, numDigits=2])",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "要处理的数字"
+  }, {
+    type: "number",
+    name: "numDigits",
+    description: "小数位数"
+  }],
+  returns: {
+    type: "number",
+    description: "传入数值向下取整后的结果"
+  },
+  namespace: "数学函数"
+}, {
+  name: "CEIL",
+  description: "将数字向上取整到指定的位数，可以设置小数位。",
+  example: "CEIL(num[, numDigits=2])",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "要处理的数字"
+  }, {
+    type: "number",
+    name: "numDigits",
+    description: "小数位数"
+  }],
+  returns: {
+    type: "number",
+    description: "传入数值向上取整后的结果"
+  },
+  namespace: "数学函数"
+}, {
+  name: "SQRT",
+  description: "开平方，参数 number 为非负数",
+  example: "SQRT(num)",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "要处理的数字"
+  }],
+  returns: {
+    type: "number",
+    description: "开平方的结果"
+  },
+  namespace: "数学函数"
+}, {
+  name: "AVG",
+  description: "返回所有参数的平均值，如果只有一个参数且是数组，则计算这个数组内的值",
+  example: "AVG(num1, num2, ...numN)",
+  params: [{
+    type: "...number",
+    name: "num",
+    description: "要处理的数字"
+  }],
+  returns: {
+    type: "number",
+    description: "所有数值的平均值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "DEVSQ",
+  description: "返回数据点与数据均值点之差（数据偏差）的平方和，如果只有一个参数且是数组，则计算这个数组内的值",
+  example: "DEVSQ(num1, num2, ...numN)",
+  params: [{
+    type: "...number",
+    name: "num",
+    description: "要处理的数字"
+  }],
+  returns: {
+    type: "number",
+    description: "所有数值的平均值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "AVEDEV",
+  description: "数据点到其算术平均值的绝对偏差的平均值",
+  example: "AVEDEV(num1, num2, ...numN)",
+  params: [{
+    type: "...number",
+    name: "num",
+    description: "要处理的数字"
+  }],
+  returns: {
+    type: "number",
+    description: "所有数值的平均值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "HARMEAN",
+  description: "数据点的调和平均值，如果只有一个参数且是数组，则计算这个数组内的值",
+  example: "HARMEAN(num1, num2, ...numN)",
+  params: [{
+    type: "...number",
+    name: "num",
+    description: "要处理的数字"
+  }],
+  returns: {
+    type: "number",
+    description: "所有数值的平均值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "LARGE",
+  description: "数据集中第 k 个最大值",
+  example: "LARGE(array, k)",
+  params: [{
+    type: "array",
+    name: "nums",
+    description: "要处理的数字"
+  }, {
+    type: "number",
+    name: "k",
+    description: "第几大"
+  }],
+  returns: {
+    type: "number",
+    description: "所有数值的平均值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "UPPERMONEY",
+  description: "将数值转为中文大写金额",
+  example: "UPPERMONEY(num)",
+  params: [{
+    type: "number",
+    name: "num",
+    description: "要处理的数字"
+  }],
+  returns: {
+    type: "string",
+    description: "数值中文大写字符"
+  },
+  namespace: "数学函数"
+}, {
+  name: "RAND",
+  description: "返回大于等于 0 且小于 1 的均匀分布随机实数。每一次触发计算都会变化。\n\n示例：`RAND()*100`\n\n返回 0-100 之间的随机数",
+  example: "RAND()",
+  params: [],
+  returns: {
+    type: "number",
+    description: "随机数"
+  },
+  namespace: "数学函数"
+}, {
+  name: "LAST",
+  description: "取数据最后一个",
+  example: "LAST(array)",
+  params: [{
+    type: "...number",
+    name: "arr",
+    description: "要处理的数组"
+  }],
+  returns: {
+    type: "any",
+    description: "最后一个值"
+  },
+  namespace: "数学函数"
+}, {
+  name: "LEFT",
+  description: "返回传入文本左侧的指定长度字符串。",
+  example: "LEFT(text, len)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }, {
+    type: "number",
+    name: "len",
+    description: "要处理的长度"
+  }],
+  returns: {
+    type: "string",
+    description: "对应字符串"
+  },
+  namespace: "文本函数"
+}, {
+  name: "RIGHT",
+  description: "返回传入文本右侧的指定长度字符串。",
+  example: "RIGHT(text, len)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }, {
+    type: "number",
+    name: "len",
+    description: "要处理的长度"
+  }],
+  returns: {
+    type: "string",
+    description: "对应字符串"
+  },
+  namespace: "文本函数"
+}, {
+  name: "LEN",
+  description: "计算文本的长度",
+  example: "LEN(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }],
+  returns: {
+    type: "number",
+    description: "长度"
+  },
+  namespace: "文本函数"
+}, {
+  name: "LENGTH",
+  description: "计算文本集合中所有文本的长度",
+  example: "LENGTH(textArr)",
+  params: [{
+    type: "Array<string>",
+    name: "textArr",
+    description: "要处理的文本集合"
+  }],
+  returns: {
+    type: "Array<number>",
+    description: "长度集合"
+  },
+  namespace: "文本函数"
+}, {
+  name: "ISEMPTY",
+  description: "判断文本是否为空",
+  example: "ISEMPTY(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }],
+  returns: {
+    type: "boolean",
+    description: "判断结果"
+  },
+  namespace: "文本函数"
+}, {
+  name: "CONCATENATE",
+  description: "将多个传入值连接成文本",
+  example: "CONCATENATE(text1, text2, ...textN)",
+  params: [{
+    type: "...string",
+    name: "text",
+    description: "文本集合"
+  }],
+  returns: {
+    type: "string",
+    description: "连接后的文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "CHAR",
+  description: "返回计算机字符集的数字代码所对应的字符。\n\n`CHAR(97)` 等价于 \"a\"",
+  example: "CHAR(code)",
+  params: [{
+    type: "number",
+    name: "code",
+    description: "编码值"
+  }],
+  returns: {
+    type: "string",
+    description: "指定位置的字符"
+  },
+  namespace: "文本函数"
+}, {
+  name: "LOWER",
+  description: "将传入文本转成小写",
+  example: "LOWER(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "结果文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "UPPER",
+  description: "将传入文本转成大写",
+  example: "UPPER(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "结果文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "UPPERFIRST",
+  description: "将传入文本首字母转成大写",
+  example: "UPPERFIRST(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "结果文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "PADSTART",
+  description: "向前补齐文本长度\n\n示例 `PADSTART(\"6\", 2, \"0\")`\n\n返回 `06`",
+  example: "PADSTART(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }, {
+    type: "number",
+    name: "num",
+    description: "目标长度"
+  }, {
+    type: "string",
+    name: "pad",
+    description: "用于补齐的文本"
+  }],
+  returns: {
+    type: "string",
+    description: "结果文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "CAPITALIZE",
+  description: "将文本转成标题\n\n示例 `CAPITALIZE(\"star\")`\n\n返回 `Star`",
+  example: "CAPITALIZE(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "结果文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "ESCAPE",
+  description: "对文本进行 HTML 转义\n\n示例 `ESCAPE(\"<star>&\")`\n\n返回 `&lt;start&gt;&amp;`",
+  example: "ESCAPE(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "结果文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "TRUNCATE",
+  description: "对文本长度进行截断\n\n示例 `TRUNCATE(\"amis.baidu.com\", 6)`\n\n返回 `amis...`",
+  example: "TRUNCATE(text, 6)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }, {
+    type: "number",
+    name: "text",
+    description: "最长长度"
+  }],
+  returns: {
+    type: "string",
+    description: "结果文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "BEFORELAST",
+  description: "取在某个分隔符之前的所有字符串",
+  example: "BEFORELAST(text, '.')",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }, {
+    type: "string",
+    name: "delimiter",
+    description: "结束文本"
+  }],
+  returns: {
+    type: "string",
+    description: "判断结果"
+  },
+  namespace: "文本函数"
+}, {
+  name: "SPLIT",
+  description: "将文本根据指定片段分割成数组\n\n示例：`SPLIT(\"a,b,c\", \",\")`\n\n返回 `[\"a\", \"b\", \"c\"]`",
+  example: "SPLIT(text, ',')",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }, {
+    type: "string",
+    name: "delimiter",
+    description: "文本片段"
+  }],
+  returns: {
+    type: "Array<string>",
+    description: "文本集"
+  },
+  namespace: "文本函数"
+}, {
+  name: "TRIM",
+  description: "将文本去除前后空格",
+  example: "TRIM(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "处理后的文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "STRIPTAG",
+  description: "去除文本中的 HTML 标签\n\n示例：`STRIPTAG(\"<b>amis</b>\")`\n\n返回：`amis`",
+  example: "STRIPTAG(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "处理后的文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "LINEBREAK",
+  description: "将字符串中的换行转成 HTML `<br>`，用于简单换行的场景\n\n示例：`LINEBREAK(\"\\n\")`\n\n返回：`<br/>`",
+  example: "LINEBREAK(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }],
+  returns: {
+    type: "string",
+    description: "处理后的文本"
+  },
+  namespace: "文本函数"
+}, {
+  name: "STARTSWITH",
+  description: "判断字符串(text)是否以特定字符串(startString)开始，是则返回 True，否则返回 False",
+  example: "STARTSWITH(text, '片段')",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }, {
+    type: "string",
+    name: "startString",
+    description: "起始文本"
+  }],
+  returns: {
+    type: "string",
+    description: "判断结果"
+  },
+  namespace: "文本函数"
+}, {
+  name: "ENDSWITH",
+  description: "判断字符串(text)是否以特定字符串(endString)结束，是则返回 True，否则返回 False",
+  example: "ENDSWITH(text, '片段')",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }, {
+    type: "string",
+    name: "endString",
+    description: "结束文本"
+  }],
+  returns: {
+    type: "string",
+    description: "判断结果"
+  },
+  namespace: "文本函数"
+}, {
+  name: "CONTAINS",
+  description: "判断参数 1 中的文本是否包含参数 2 中的文本。",
+  example: "CONTAINS(text, searchText)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "文本"
+  }, {
+    type: "string",
+    name: "searchText",
+    description: "搜索文本"
+  }],
+  returns: {
+    type: "string",
+    description: "判断结果"
+  },
+  namespace: "文本函数"
+}, {
+  name: "REPLACE",
+  description: "对文本进行全量替换。",
+  example: "REPLACE(text, search, replace)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }, {
+    type: "string",
+    name: "search",
+    description: "要被替换的文本"
+  }, {
+    type: "string",
+    name: "replace",
+    description: "要替换的文本"
+  }],
+  returns: {
+    type: "string",
+    description: "处理结果"
+  },
+  namespace: "文本函数"
+}, {
+  name: "SEARCH",
+  description: "对文本进行搜索，返回命中的位置",
+  example: "SEARCH(text, search, 0)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }, {
+    type: "string",
+    name: "search",
+    description: "用来搜索的文本"
+  }, {
+    type: "number",
+    name: "start",
+    description: "起始位置"
+  }],
+  returns: {
+    type: "number",
+    description: "命中的位置"
+  },
+  namespace: "文本函数"
+}, {
+  name: "MID",
+  description: "返回文本字符串中从指定位置开始的特定数目的字符",
+  example: "MID(text, from, len)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }, {
+    type: "number",
+    name: "from",
+    description: "起始位置"
+  }, {
+    type: "number",
+    name: "len",
+    description: "处理长度"
+  }],
+  returns: {
+    type: "number",
+    description: "命中的位置"
+  },
+  namespace: "文本函数"
+}, {
+  name: "BASENAME",
+  description: "返回路径中的文件名\n\n示例：`/home/amis/a.json`\n\n返回：a.json`",
+  example: "BASENAME(text)",
+  params: [{
+    type: "string",
+    name: "text",
+    description: "要处理的文本"
+  }],
+  returns: {
+    type: "string",
+    description: "文件名"
+  },
+  namespace: "文本函数"
+}, {
+  name: "DATE",
+  description: "创建日期对象，可以通过特定格式的字符串，或者数值。\n\n需要注意的是，其中月份的数值是从0开始的，也就是说，\n如果是12月份，你应该传入数值11。",
+  example: "DATE('2021-12-06 08:20:00')",
+  params: [],
+  returns: {
+    type: "Date",
+    description: "日期对象"
+  },
+  namespace: "日期函数"
+}, {
+  name: "TIMESTAMP",
+  description: "返回时间的时间戳",
+  example: "TIMESTAMP(date, 'x')",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }, {
+    type: "string",
+    name: "format",
+    description: "时间戳格式，带毫秒传入 'x'。默认为 'X' 不带毫秒的。"
+  }],
+  returns: {
+    type: "number",
+    description: "时间戳"
+  },
+  namespace: "日期函数"
+}, {
+  name: "TODAY",
+  description: "返回今天的日期",
+  example: "TODAY()",
+  params: [],
+  returns: {
+    type: "number",
+    description: "日期"
+  },
+  namespace: "日期函数"
+}, {
+  name: "NOW",
+  description: "返回现在的日期",
+  example: "NOW()",
+  params: [],
+  returns: {
+    type: "number",
+    description: "日期"
+  },
+  namespace: "日期函数"
+}, {
+  name: "WEEKDAY",
+  description: "获取日期的星期几，\n\n示例：\n\nWEEKDAY('2023-02-27') 得到 1",
+  example: "WEEKDAY(date)",
+  params: [{
+    type: "any",
+    name: "date",
+    description: "日期"
+  }, {
+    type: "number",
+    name: "type",
+    description: "星期定义类型，默认为1，1表示0至6代表星期一到星期日，2表示1至7代表星期一到星期日"
+  }],
+  returns: {
+    type: "number",
+    description: "星期几的数字标识"
+  },
+  namespace: "日期函数"
+}, {
+  name: "WEEK",
+  description: "获取年份的星期，即第几周\n\n示例：\n\nWEEK('2023-03-05') 得到 10",
+  example: "WEEK(date)",
+  params: [{
+    type: "any",
+    name: "date",
+    description: "日期"
+  }, {
+    type: "boolean",
+    name: "isISO",
+    description: "是否ISO星期"
+  }],
+  returns: {
+    type: "number",
+    description: "星期几的数字标识"
+  },
+  namespace: "日期函数"
+}, {
+  name: "DATETOSTR",
+  description: "对日期、日期字符串、时间戳进行格式化\n\n示例：\n\nDATETOSTR('12/25/2022', 'YYYY-MM-DD') 得到 '2022.12.25'\nDATETOSTR(1676563200, 'YYYY.MM.DD') 得到 '2023.02.17'\nDATETOSTR(1676563200000, 'YYYY.MM.DD hh:mm:ss') 得到 '2023.02.17 12:00:00'\nDATETOSTR(DATE('2021-12-21'), 'YYYY.MM.DD hh:mm:ss') 得到 '2021.12.21 08:00:00'",
+  example: "DATETOSTR(date, 'YYYY-MM-DD')",
+  params: [{
+    type: "any",
+    name: "date",
+    description: "日期对象、日期字符串、时间戳"
+  }, {
+    type: "string",
+    name: "format",
+    description: "日期格式，默认为 \"YYYY-MM-DD HH:mm:ss\""
+  }],
+  returns: {
+    type: "string",
+    description: "日期字符串"
+  },
+  namespace: "日期函数"
+}, {
+  name: "DATERANGESPLIT",
+  description: "获取日期范围字符串中的开始时间、结束时间\n\n示例：\n\nDATERANGESPLIT('1676563200, 1676735999') 得到 [1676563200, 1676735999]\nDATERANGESPLIT('1676563200, 1676735999', undefined , 'YYYY.MM.DD hh:mm:ss') 得到 [2023.02.17 12:00:00, 2023.02.18 11:59:59]\nDATERANGESPLIT('1676563200, 1676735999', 0 , 'YYYY.MM.DD hh:mm:ss') 得到 '2023.02.17 12:00:00'\nDATERANGESPLIT('1676563200, 1676735999', 'start' , 'YYYY.MM.DD hh:mm:ss') 得到 '2023.02.17 12:00:00'\nDATERANGESPLIT('1676563200, 1676735999', 1 , 'YYYY.MM.DD hh:mm:ss') 得到 '2023.02.18 11:59:59'\nDATERANGESPLIT('1676563200, 1676735999', 'end' , 'YYYY.MM.DD hh:mm:ss') 得到 '2023.02.18 11:59:59'",
+  example: "DATERANGESPLIT(date, 'YYYY-MM-DD')",
+  params: [{
+    type: "string",
+    name: "date",
+    description: "日期范围字符串"
+  }, {
+    type: "string",
+    name: "key",
+    description: "取值标识，0或'start'表示获取开始时间，1或'end'表示获取结束时间"
+  }, {
+    type: "string",
+    name: "format",
+    description: "日期格式，可选"
+  }, {
+    type: "string",
+    name: "delimiter",
+    description: "分隔符，可选，默认为','"
+  }],
+  returns: {
+    type: "string",
+    description: "日期字符串"
+  },
+  namespace: "日期函数"
+}, {
+  name: "STARTOF",
+  description: "返回日期的指定范围的开端",
+  example: "STARTOF(date[unit = \"day\"])",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "比如可以传入 'day'、'month'、'year' 或者 `week` 等等"
+  }, {
+    type: "string",
+    name: "format",
+    description: "日期格式，可选"
+  }],
+  returns: {
+    type: "date",
+    description: "新的日期对象"
+  },
+  namespace: "日期函数"
+}, {
+  name: "ENDOF",
+  description: "返回日期的指定范围的末尾",
+  example: "ENDOF(date[unit = \"day\"])",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "比如可以传入 'day'、'month'、'year' 或者 `week` 等等"
+  }, {
+    type: "string",
+    name: "format",
+    description: "日期格式，可选"
+  }],
+  returns: {
+    type: "date",
+    description: "新的日期对象"
+  },
+  namespace: "日期函数"
+}, {
+  name: "YEAR",
+  description: "返回日期的年份",
+  example: "YEAR(date)",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "MONTH",
+  description: "返回日期的月份，这里就是自然月份。",
+  example: "MONTH(date)",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "DAY",
+  description: "返回日期的天",
+  example: "DAY(date)",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "HOUR",
+  description: "返回日期的小时",
+  example: "HOUR(date)",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "MINUTE",
+  description: "返回日期的分",
+  example: "MINUTE(date)",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "SECOND",
+  description: "返回日期的秒",
+  example: "SECOND(date)",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "YEARS",
+  description: "返回两个日期相差多少年",
+  example: "YEARS(endDate, startDate)",
+  params: [{
+    type: "date",
+    name: "endDate",
+    description: "日期对象"
+  }, {
+    type: "date",
+    name: "startDate",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "MINUTES",
+  description: "返回两个日期相差多少分钟",
+  example: "MINUTES(endDate, startDate)",
+  params: [{
+    type: "date",
+    name: "endDate",
+    description: "日期对象"
+  }, {
+    type: "date",
+    name: "startDate",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "DAYS",
+  description: "返回两个日期相差多少天",
+  example: "DAYS(endDate, startDate)",
+  params: [{
+    type: "date",
+    name: "endDate",
+    description: "日期对象"
+  }, {
+    type: "date",
+    name: "startDate",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "HOURS",
+  description: "返回两个日期相差多少小时",
+  example: "HOURS(endDate, startDate)",
+  params: [{
+    type: "date",
+    name: "endDate",
+    description: "日期对象"
+  }, {
+    type: "date",
+    name: "startDate",
+    description: "日期对象"
+  }],
+  returns: {
+    type: "number",
+    description: "数值"
+  },
+  namespace: "日期函数"
+}, {
+  name: "DATEMODIFY",
+  description: "修改日期，对日期进行加减天、月份、年等操作\n\n示例：\n\nDATEMODIFY(A, -2, 'month')\n\n对日期 A 进行往前减2月的操作。",
+  example: "DATEMODIFY(date, 2, 'days')",
+  params: [{
+    type: "date",
+    name: "date",
+    description: "日期对象"
+  }, {
+    type: "number",
+    name: "num",
+    description: "数值"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "单位：支持年、月、天等等"
+  }],
+  returns: {
+    type: "date",
+    description: "日期对象"
+  },
+  namespace: "日期函数"
+}, {
+  name: "STRTODATE",
+  description: "将字符日期转成日期对象，可以指定日期格式。\n\n示例：STRTODATE('2021/12/6', 'YYYY/MM/DD')",
+  example: "STRTODATE(value[, format=\"\"])",
+  params: [{
+    type: "string",
+    name: "value",
+    description: "日期字符"
+  }, {
+    type: "string",
+    name: "format",
+    description: "日期格式"
+  }],
+  returns: {
+    type: "date",
+    description: "日期对象"
+  },
+  namespace: "日期函数"
+}, {
+  name: "ISBEFORE",
+  description: "判断两个日期，是否第一个日期在第二个日期的前面",
+  example: "ISBEFORE(a, b)",
+  params: [{
+    type: "date",
+    name: "a",
+    description: "第一个日期"
+  }, {
+    type: "date",
+    name: "b",
+    description: "第二个日期"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "单位，默认是 'day'， 即之比较到天"
+  }],
+  returns: {
+    type: "boolean",
+    description: "判断结果"
+  },
+  namespace: "日期函数"
+}, {
+  name: "ISAFTER",
+  description: "判断两个日期，是否第一个日期在第二个日期的后面",
+  example: "ISAFTER(a, b)",
+  params: [{
+    type: "date",
+    name: "a",
+    description: "第一个日期"
+  }, {
+    type: "date",
+    name: "b",
+    description: "第二个日期"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "单位，默认是 'day'， 即之比较到天"
+  }],
+  returns: {
+    type: "boolean",
+    description: "判断结果"
+  },
+  namespace: "日期函数"
+}, {
+  name: "BETWEENRANGE",
+  description: "判断日期是否在指定范围内\n\n示例：BETWEENRANGE('2021/12/6', ['2021/12/5','2021/12/7'])",
+  example: "BETWEENRANGE(date, [start, end])",
+  params: [{
+    type: "any",
+    name: "date",
+    description: "第一个日期"
+  }, {
+    type: "Array<any>",
+    name: "daterange",
+    description: "日期范围"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "单位，默认是 'day'， 即之比较到天"
+  }, {
+    type: "string",
+    name: "inclusivity",
+    description: "包容性规则，默认为'[]'。[ 表示包含、( 表示排除，如果使用包容性参数，则必须传入两个指示符，如'()'表示左右范围都排除"
+  }],
+  returns: {
+    type: "boolean",
+    description: "判断结果"
+  },
+  namespace: "日期函数"
+}, {
+  name: "ISSAMEORBEFORE",
+  description: "判断两个日期，是否第一个日期在第二个日期的前面或者相等",
+  example: "ISSAMEORBEFORE(a, b)",
+  params: [{
+    type: "date",
+    name: "a",
+    description: "第一个日期"
+  }, {
+    type: "date",
+    name: "b",
+    description: "第二个日期"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "单位，默认是 'day'， 即之比较到天"
+  }],
+  returns: {
+    type: "boolean",
+    description: "判断结果"
+  },
+  namespace: "日期函数"
+}, {
+  name: "ISSAMEORAFTER",
+  description: "判断两个日期，是否第一个日期在第二个日期的后面或者相等",
+  example: "ISSAMEORAFTER(a, b)",
+  params: [{
+    type: "date",
+    name: "a",
+    description: "第一个日期"
+  }, {
+    type: "date",
+    name: "b",
+    description: "第二个日期"
+  }, {
+    type: "string",
+    name: "unit",
+    description: "单位，默认是 'day'， 即之比较到天"
+  }],
+  returns: {
+    type: "boolean",
+    description: "判断结果"
+  },
+  namespace: "日期函数"
+}, {
+  name: "COUNT",
+  description: "返回数组的长度",
+  example: "COUNT(arr)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }],
+  returns: {
+    type: "boolean",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ARRAYMAP",
+  description: "数组做数据转换，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。",
+  example: "ARRAYMAP(arr, item => item)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "Array<any>",
+    name: "iterator",
+    description: "箭头函数"
+  }],
+  returns: {
+    type: "boolean",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ARRAYFILTER",
+  description: "数据做数据过滤，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。\n将第二个箭头函数返回为 false 的成员过滤掉。",
+  example: "ARRAYFILTER(arr, item => item)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "Array<any>",
+    name: "iterator",
+    description: "箭头函数"
+  }],
+  returns: {
+    type: "boolean",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ARRAYFINDINDEX",
+  description: "数据做数据查找，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。\n找出第二个箭头函数返回为 true 的成员的索引。\n\n示例：\n\nARRAYFINDINDEX([0, 2, false], item => item === 2) 得到 1",
+  example: "ARRAYFINDINDEX(arr, item => item === 2)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "Array<any>",
+    name: "iterator",
+    description: "箭头函数"
+  }],
+  returns: {
+    type: "number",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ARRAYFIND",
+  description: "数据做数据查找，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。\n找出第二个箭头函数返回为 true 的成员。\n\n示例：\n\nARRAYFIND([0, 2, false], item => item === 2) 得到 2",
+  example: "ARRAYFIND(arr, item => item === 2)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "Array<any>",
+    name: "iterator",
+    description: "箭头函数"
+  }],
+  returns: {
+    type: "any",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ARRAYSOME",
+  description: "数据做数据遍历判断，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。\n判断第二个箭头函数是否存在返回为 true 的成员。\n\n示例：\n\nARRAYSOME([0, 2, false], item => item === 2) 得到 true",
+  example: "ARRAYSOME(arr, item => item === 2)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "Array<any>",
+    name: "iterator",
+    description: "箭头函数"
+  }],
+  returns: {
+    type: "boolean",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ARRAYEVERY",
+  description: "数据做数据遍历判断，需要搭配箭头函数一起使用，注意箭头函数只支持单表达式用法。\n判断第二个箭头函数返回是否都为 true。\n\n示例：\n\nARRAYEVERY([0, 2, false], item => item === 2) 得到 false",
+  example: "ARRAYEVERY(arr, item => item === 2)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "Array<any>",
+    name: "iterator",
+    description: "箭头函数"
+  }],
+  returns: {
+    type: "boolean",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ARRAYINCLUDES",
+  description: "判断数据中是否存在指定元素\n\n示例：\n\nARRAYINCLUDES([0, 2, false], 2) 得到 true",
+  example: "ARRAYINCLUDES(arr, 2)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "any",
+    name: "item",
+    description: "元素"
+  }],
+  returns: {
+    type: "any",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "COMPACT",
+  description: "数组过滤掉 false、null、0 和 \"\"\n\n示例：\n\nCOMPACT([0, 1, false, 2, '', 3]) 得到 [1, 2, 3]",
+  example: "COMPACT(arr)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }],
+  returns: {
+    type: "Array<any>",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "JOIN",
+  description: "数组转成字符串\n\n示例：\n\nJOIN(['a', 'b', 'c'], '=') 得到 'a=b=c'",
+  example: "JOIN(arr, string)",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "String",
+    name: "separator",
+    description: "分隔符"
+  }],
+  returns: {
+    type: "String",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "CONCAT",
+  description: "数组合并\n\n示例：\n\nCONCAT(['a', 'b', 'c'], ['1'], ['3']) 得到 ['a', 'b', 'c', '1', '3']",
+  example: "CONCAT(['a', 'b', 'c'], ['1'], ['3'])",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }],
+  returns: {
+    type: "Array<any>",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "UNIQ",
+  description: "数组去重，第二个参数「field」，可指定根据该字段去重\n\n示例：\n\nUNIQ([{a: '1'}, {b: '2'}, {a: '1'}]， 'id')",
+  example: "UNIQ([{a: '1'}, {b: '2'}, {a: '1'}], 'x')",
+  params: [{
+    type: "Array<any>",
+    name: "arr",
+    description: "数组"
+  }, {
+    type: "string",
+    name: "field",
+    description: "字段"
+  }],
+  returns: {
+    type: "Array<any>",
+    description: "结果"
+  },
+  namespace: "数组"
+}, {
+  name: "ENCODEJSON",
+  description: "将JS对象转换成JSON字符串\n\n示例：\n\nENCODEJSON({name: 'amis'}) 得到 '{\"name\":\"amis\"}'",
+  example: "ENCODEJSON({name: 'amis'})",
+  params: [{
+    type: "object",
+    name: "obj",
+    description: "JS对象"
+  }],
+  returns: {
+    type: "string",
+    description: "结果"
+  },
+  namespace: "编码"
+}, {
+  name: "DECODEJSON",
+  description: "解析JSON编码数据，返回JS对象\n\n示例：\n\nDECODEJSON('{\\\"name\\\": \"amis\"}') 得到 {name: 'amis'}",
+  example: "DECODEJSON('{\\\"name\\\": \"amis\"}')",
+  params: [{
+    type: "string",
+    name: "str",
+    description: "字符串"
+  }],
+  returns: {
+    type: "object",
+    description: "结果"
+  },
+  namespace: "编码"
+}, {
+  name: "GET",
+  description: "根据对象或者数组的path路径获取值。 如果解析 value 是 undefined 会以 defaultValue 取代\n\n示例：\n\nGET([0, 2, {name: 'amis', age: 18}], 1) 得到 2\nGET([0, 2, {name: 'amis', age: 18}], '2.name') 得到 'amis'\nGET({arr: [{name: 'amis', age: 18}]}, 'arr[0].name') 得到 'amis'\nGET({arr: [{name: 'amis', age: 18}]}, 'arr.0.name') 得到 'amis'\nGET({arr: [{name: 'amis', age: 18}]}, 'arr.1.name', 'not-found') 得到 'not-found'",
+  example: "GET(arr, 2)",
+  params: [{
+    type: "any",
+    name: "obj",
+    description: "对象或数组"
+  }, {
+    type: "string",
+    name: "path",
+    description: "路径"
+  }, {
+    type: "any",
+    name: "defaultValue",
+    description: "如果解析不到则返回该值"
+  }],
+  returns: {
+    type: "any",
+    description: "结果"
+  },
+  namespace: "其他"
+}, {
+  name: "ISTYPE",
+  description: "判断是否为类型支持：string, number, array, date, plain-object。",
+  example: "ISTYPE([{a: '1'}, {b: '2'}, {a: '1'}], 'array')",
+  params: [{
+    type: "string",
+    name: "判断对象",
+    description: null
+  }],
+  returns: {
+    type: "boolean",
+    description: "结果"
+  },
+  namespace: "其他"
+}]);
+// EXTERNAL MODULE: external "element-ui/lib/message"
+var message_ = __webpack_require__(61);
+var message_default = /*#__PURE__*/__webpack_require__.n(message_);
+
+// CONCATENATED MODULE: ./src/components/formula/src/index.js
+
+
+
+
+
+
+
+
+
+/* harmony default export */ var src = ({
+  name: "Formula",
+  componentName: "Formula",
+  components: {
+    CodeMirrorEditor: codeMirror,
+    FuncList: funcList,
+    VariableList: variableList
+  },
+  props: {
+    value: String,
+    evalMode: {
+      type: Boolean,
+      default: function _default() {
+        return true;
+      }
+    },
+    /**
+     * 变量展现模式，可选值：'tabs' ｜ 'tree'
+     */
+    variableMode: {
+      type: String,
+      default: "tabs"
+    },
+    functions: Array,
+    variables: Array,
+    functionClassName: String,
+    variableClassName: String,
+    /**
+     * 当前输入项字段 name: 用于避免循环绑定自身导致无限渲染
+     */
+    selfVariableName: String
+  },
+  data: function data() {
+    return {
+      focused: false,
+      editorPlugin: null
+    };
+  },
+  computed: {
+    functionList: function functionList() {
+      var funcs = [];
+      doc.forEach(function (item) {
+        var namespace = item.namespace || 'Others';
+        var exists = funcs.find(function (item) {
+          return item.groupName === namespace;
+        });
+        if (!exists) {
+          exists = {
+            groupName: namespace,
+            items: []
+          };
+          funcs.push(exists);
+        }
+        exists.items.push(item);
+      });
+      var customFunctions = Array.isArray(this.functions) ? this.functions : [];
+      return [].concat(funcs, customFunctions);
+    }
+  },
+  methods: {
+    editorFactory: function editorFactory(dom, cm) {
+      return plugin_editorFactory(dom, cm, this.$props);
+    },
+    handleEditorMounted: function handleEditorMounted(cm, editor) {
+      var _this = this;
+      this.editorPlugin = new FormulaPlugin(editor, cm, function () {
+        return _this.$props;
+      });
+    },
+    // type:'variable' | 'func'
+    insertValue: function insertValue(value, type) {
+      if (!this.editorPlugin) {
+        return;
+      }
+      this.editorPlugin.insertContent(value, type);
+    },
+    handleFunctionSelect: function handleFunctionSelect(item) {
+      if (!this.editorPlugin) {
+        return;
+      }
+      this.editorPlugin.insertContent("" + item.name, 'func');
+    },
+    handleVariableSelect: function handleVariableSelect(item) {
+      var _this$$props = this.$props,
+        evalMode = _this$$props.evalMode,
+        selfVariableName = _this$$props.selfVariableName;
+      if (!(item.value && this.editorPlugin)) {
+        return;
+      }
+      if (selfVariableName && selfVariableName === item.value) {
+        message_default.a.warning("\u4E0D\u80FD\u4F7F\u7528\u5F53\u524D\u53D8\u91CF[" + selfVariableName + "]\uFF0C\u907F\u514D\u5FAA\u73AF\u5F15\u7528\u3002");
+        return;
+      }
+      this.editorPlugin.insertContent({
+        key: item.value,
+        name: item.label
+      }, 'variable');
+    },
+    handleChange: function handleChange(value) {
+      this.$emit("change", value);
+    },
+    handleFocus: function handleFocus() {
+      this.focused = true;
+    },
+    handleBlur: function handleBlur() {
+      this.focused = false;
+    },
+    handleValClick: function handleValClick() {
+      this.handleVariableSelect({
+        value: "name",
+        label: "名称"
+      });
+    }
+  },
+  beforeDestroy: function beforeDestroy() {
+    this.editorPlugin && this.editorPlugin.dispose();
+  },
+  render: function render(h) {
+    var mirrorParam = {
+      attrs: Object.assign({
+        className: "FormulaEditor-editor",
+        value: this.value,
+        editorFactory: this.editorFactory,
+        editorDidMount: this.handleEditorMounted
+      }, this.$attrs),
+      on: Object.assign({
+        change: this.handleChange,
+        focus: this.handleFocus,
+        blur: this.handleBlur
+      }, this.$listeners),
+      slots: this.$slots,
+      scopedSlots: this.$scopedSlots
+    };
+    return h("div", {
+      "class": ["FormulaEditor", {
+        "is-focused": this.focused
+      }]
+    }, [h("section", {
+      "class": ["FormulaEditor-content"]
+    }, [h("header", {
+      "class": "FormulaEditor-header"
+    }, ["\u8868\u8FBE\u5F0F"]), h(codeMirror, babel_helper_vue_jsx_merge_props_default()([{}, mirrorParam]))]), h("section", {
+      "class": "FormulaEditor-settings"
+    }, [h("div", {
+      "class": "FormulaEditor-panel"
+    }, [this.variableMode !== 'tabs' ? h("div", {
+      "class": "FormulaEditor-panel-header"
+    }, ["\u53D8\u91CF"]) : null, h("div", {
+      "class": ["FormulaEditor-panel-body", this.variableMode && "FormulaEditor-panel-body--" + this.variableMode]
+    }, [h(variableList, babel_helper_vue_jsx_merge_props_default()([{
+      "class": ["FormulaEditor-VariableList", "FormulaEditor-VariableList-root", this.variableClassName],
+      "attrs": {
+        "classPrefix": this.classPrefix,
+        "selectMode": this.variableMode,
+        "selfVariableName": this.selfVariableName,
+        "data": this.variables
+      }
+    }, {
+      "on": {
+        select: this.handleVariableSelect
+      }
+    }]))])]), h(funcList, babel_helper_vue_jsx_merge_props_default()([{
+      "attrs": {
+        "className": this.functionClassName,
+        "data": this.functionList
+      }
+    }, {
+      "on": {
+        select: this.handleFunctionSelect
+      }
+    }]))])]);
+  }
+});
+// CONCATENATED MODULE: ./src/components/formula/index.js
+
+/* istanbul ignore next */
+src.install = function (Vue) {
+  Vue.component(src.name, src);
+};
+/* harmony default export */ var formula = __webpack_exports__["default"] = (src);
+
+/***/ }),
+
+/***/ 8:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/collapse-item");
+
+/***/ })
+
+/******/ });