@idooel/components 0.0.2-beta.7 → 0.0.2-beta.8

package/dist/@idooel/components.umd.js

@@ -1,862 +1,14 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('moment'), require('@idooel/shared'), require('vue-upload-component')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'moment', '@idooel/shared', 'vue-upload-component'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.__ele__umd__components__ = {}, global.moment, global.shared, global.FileUpload));
-})(this, (function (exports, moment, shared, FileUpload) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@idooel/expression'), require('moment'), require('@idooel/shared'), require('vue-upload-component')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@idooel/expression', 'moment', '@idooel/shared', 'vue-upload-component'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.__ele__umd__components__ = {}, global["@idooel/expression"], global.moment, global["@idooel/shared"], global.FileUpload));
+})(this, (function (exports, expression, moment, shared, FileUpload) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
   var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
   var FileUpload__default = /*#__PURE__*/_interopDefaultLegacy(FileUpload);
 
-  var __defProp$2 = Object.defineProperty;
-  var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value
-  }) : obj[key] = value;
-  var __publicField$2 = (obj, key, value) => {
-    __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
-  class LexerError extends Error {
-    constructor(message, index, line, column) {
-      super(message);
-      __publicField$2(this, "index");
-      __publicField$2(this, "line");
-      __publicField$2(this, "column");
-      this.name = "LexerError";
-      this.index = index;
-      this.line = line;
-      this.column = column;
-    }
-  }
-  class ParseError extends Error {
-    constructor(message, index, line, column) {
-      super(message);
-      __publicField$2(this, "index");
-      __publicField$2(this, "line");
-      __publicField$2(this, "column");
-      this.name = "ParseError";
-      this.index = index;
-      this.line = line;
-      this.column = column;
-    }
-  }
-  class EvalError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "EvalError";
-    }
-  }
-  var TokenKind = /* @__PURE__ */(TokenKind2 => {
-    TokenKind2["Identifier"] = "Identifier";
-    TokenKind2["Number"] = "Number";
-    TokenKind2["String"] = "String";
-    TokenKind2["Punctuator"] = "Punctuator";
-    TokenKind2["Operator"] = "Operator";
-    TokenKind2["EOF"] = "EOF";
-    return TokenKind2;
-  })(TokenKind || {});
-  const PUNCTUATORS = /* @__PURE__ */new Set(["(", ")", "{", "}", "[", "]", ".", ",", ":", "?"]);
-  const MULTI_OPERATORS = ["?.", "??", "===", "!==", "==", "!=", "<=", ">=", "&&", "||"];
-  const SINGLE_OPERATORS = /* @__PURE__ */new Set(["+", "-", "*", "/", "%", "<", ">", "!"]);
-  function isDigit(ch) {
-    return ch >= "0" && ch <= "9";
-  }
-  function isIdentStart(ch) {
-    return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_" || ch === "$";
-  }
-  function isIdentPart(ch) {
-    return isIdentStart(ch) || isDigit(ch);
-  }
-  function lex(input) {
-    if (!input && input !== "") throw new LexerError("invalid input", 0, 1, 1);
-    const tokens = [];
-    let index = 0;
-    let line = 1;
-    let column = 1;
-    function current() {
-      return input.charAt(index);
-    }
-    function advance(n = 1) {
-      for (let i = 0; i < n; i++) {
-        const ch = input.charAt(index++);
-        if (ch === "\n") {
-          line++;
-          column = 1;
-        } else {
-          column++;
-        }
-      }
-    }
-    function make(kind, text, value, startIndex, startLine, startColumn) {
-      return {
-        kind,
-        text,
-        value,
-        index: startIndex ?? index,
-        line: startLine ?? line,
-        column: startColumn ?? column
-      };
-    }
-    while (index < input.length) {
-      const ch = current();
-      if (ch === " " || ch === "	" || ch === "\r" || ch === "\n" || ch === "\v" || ch === "\xA0") {
-        advance();
-        continue;
-      }
-      if (ch === "'" || ch === '"') {
-        const quote = ch;
-        const startIndex = index;
-        const startLine = line;
-        const startColumn = column;
-        advance();
-        let value = "";
-        let escaped = false;
-        while (index < input.length) {
-          const c = current();
-          if (escaped) {
-            if (c === "u") {
-              const hex = input.substring(index + 1, index + 5);
-              if (!/^[\da-f]{4}$/i.test(hex)) {
-                throw new LexerError(`invalid unicode escape \\u${hex}`, index, line, column);
-              }
-              value += String.fromCharCode(parseInt(hex, 16));
-              advance(5);
-            } else {
-              const ESCAPE = {
-                n: "\n",
-                f: "\f",
-                r: "\r",
-                t: "	",
-                v: "\v"
-              };
-              value += ESCAPE[c] ?? c;
-              advance();
-            }
-            escaped = false;
-            continue;
-          }
-          if (c === "\\") {
-            escaped = true;
-            advance();
-            continue;
-          }
-          if (c === quote) {
-            advance();
-            tokens.push(make("String" /* String */, input.slice(startIndex, index), value, startIndex, startLine, startColumn));
-            value = "";
-            break;
-          }
-          value += c;
-          advance();
-        }
-        if (value !== "") {
-          const last = tokens[tokens.length - 1];
-          if (!last || last.index !== startIndex) {
-            throw new LexerError("unterminated string", startIndex, startLine, startColumn);
-          }
-        }
-        continue;
-      }
-      if (isDigit(ch) || ch === "." && isDigit(input.charAt(index + 1))) {
-        const startIndex = index;
-        const startLine = line;
-        const startColumn = column;
-        let text = "";
-        while (index < input.length) {
-          let c = input.charAt(index).toLowerCase();
-          if (c === "." || isDigit(c)) {
-            text += c;
-          } else {
-            const c2 = input.charAt(index + 1);
-            if (c === "e" && (c2 === "+" || c2 === "-" || isDigit(c2))) {
-              text += c;
-            } else if ((c === "+" || c === "-") && isDigit(c2) && text.charAt(text.length - 1) === "e") {
-              text += c;
-            } else if ((c === "+" || c === "-") && (!c2 || !isDigit(c2)) && text.charAt(text.length - 1) === "e") {
-              throw new LexerError("dangling exponent", index, line, column);
-            } else {
-              break;
-            }
-          }
-          advance();
-        }
-        tokens.push(make("Number" /* Number */, text, Number(text), startIndex, startLine, startColumn));
-        continue;
-      }
-      if (isIdentStart(ch)) {
-        const startIndex = index;
-        const startLine = line;
-        const startColumn = column;
-        advance();
-        while (index < input.length && isIdentPart(current())) advance();
-        const text = input.slice(startIndex, index);
-        tokens.push(make("Identifier" /* Identifier */, text, void 0, startIndex, startLine, startColumn));
-        continue;
-      }
-      const three = input.substring(index, index + 3);
-      const two = input.substring(index, index + 2);
-      const one = input.substring(index, index + 1);
-      const multi = MULTI_OPERATORS.find(op => input.startsWith(op, index));
-      if (multi) {
-        tokens.push(make("Operator" /* Operator */, multi, void 0, index, line, column));
-        advance(multi.length);
-        continue;
-      }
-      if (PUNCTUATORS.has(one)) {
-        tokens.push(make("Punctuator" /* Punctuator */, one, void 0, index, line, column));
-        advance();
-        continue;
-      }
-      if (SINGLE_OPERATORS.has(one)) {
-        tokens.push(make("Operator" /* Operator */, one, void 0, index, line, column));
-        advance();
-        continue;
-      }
-      throw new LexerError(`invalid token '${three || two || one}'`, index, line, column);
-    }
-    tokens.push({
-      kind: "EOF" /* EOF */,
-      text: "<eof>",
-      index,
-      line,
-      column
-    });
-    return {
-      tokens
-    };
-  }
-  var __defProp$1 = Object.defineProperty;
-  var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value
-  }) : obj[key] = value;
-  var __publicField$1 = (obj, key, value) => {
-    __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
-  class LRUCache {
-    constructor(maxSize = 100) {
-      __publicField$1(this, "cache", /* @__PURE__ */new Map());
-      __publicField$1(this, "maxSize");
-      this.maxSize = maxSize;
-    }
-    get(key) {
-      const value = this.cache.get(key);
-      if (value !== void 0) {
-        this.cache.delete(key);
-        this.cache.set(key, value);
-      }
-      return value;
-    }
-    set(key, value) {
-      if (this.cache.has(key)) {
-        this.cache.delete(key);
-      }
-      if (this.cache.size >= this.maxSize) {
-        const firstKey = this.cache.keys().next().value;
-        if (firstKey !== void 0) {
-          this.cache.delete(firstKey);
-        }
-      }
-      this.cache.set(key, value);
-    }
-    clear() {
-      this.cache.clear();
-    }
-  }
-  const astCache = new LRUCache(100);
-  function parseToAst(input) {
-    const cached = astCache.get(input);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const {
-      tokens
-    } = lex(input);
-    const state = new Parser(tokens, input);
-    const result = state.parse();
-    astCache.set(input, result);
-    return result;
-  }
-  class Parser {
-    constructor(tokens, input) {
-      __publicField$1(this, "tokens");
-      __publicField$1(this, "input");
-      __publicField$1(this, "i", 0);
-      this.tokens = tokens;
-      this.input = input;
-    }
-    current() {
-      return this.tokens[this.i];
-    }
-    next() {
-      return this.tokens[this.i + 1];
-    }
-    eat() {
-      return this.tokens[this.i++];
-    }
-    matchText(text) {
-      return this.current()?.text === text;
-    }
-    expectText(text) {
-      const t = this.current();
-      if (!text || t?.text === text) {
-        this.i++;
-        return t;
-      }
-      return void 0;
-    }
-    consumeText(text) {
-      const t = this.expectText(text);
-      if (!t) this.error(this.current(), `unexpected token, expect '${text ?? "<any>"}'`);
-      return t;
-    }
-    error(t, message) {
-      throw new ParseError(`${message} at ${t.line}:${t.column}`, t.index, t.line, t.column);
-    }
-    parse() {
-      const t = this.current();
-      if (t && t.kind !== TokenKind.EOF && t.text !== "}" && t.text !== ")" && t.text !== "]") {
-        const expr = this.expression();
-        return expr;
-      }
-      return void 0;
-    }
-    expression() {
-      return this.ternary();
-    }
-    ternary() {
-      const test = this.nullish();
-      if (this.expectText("?")) {
-        const consequent = this.expression();
-        this.consumeText(":");
-        const alternate = this.expression();
-        const node = {
-          type: "ConditionalExpression",
-          test,
-          consequent,
-          alternate
-        };
-        return node;
-      }
-      return test;
-    }
-    nullish() {
-      let left = this.logicalOR();
-      while (this.expectText("??")) {
-        if (isLogicalAndOr(left)) {
-          this.error(this.current(), "Cannot mix ?? with && or || without parentheses");
-        }
-        const rightStart = this.current();
-        const right = this.logicalOR();
-        if (isLogicalAndOr(right)) {
-          this.error(rightStart, "Cannot mix ?? with && or || without parentheses");
-        }
-        const node = {
-          type: "LogicalExpression",
-          operator: "??",
-          left,
-          right
-        };
-        left = node;
-      }
-      return left;
-    }
-    logicalOR() {
-      let left = this.logicalAND();
-      while (this.expectText("||")) {
-        const right = this.logicalAND();
-        const node = {
-          type: "LogicalExpression",
-          operator: "||",
-          left,
-          right
-        };
-        left = node;
-      }
-      return left;
-    }
-    logicalAND() {
-      let left = this.equality();
-      while (this.expectText("&&")) {
-        const right = this.equality();
-        const node = {
-          type: "LogicalExpression",
-          operator: "&&",
-          left,
-          right
-        };
-        left = node;
-      }
-      return left;
-    }
-    equality() {
-      let left = this.relational();
-      while (true) {
-        if (this.expectText("===")) {
-          left = this.binary(left, "===", this.relational());
-        } else if (this.expectText("!==")) {
-          left = this.binary(left, "!==", this.relational());
-        } else if (this.expectText("==")) {
-          left = this.binary(left, "==", this.relational());
-        } else if (this.expectText("!=")) {
-          left = this.binary(left, "!=", this.relational());
-        } else break;
-      }
-      return left;
-    }
-    relational() {
-      let left = this.additive();
-      while (true) {
-        if (this.expectText("<=")) {
-          left = this.binary(left, "<=", this.additive());
-        } else if (this.expectText(">=")) {
-          left = this.binary(left, ">=", this.additive());
-        } else if (this.expectText("<")) {
-          left = this.binary(left, "<", this.additive());
-        } else if (this.expectText(">")) {
-          left = this.binary(left, ">", this.additive());
-        } else break;
-      }
-      return left;
-    }
-    additive() {
-      let left = this.multiplicative();
-      while (true) {
-        if (this.expectText("+")) {
-          left = this.binary(left, "+", this.multiplicative());
-        } else if (this.expectText("-")) {
-          left = this.binary(left, "-", this.multiplicative());
-        } else break;
-      }
-      return left;
-    }
-    multiplicative() {
-      let left = this.unary();
-      while (true) {
-        if (this.expectText("*")) {
-          left = this.binary(left, "*", this.unary());
-        } else if (this.expectText("/")) {
-          left = this.binary(left, "/", this.unary());
-        } else if (this.expectText("%")) {
-          left = this.binary(left, "%", this.unary());
-        } else break;
-      }
-      return left;
-    }
-    unary() {
-      if (this.expectText("+")) {
-        return this.primary();
-      }
-      if (this.expectText("-")) {
-        const arg = this.unary();
-        const node = {
-          type: "UnaryExpression",
-          operator: "-",
-          argument: arg
-        };
-        return node;
-      }
-      if (this.expectText("!")) {
-        const arg = this.unary();
-        const node = {
-          type: "UnaryExpression",
-          operator: "!",
-          argument: arg
-        };
-        return node;
-      }
-      return this.primary();
-    }
-    primary() {
-      const t = this.current();
-      let expr;
-      if (this.expectText("(")) {
-        expr = this.expression();
-        this.consumeText(")");
-      } else if (this.expectText("[")) {
-        expr = this.array();
-      } else if (this.expectText("{")) {
-        expr = this.object();
-      } else if (t.kind === TokenKind.Identifier && (t.text === "true" || t.text === "false" || t.text === "null" || t.text === "undefined")) {
-        const tok = this.eat();
-        const map = {
-          true: true,
-          false: false,
-          null: null,
-          undefined: void 0
-        };
-        const node = {
-          type: "Literal",
-          value: map[tok.text]
-        };
-        expr = node;
-      } else if (t.kind === TokenKind.Identifier) {
-        expr = this.identifier();
-      } else if (t.kind === TokenKind.Number || t.kind === TokenKind.String) {
-        const tok = this.eat();
-        const node = {
-          type: "Literal",
-          value: tok.kind === TokenKind.Number ? Number(tok.text) : String(tok.value)
-        };
-        expr = node;
-      } else {
-        this.error(t, "unexpected token in primary");
-      }
-      while (true) {
-        if (this.expectText("(")) {
-          const args = [];
-          if (!this.matchText(")")) {
-            do {
-              args.push(this.expression());
-            } while (this.expectText(","));
-          }
-          this.consumeText(")");
-          const call = {
-            type: "CallExpression",
-            callee: expr,
-            arguments: args,
-            optional: false
-          };
-          expr = call;
-          continue;
-        }
-        if (this.expectText("?.(")) ;
-        if (this.expectText(".")) {
-          const id = this.consumeIdentifier();
-          const prop = {
-            type: "Identifier",
-            name: id
-          };
-          const mem = {
-            type: "MemberExpression",
-            object: expr,
-            property: prop,
-            computed: false,
-            optional: false
-          };
-          expr = mem;
-          continue;
-        }
-        if (this.expectText("[")) {
-          const prop = this.expression();
-          this.consumeText("]");
-          const mem = {
-            type: "MemberExpression",
-            object: expr,
-            property: prop,
-            computed: true,
-            optional: false
-          };
-          expr = mem;
-          continue;
-        }
-        if (this.matchText("?.")) {
-          this.eat();
-          if (this.expectText("(")) {
-            const args = [];
-            if (!this.matchText(")")) {
-              do {
-                args.push(this.expression());
-              } while (this.expectText(","));
-            }
-            this.consumeText(")");
-            const call = {
-              type: "CallExpression",
-              callee: expr,
-              arguments: args,
-              optional: true
-            };
-            expr = call;
-            continue;
-          }
-          if (this.expectText("[")) {
-            const prop2 = this.expression();
-            this.consumeText("]");
-            const mem2 = {
-              type: "MemberExpression",
-              object: expr,
-              property: prop2,
-              computed: true,
-              optional: true
-            };
-            expr = mem2;
-            continue;
-          }
-          const id = this.consumeIdentifier();
-          const prop = {
-            type: "Identifier",
-            name: id
-          };
-          const mem = {
-            type: "MemberExpression",
-            object: expr,
-            property: prop,
-            computed: false,
-            optional: true
-          };
-          expr = mem;
-          continue;
-        }
-        break;
-      }
-      return expr;
-    }
-    identifier() {
-      const name = this.consumeIdentifier();
-      const node = {
-        type: "Identifier",
-        name
-      };
-      return node;
-    }
-    consumeIdentifier() {
-      const t = this.current();
-      if (t.kind !== TokenKind.Identifier) this.error(t, "identifier expected");
-      this.eat();
-      return t.text;
-    }
-    array() {
-      const elements = [];
-      if (!this.matchText("]")) {
-        do {
-          if (this.matchText("]")) break;
-          elements.push(this.expression());
-        } while (this.expectText(","));
-      }
-      this.consumeText("]");
-      return {
-        type: "ArrayExpression",
-        elements
-      };
-    }
-    object() {
-      const properties = [];
-      if (!this.matchText("}")) {
-        do {
-          if (this.matchText("}")) break;
-          const keyTok = this.eat();
-          let key;
-          if (keyTok.kind === TokenKind.String) key = String(keyTok.value);else if (keyTok.kind === TokenKind.Identifier) key = keyTok.text;else this.error(keyTok, "invalid object key");
-          this.consumeText(":");
-          const value = this.expression();
-          properties.push({
-            key,
-            value
-          });
-        } while (this.expectText(","));
-      }
-      this.consumeText("}");
-      return {
-        type: "ObjectExpression",
-        properties
-      };
-    }
-    binary(left, op, right) {
-      return {
-        type: "BinaryExpression",
-        operator: op,
-        left,
-        right
-      };
-    }
-  }
-  function isLogicalAndOr(node) {
-    return node.type === "LogicalExpression" && (node.operator === "&&" || node.operator === "||");
-  }
-  const DENY_KEYS = /* @__PURE__ */new Set(["__proto__", "prototype", "constructor"]);
-  let evalOptions = {};
-  let currentDepth = 0;
-  function evaluate(ast, scope, options) {
-    if (!ast) return void 0;
-    evalOptions = options || {};
-    currentDepth = 0;
-    return exec(ast, scope);
-  }
-  function exec(node, scope) {
-    const maxDepth = evalOptions.maxDepth || 100;
-    if (++currentDepth > maxDepth) {
-      currentDepth--;
-      if (evalOptions.strict) {
-        throw new EvalError(`Maximum recursion depth (${maxDepth}) exceeded`);
-      }
-      return void 0;
-    }
-    try {
-      switch (node.type) {
-        case "Literal":
-          return node.value;
-        case "Identifier":
-          return readIdentifier(node, scope);
-        case "MemberExpression":
-          return readMember(node, scope);
-        case "CallExpression":
-          return callExpression(node, scope);
-        case "UnaryExpression":
-          return unaryExpression(node, scope);
-        case "BinaryExpression":
-          return binaryExpression(node, scope);
-        case "LogicalExpression":
-          return logicalExpression(node, scope);
-        case "ConditionalExpression":
-          return conditionalExpression(node, scope);
-        case "ArrayExpression":
-          return arrayExpression(node, scope);
-        case "ObjectExpression":
-          return objectExpression(node, scope);
-        default:
-          return void 0;
-      }
-    } finally {
-      currentDepth--;
-    }
-  }
-  function readIdentifier(node, scope) {
-    if (!scope) return void 0;
-    return scope[node.name];
-  }
-  function readMember(node, scope) {
-    const object = exec(node.object, scope);
-    if (object == null) {
-      return void 0;
-    }
-    const key = node.computed ? String(exec(node.property, scope)) : node.property.name;
-    if (DENY_KEYS.has(key)) {
-      if (evalOptions.strict) {
-        throw new EvalError(`Access to property "${key}" is not allowed`);
-      }
-      return void 0;
-    }
-    try {
-      return object[key];
-    } catch (err) {
-      if (evalOptions.strict) {
-        throw new EvalError(`Failed to access property "${key}": ${err}`);
-      }
-      return void 0;
-    }
-  }
-  function callExpression(node, scope) {
-    let fn;
-    let thisArg = void 0;
-    const calleeNode = node.callee;
-    if (calleeNode.type === "MemberExpression") {
-      const mem = calleeNode;
-      thisArg = exec(mem.object, scope);
-      if (thisArg == null) return void 0;
-      const key = mem.computed ? String(exec(mem.property, scope)) : mem.property.name;
-      if (DENY_KEYS.has(key)) {
-        if (evalOptions.strict) {
-          throw new EvalError(`Call to method "${key}" is not allowed`);
-        }
-        return void 0;
-      }
-      fn = thisArg[key];
-    } else {
-      fn = exec(node.callee, scope);
-    }
-    if (fn == null) return void 0;
-    if (typeof fn !== "function") {
-      if (evalOptions.strict) {
-        throw new EvalError(`Cannot call non-function value`);
-      }
-      return void 0;
-    }
-    const args = node.arguments.map(a => exec(a, scope));
-    try {
-      return fn.apply(thisArg, args);
-    } catch (err) {
-      if (evalOptions.strict) {
-        throw new EvalError(`Function call failed: ${err}`);
-      }
-      return void 0;
-    }
-  }
-  function unaryExpression(node, scope) {
-    const v = exec(node.argument, scope);
-    switch (node.operator) {
-      case "-":
-        return 0 - Number(v);
-      case "!":
-        return !v;
-      case "+":
-        return v;
-    }
-  }
-  function binaryExpression(node, scope) {
-    const a = exec(node.left, scope);
-    const b = exec(node.right, scope);
-    switch (node.operator) {
-      case "+":
-        return a + b;
-      case "-":
-        return a - b;
-      case "*":
-        return a * b;
-      case "/":
-        return a / b;
-      case "%":
-        return a % b;
-      case "==":
-        return a == b;
-      case "!=":
-        return a != b;
-      case "===":
-        return a === b;
-      case "!==":
-        return a !== b;
-      case "<":
-        return a < b;
-      case ">":
-        return a > b;
-      case "<=":
-        return a <= b;
-      case ">=":
-        return a >= b;
-    }
-  }
-  function logicalExpression(node, scope) {
-    if (node.operator === "&&") {
-      const left2 = exec(node.left, scope);
-      return left2 ? exec(node.right, scope) : left2;
-    }
-    if (node.operator === "||") {
-      const left2 = exec(node.left, scope);
-      return left2 ? left2 : exec(node.right, scope);
-    }
-    const left = exec(node.left, scope);
-    return left ?? exec(node.right, scope);
-  }
-  function conditionalExpression(node, scope) {
-    const test = exec(node.test, scope);
-    return test ? exec(node.consequent, scope) : exec(node.alternate, scope);
-  }
-  function arrayExpression(node, scope) {
-    return node.elements.map(e => exec(e, scope));
-  }
-  function objectExpression(node, scope) {
-    const out = {};
-    for (const p of node.properties) {
-      if (DENY_KEYS.has(p.key)) continue;
-      out[p.key] = exec(p.value, scope);
-    }
-    return out;
-  }
-  function compile(expression, options) {
-    if (!expression) throw new Error("expression is required");
-    const ast = parseToAst(expression);
-    return scope => evaluate(ast, scope, options);
-  }
-  function parse$1(expression, scope = {}, options) {
-    return compile(expression, options)(scope);
-  }
-
   const CONTEXT = '__idooel__ele__context__';
   const AREA_NAMES = {
     BUTTON_GROUP: 'BUTTON_GROUP'
@@ -908,7 +60,7 @@
   const parseFieldMap = (fieldMap = {}, dataSource = {}) => {
     let ret = {};
     Object.keys(fieldMap).forEach(key => {
-      ret[fieldMap[key]] = parse$1(key, dataSource);
+      ret[fieldMap[key]] = expression.parse(key, dataSource);
     });
     return ret;
   };
@@ -1920,7 +1072,7 @@
           } else if (shared.type.isBool(show)) {
             if (show) return item;
           } else if (shared.type.isStr(show)) {
-            const parseRet = parse$1(show, {
+            const parseRet = expression.parse(show, {
               ...this.record,
               _route: shared.route.searchToQueryParams(window.location.search)
             });
@@ -4178,10 +3330,10 @@
       formModels(fieldNames) {
         return this.$refs[this.formRef] ? this.$refs[this.formRef].getFieldsValue(fieldNames) : {};
       },
-      executeExpression(expression, dataSource = {}) {
-        if (shared.type.isBool(expression)) return expression;
-        if (shared.type.isEmpty(expression)) return false;
-        return parse$1(expression, {
+      executeExpression(expression$1, dataSource = {}) {
+        if (shared.type.isBool(expression$1)) return expression$1;
+        if (shared.type.isEmpty(expression$1)) return false;
+        return expression.parse(expression$1, {
           ...this.expressionData,
           ...this.formModels(),
           ...dataSource
@@ -4525,10 +3677,10 @@
       this.evalShowExpressionForFooterElements();
     },
     methods: {
-      executeExpression(expression) {
-        if (shared.type.isBool(expression)) return expression;
-        if (shared.type.isEmpty(expression)) return false;
-        return parse$1(expression, {
+      executeExpression(expression$1) {
+        if (shared.type.isBool(expression$1)) return expression$1;
+        if (shared.type.isEmpty(expression$1)) return false;
+        return expression.parse(expression$1, {
           ...this.expressionData
         });
       },
@@ -4911,10 +4063,10 @@
           this.$set(ele, '_show', ret);
         });
       },
-      executeExpression(expression) {
-        if (shared.type.isBool(expression)) return expression;
-        if (shared.type.isEmpty(expression)) return false;
-        return parse$1(expression, {
+      executeExpression(expression$1) {
+        if (shared.type.isBool(expression$1)) return expression$1;
+        if (shared.type.isEmpty(expression$1)) return false;
+        return expression.parse(expression$1, {
           ...this.getFieldsValue(),
           ...this.formModel,
           _route: this.$route.query,
@@ -12745,7 +11897,7 @@
       buildDefaultValue(arg) {
         if (shared.type.notStr(arg)) return arg;
         if (!arg || arg.charAt(0) !== '_') return arg;
-        return parse$1(arg, {
+        return expression.parse(arg, {
           _route: this.$route.query
         });
       },
@@ -13205,10 +12357,10 @@
         } = modalConfirm;
         return !this.executeExpression(show);
       },
-      executeExpression(expression) {
-        if (shared.type.isBool(expression)) return expression;
-        if (shared.type.isEmpty(expression)) return true;
-        return parse$1(expression, {
+      executeExpression(expression$1) {
+        if (shared.type.isBool(expression$1)) return expression$1;
+        if (shared.type.isEmpty(expression$1)) return true;
+        return expression.parse(expression$1, {
           ...this.currentContext,
           ...this.contextData
         });
@@ -13509,10 +12661,10 @@
         });
         return ret;
       },
-      executeExpression(expression, dataSource = {}) {
-        if (shared.type.isBool(expression)) return expression;
-        if (shared.type.isEmpty(expression)) return false;
-        return parse$1(expression, {
+      executeExpression(expression$1, dataSource = {}) {
+        if (shared.type.isBool(expression$1)) return expression$1;
+        if (shared.type.isEmpty(expression$1)) return false;
+        return expression.parse(expression$1, {
           ...this.expressionData,
           ...this.formModels(),
           ...dataSource