lew-ui 2.7.46 → 2.7.48

package/dist/index.js

@@ -1,4 +1,4 @@
-import { h, defineComponent, computed, createBlock, openBlock, resolveDynamicComponent, normalizeStyle, normalizeClass, unref, createApp, mergeModels, useModel, provide, watch, toRaw, createElementBlock, renderSlot, ref, Transition, withCtx, inject, createVNode, Fragment, createCommentVNode, createElementVNode, renderList, createTextVNode, toDisplayString as toDisplayString$1, isVNode as isVNode$1, mergeProps, getCurrentInstance, resolveDirective, withDirectives, onMounted, nextTick, createSlots, reactive, getCurrentScope, onScopeDispose, shallowRef, shallowReadonly, toValue, isRef, readonly, resolveComponent, onUnmounted, withModifiers, normalizeProps, guardReactiveProps, vShow, markRaw, Teleport, onActivated, onDeactivated, onBeforeUnmount, shallowReactive, onBeforeMount, vModelText, useCssVars, watchEffect, vModelDynamic, TransitionGroup, useSlots, vModelCheckbox, render as render$1, effectScope, Text } from "vue";
+import { h, defineComponent, computed, createBlock, openBlock, resolveDynamicComponent, normalizeStyle, normalizeClass, unref, createApp, mergeModels, useModel, provide, watch, toRaw, createElementBlock, renderSlot, ref, Transition, withCtx, inject, createVNode, Fragment, createCommentVNode, createElementVNode, renderList, createTextVNode, toDisplayString as toDisplayString$1, isVNode as isVNode$1, mergeProps, getCurrentInstance, resolveDirective, withDirectives, onMounted, nextTick, createSlots, reactive, getCurrentScope, onScopeDispose, shallowRef, shallowReadonly, toValue, isRef, readonly, resolveComponent, onUnmounted, withModifiers, normalizeProps, guardReactiveProps, vShow, markRaw, Teleport, onActivated, onDeactivated, onBeforeUnmount, shallowReactive, onBeforeMount, vModelText, useCssVars, vModelDynamic, TransitionGroup, useSlots, vModelCheckbox, watchEffect, render as render$1, effectScope, Text } from "vue";
 const collapseItemEmits = {
   change: (expanded, key) => ({ expanded, key })
 };
@@ -71,7 +71,7 @@ var symbolTag$3 = "[object Symbol]";
 function isSymbol(value) {
   return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$3;
 }
-function arrayMap(array2, iteratee) {
+function arrayMap$1(array2, iteratee) {
   var index2 = -1, length = array2 == null ? 0 : array2.length, result = Array(length);
   while (++index2 < length) {
     result[index2] = iteratee(array2[index2], index2, array2);
@@ -85,7 +85,7 @@ function baseToString(value) {
     return value;
   }
   if (isArray$1(value)) {
-    return arrayMap(value, baseToString) + "";
+    return arrayMap$1(value, baseToString) + "";
   }
   if (isSymbol(value)) {
     return symbolToString$1 ? symbolToString$1.call(value) : "";
@@ -791,7 +791,7 @@ function cloneBuffer(buffer, isDeep) {
     return buffer.slice();
   }
 }
-function arrayFilter(array2, predicate) {
+function arrayFilter$1(array2, predicate) {
   var index2 = -1, length = array2 == null ? 0 : array2.length, resIndex = 0, result = [];
   while (++index2 < length) {
     var value = array2[index2];
@@ -807,12 +807,12 @@ function stubArray() {
 var objectProto$5 = Object.prototype;
 var propertyIsEnumerable = objectProto$5.propertyIsEnumerable;
 var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
-var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object2) {
+var getSymbols$1 = !nativeGetSymbols$1 ? stubArray : function(object2) {
   if (object2 == null) {
     return [];
   }
   object2 = Object(object2);
-  return arrayFilter(nativeGetSymbols$1(object2), function(symbol) {
+  return arrayFilter$1(nativeGetSymbols$1(object2), function(symbol) {
     return propertyIsEnumerable.call(object2, symbol);
   });
 };
@@ -820,7 +820,7 @@ var nativeGetSymbols = Object.getOwnPropertySymbols;
 var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object2) {
   var result = [];
   while (object2) {
-    arrayPush(result, getSymbols(object2));
+    arrayPush(result, getSymbols$1(object2));
     object2 = getPrototype(object2);
   }
   return result;
@@ -830,7 +830,7 @@ function baseGetAllKeys(object2, keysFunc, symbolsFunc) {
   return isArray$1(object2) ? result : arrayPush(result, symbolsFunc(object2));
 }
 function getAllKeys(object2) {
-  return baseGetAllKeys(object2, keys, getSymbols);
+  return baseGetAllKeys(object2, keys, getSymbols$1);
 }
 function getAllKeysIn(object2) {
   return baseGetAllKeys(object2, keysIn, getSymbolsIn);
@@ -1629,7 +1629,7 @@ function pickBy(object2, predicate) {
   if (object2 == null) {
     return {};
   }
-  var props = arrayMap(getAllKeysIn(object2), function(prop) {
+  var props = arrayMap$1(getAllKeysIn(object2), function(prop) {
     return [prop];
   });
   predicate = baseIteratee(predicate);
@@ -2528,7 +2528,7 @@ class Schema {
       let conditions = schema.conditions;
       schema = schema.clone();
       schema.conditions = [];
-      schema = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema);
+      schema = conditions.reduce((prevSchema, condition2) => condition2.resolve(prevSchema, options), schema);
       schema = schema.resolve(options);
     }
     return schema;
@@ -6259,8 +6259,8 @@ const formItemProps = {
     })
   },
   visible: {
-    type: [Boolean, Function],
-    default: true,
+    type: Function,
+    default: () => true,
     validator: validators.boolean({
       componentName: "LewForm",
       propName: "visible"
@@ -6321,16 +6321,16 @@ const formItemProps = {
     })
   },
   disabled: {
-    type: [Boolean, Function],
-    default: false,
+    type: Function,
+    default: () => false,
     validator: validators.boolean({
       componentName: "LewFormItem",
       propName: "disabled"
     })
   },
   readonly: {
-    type: [Boolean, Function],
-    default: false,
+    type: Function,
+    default: () => false,
     validator: validators.boolean({
       componentName: "LewFormItem",
       propName: "readonly"
@@ -7028,7 +7028,7 @@ const _sfc_main$15 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewDescItem = /* @__PURE__ */ _export_sfc(_sfc_main$15, [["__scopeId", "data-v-c41ccfe3"]]);
+const LewDescItem = /* @__PURE__ */ _export_sfc(_sfc_main$15, [["__scopeId", "data-v-67c52aba"]]);
 const _sfc_main$14 = /* @__PURE__ */ defineComponent({
   __name: "LewDesc",
   props: descProps,
@@ -7484,7 +7484,7 @@ const _sfc_main$12 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewPagination = /* @__PURE__ */ _export_sfc(_sfc_main$12, [["__scopeId", "data-v-5caebf55"]]);
+const LewPagination = /* @__PURE__ */ _export_sfc(_sfc_main$12, [["__scopeId", "data-v-ed4ad664"]]);
 const tableEmits = {
   sortChange: (sortValue) => sortValue,
   selectChange: (selectedKeys) => selectedKeys,
@@ -7595,13 +7595,13 @@ function watchWithFilter(source, cb, options = {}) {
   );
 }
 function createUntil(r, isNot = false) {
-  function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
+  function toMatch(condition2, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
     let stop = null;
     const watcher = new Promise((resolve) => {
       stop = watch(
         r,
         (v) => {
-          if (condition(v) !== isNot) {
+          if (condition2(v) !== isNot) {
             if (stop)
               stop();
             else
@@ -11663,8 +11663,8 @@ const applyStyles$1 = {
 function getBasePlacement$1(placement) {
   return placement.split("-")[0];
 }
-var max = Math.max;
-var min = Math.min;
+var max$1 = Math.max;
+var min$1 = Math.min;
 var round = Math.round;
 function getUAString() {
   var uaData = navigator.userAgentData;
@@ -11726,7 +11726,7 @@ function getLayoutRect(element) {
     height
   };
 }
-function contains(parent, child) {
+function contains$1(parent, child) {
   var rootNode = child.getRootNode && child.getRootNode();
   if (parent.contains(child)) {
     return true;
@@ -11812,8 +11812,8 @@ function getOffsetParent(element) {
 function getMainAxisFromPlacement(placement) {
   return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
 }
-function within(min$1, value, max$1) {
-  return max(min$1, min(value, max$1));
+function within(min2, value, max2) {
+  return max$1(min2, min$1(value, max2));
 }
 function withinMaxClamp(min2, value, max2) {
   var v = within(min2, value, max2);
@@ -11882,7 +11882,7 @@ function effect$1(_ref2) {
       return;
     }
   }
-  if (!contains(state.elements.popper, arrowElement)) {
+  if (!contains$1(state.elements.popper, arrowElement)) {
     return;
   }
   state.elements.arrow = arrowElement;
@@ -12115,12 +12115,12 @@ function getDocumentRect(element) {
   var html = getDocumentElement(element);
   var winScroll = getWindowScroll(element);
   var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
-  var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
-  var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+  var width = max$1(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+  var height = max$1(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
   var x2 = -winScroll.scrollLeft + getWindowScrollBarX(element);
   var y2 = -winScroll.scrollTop;
   if (getComputedStyle$1(body || html).direction === "rtl") {
-    x2 += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    x2 += max$1(html.clientWidth, body ? body.clientWidth : 0) - width;
   }
   return {
     width,
@@ -12188,7 +12188,7 @@ function getClippingParents(element) {
     return [];
   }
   return clippingParents2.filter(function(clippingParent) {
-    return isElement$1(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
+    return isElement$1(clippingParent) && contains$1(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
   });
 }
 function getClippingRect(element, boundary, rootBoundary, strategy) {
@@ -12197,10 +12197,10 @@ function getClippingRect(element, boundary, rootBoundary, strategy) {
   var firstClippingParent = clippingParents2[0];
   var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
     var rect = getClientRectFromMixedType(element, clippingParent, strategy);
-    accRect.top = max(rect.top, accRect.top);
-    accRect.right = min(rect.right, accRect.right);
-    accRect.bottom = min(rect.bottom, accRect.bottom);
-    accRect.left = max(rect.left, accRect.left);
+    accRect.top = max$1(rect.top, accRect.top);
+    accRect.right = min$1(rect.right, accRect.right);
+    accRect.bottom = min$1(rect.bottom, accRect.bottom);
+    accRect.left = max$1(rect.left, accRect.left);
     return accRect;
   }, getClientRectFromMixedType(element, firstClippingParent, strategy));
   clippingRect.width = clippingRect.right - clippingRect.left;
@@ -12575,8 +12575,8 @@ function preventOverflow(_ref) {
     var altSide = mainAxis === "y" ? bottom : right;
     var len = mainAxis === "y" ? "height" : "width";
     var offset2 = popperOffsets2[mainAxis];
-    var min$1 = offset2 + overflow[mainSide];
-    var max$1 = offset2 - overflow[altSide];
+    var min2 = offset2 + overflow[mainSide];
+    var max2 = offset2 - overflow[altSide];
     var additive = tether ? -popperRect[len] / 2 : 0;
     var minLen = variation === start ? referenceRect[len] : popperRect[len];
     var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
@@ -12596,7 +12596,7 @@ function preventOverflow(_ref) {
     var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
     var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
     var tetherMax = offset2 + maxOffset - offsetModifierValue;
-    var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1);
+    var preventedOffset = within(tether ? min$1(min2, tetherMin) : min2, offset2, tether ? max$1(max2, tetherMax) : max2);
     popperOffsets2[mainAxis] = preventedOffset;
     data[mainAxis] = preventedOffset - offset2;
   }
@@ -12963,7 +12963,7 @@ function removeUndefinedProps(obj) {
     return acc;
   }, {});
 }
-function div() {
+function div$1() {
   return document.createElement("div");
 }
 function isElement(value) {
@@ -13118,15 +13118,15 @@ if (process.env.NODE_ENV !== "production") {
 function resetVisitedMessages() {
   visitedMessages = /* @__PURE__ */ new Set();
 }
-function warnWhen(condition, message) {
-  if (condition && !visitedMessages.has(message)) {
+function warnWhen(condition2, message) {
+  if (condition2 && !visitedMessages.has(message)) {
     var _console;
     visitedMessages.add(message);
     (_console = console).warn.apply(_console, getFormattedMessage(message));
   }
 }
-function errorWhen(condition, message) {
-  if (condition && !visitedMessages.has(message)) {
+function errorWhen(condition2, message) {
+  if (condition2 && !visitedMessages.has(message)) {
     var _console2;
     visitedMessages.add(message);
     (_console2 = console).error.apply(_console2, getFormattedMessage(message));
@@ -13285,7 +13285,7 @@ function dangerouslySetInnerHTML(element, html) {
   element[innerHTML()] = html;
 }
 function createArrowElement(value) {
-  var arrow2 = div();
+  var arrow2 = div$1();
   if (value === true) {
     arrow2.className = ARROW_CLASS;
   } else {
@@ -13327,12 +13327,12 @@ function getChildren(popper2) {
   };
 }
 function render(instance) {
-  var popper2 = div();
-  var box = div();
+  var popper2 = div$1();
+  var box = div$1();
   box.className = BOX_CLASS;
   box.setAttribute("data-state", "hidden");
   box.setAttribute("tabindex", "-1");
-  var content = div();
+  var content = div$1();
   content.className = CONTENT_CLASS;
   content.setAttribute("data-state", "hidden");
   setContent(content, instance.props);
@@ -13419,7 +13419,7 @@ function createTippy(reference2, passedProps) {
     // properties
     id,
     reference: reference2,
-    popper: div(),
+    popper: div$1(),
     popperInstance,
     props,
     state,
@@ -19563,6 +19563,1610 @@ const formEmits = {
 const formItemEmits = {
   change: (value) => value
 };
+var INUMBER = "INUMBER";
+var IOP1 = "IOP1";
+var IOP2 = "IOP2";
+var IOP3 = "IOP3";
+var IVAR = "IVAR";
+var IVARNAME = "IVARNAME";
+var IFUNCALL = "IFUNCALL";
+var IFUNDEF = "IFUNDEF";
+var IEXPR = "IEXPR";
+var IEXPREVAL = "IEXPREVAL";
+var IMEMBER = "IMEMBER";
+var IENDSTATEMENT = "IENDSTATEMENT";
+var IARRAY = "IARRAY";
+function Instruction(type, value) {
+  this.type = type;
+  this.value = value !== void 0 && value !== null ? value : 0;
+}
+Instruction.prototype.toString = function() {
+  switch (this.type) {
+    case INUMBER:
+    case IOP1:
+    case IOP2:
+    case IOP3:
+    case IVAR:
+    case IVARNAME:
+    case IENDSTATEMENT:
+      return this.value;
+    case IFUNCALL:
+      return "CALL " + this.value;
+    case IFUNDEF:
+      return "DEF " + this.value;
+    case IARRAY:
+      return "ARRAY " + this.value;
+    case IMEMBER:
+      return "." + this.value;
+    default:
+      return "Invalid Instruction";
+  }
+};
+function unaryInstruction(value) {
+  return new Instruction(IOP1, value);
+}
+function binaryInstruction(value) {
+  return new Instruction(IOP2, value);
+}
+function ternaryInstruction(value) {
+  return new Instruction(IOP3, value);
+}
+function simplify(tokens, unaryOps, binaryOps, ternaryOps, values) {
+  var nstack = [];
+  var newexpression = [];
+  var n1, n2, n3;
+  var f;
+  for (var i = 0; i < tokens.length; i++) {
+    var item = tokens[i];
+    var type = item.type;
+    if (type === INUMBER || type === IVARNAME) {
+      if (Array.isArray(item.value)) {
+        nstack.push.apply(nstack, simplify(item.value.map(function(x2) {
+          return new Instruction(INUMBER, x2);
+        }).concat(new Instruction(IARRAY, item.value.length)), unaryOps, binaryOps, ternaryOps, values));
+      } else {
+        nstack.push(item);
+      }
+    } else if (type === IVAR && values.hasOwnProperty(item.value)) {
+      item = new Instruction(INUMBER, values[item.value]);
+      nstack.push(item);
+    } else if (type === IOP2 && nstack.length > 1) {
+      n2 = nstack.pop();
+      n1 = nstack.pop();
+      f = binaryOps[item.value];
+      item = new Instruction(INUMBER, f(n1.value, n2.value));
+      nstack.push(item);
+    } else if (type === IOP3 && nstack.length > 2) {
+      n3 = nstack.pop();
+      n2 = nstack.pop();
+      n1 = nstack.pop();
+      if (item.value === "?") {
+        nstack.push(n1.value ? n2.value : n3.value);
+      } else {
+        f = ternaryOps[item.value];
+        item = new Instruction(INUMBER, f(n1.value, n2.value, n3.value));
+        nstack.push(item);
+      }
+    } else if (type === IOP1 && nstack.length > 0) {
+      n1 = nstack.pop();
+      f = unaryOps[item.value];
+      item = new Instruction(INUMBER, f(n1.value));
+      nstack.push(item);
+    } else if (type === IEXPR) {
+      while (nstack.length > 0) {
+        newexpression.push(nstack.shift());
+      }
+      newexpression.push(new Instruction(IEXPR, simplify(item.value, unaryOps, binaryOps, ternaryOps, values)));
+    } else if (type === IMEMBER && nstack.length > 0) {
+      n1 = nstack.pop();
+      nstack.push(new Instruction(INUMBER, n1.value[item.value]));
+    } else {
+      while (nstack.length > 0) {
+        newexpression.push(nstack.shift());
+      }
+      newexpression.push(item);
+    }
+  }
+  while (nstack.length > 0) {
+    newexpression.push(nstack.shift());
+  }
+  return newexpression;
+}
+function substitute(tokens, variable, expr) {
+  var newexpression = [];
+  for (var i = 0; i < tokens.length; i++) {
+    var item = tokens[i];
+    var type = item.type;
+    if (type === IVAR && item.value === variable) {
+      for (var j = 0; j < expr.tokens.length; j++) {
+        var expritem = expr.tokens[j];
+        var replitem;
+        if (expritem.type === IOP1) {
+          replitem = unaryInstruction(expritem.value);
+        } else if (expritem.type === IOP2) {
+          replitem = binaryInstruction(expritem.value);
+        } else if (expritem.type === IOP3) {
+          replitem = ternaryInstruction(expritem.value);
+        } else {
+          replitem = new Instruction(expritem.type, expritem.value);
+        }
+        newexpression.push(replitem);
+      }
+    } else if (type === IEXPR) {
+      newexpression.push(new Instruction(IEXPR, substitute(item.value, variable, expr)));
+    } else {
+      newexpression.push(item);
+    }
+  }
+  return newexpression;
+}
+function evaluate(tokens, expr, values) {
+  var nstack = [];
+  var n1, n2, n3;
+  var f, args, argCount;
+  if (isExpressionEvaluator(tokens)) {
+    return resolveExpression(tokens, values);
+  }
+  var numTokens = tokens.length;
+  for (var i = 0; i < numTokens; i++) {
+    var item = tokens[i];
+    var type = item.type;
+    if (type === INUMBER || type === IVARNAME) {
+      nstack.push(item.value);
+    } else if (type === IOP2) {
+      n2 = nstack.pop();
+      n1 = nstack.pop();
+      if (item.value === "and") {
+        nstack.push(n1 ? !!evaluate(n2, expr, values) : false);
+      } else if (item.value === "or") {
+        nstack.push(n1 ? true : !!evaluate(n2, expr, values));
+      } else if (item.value === "=") {
+        f = expr.binaryOps[item.value];
+        nstack.push(f(n1, evaluate(n2, expr, values), values));
+      } else {
+        f = expr.binaryOps[item.value];
+        nstack.push(f(resolveExpression(n1, values), resolveExpression(n2, values)));
+      }
+    } else if (type === IOP3) {
+      n3 = nstack.pop();
+      n2 = nstack.pop();
+      n1 = nstack.pop();
+      if (item.value === "?") {
+        nstack.push(evaluate(n1 ? n2 : n3, expr, values));
+      } else {
+        f = expr.ternaryOps[item.value];
+        nstack.push(f(resolveExpression(n1, values), resolveExpression(n2, values), resolveExpression(n3, values)));
+      }
+    } else if (type === IVAR) {
+      if (item.value in expr.functions) {
+        nstack.push(expr.functions[item.value]);
+      } else if (item.value in expr.unaryOps && expr.parser.isOperatorEnabled(item.value)) {
+        nstack.push(expr.unaryOps[item.value]);
+      } else {
+        var v = values[item.value];
+        if (v !== void 0) {
+          nstack.push(v);
+        } else {
+          throw new Error("undefined variable: " + item.value);
+        }
+      }
+    } else if (type === IOP1) {
+      n1 = nstack.pop();
+      f = expr.unaryOps[item.value];
+      nstack.push(f(resolveExpression(n1, values)));
+    } else if (type === IFUNCALL) {
+      argCount = item.value;
+      args = [];
+      while (argCount-- > 0) {
+        args.unshift(resolveExpression(nstack.pop(), values));
+      }
+      f = nstack.pop();
+      if (f.apply && f.call) {
+        nstack.push(f.apply(void 0, args));
+      } else {
+        throw new Error(f + " is not a function");
+      }
+    } else if (type === IFUNDEF) {
+      nstack.push((function() {
+        var n22 = nstack.pop();
+        var args2 = [];
+        var argCount2 = item.value;
+        while (argCount2-- > 0) {
+          args2.unshift(nstack.pop());
+        }
+        var n12 = nstack.pop();
+        var f2 = function() {
+          var scope = Object.assign({}, values);
+          for (var i2 = 0, len = args2.length; i2 < len; i2++) {
+            scope[args2[i2]] = arguments[i2];
+          }
+          return evaluate(n22, expr, scope);
+        };
+        Object.defineProperty(f2, "name", {
+          value: n12,
+          writable: false
+        });
+        values[n12] = f2;
+        return f2;
+      })());
+    } else if (type === IEXPR) {
+      nstack.push(createExpressionEvaluator(item, expr));
+    } else if (type === IEXPREVAL) {
+      nstack.push(item);
+    } else if (type === IMEMBER) {
+      n1 = nstack.pop();
+      nstack.push(n1[item.value]);
+    } else if (type === IENDSTATEMENT) {
+      nstack.pop();
+    } else if (type === IARRAY) {
+      argCount = item.value;
+      args = [];
+      while (argCount-- > 0) {
+        args.unshift(nstack.pop());
+      }
+      nstack.push(args);
+    } else {
+      throw new Error("invalid Expression");
+    }
+  }
+  if (nstack.length > 1) {
+    throw new Error("invalid Expression (parity)");
+  }
+  return nstack[0] === 0 ? 0 : resolveExpression(nstack[0], values);
+}
+function createExpressionEvaluator(token, expr, values) {
+  if (isExpressionEvaluator(token)) return token;
+  return {
+    type: IEXPREVAL,
+    value: function(scope) {
+      return evaluate(token.value, expr, scope);
+    }
+  };
+}
+function isExpressionEvaluator(n) {
+  return n && n.type === IEXPREVAL;
+}
+function resolveExpression(n, values) {
+  return isExpressionEvaluator(n) ? n.value(values) : n;
+}
+function expressionToString(tokens, toJS) {
+  var nstack = [];
+  var n1, n2, n3;
+  var f, args, argCount;
+  for (var i = 0; i < tokens.length; i++) {
+    var item = tokens[i];
+    var type = item.type;
+    if (type === INUMBER) {
+      if (typeof item.value === "number" && item.value < 0) {
+        nstack.push("(" + item.value + ")");
+      } else if (Array.isArray(item.value)) {
+        nstack.push("[" + item.value.map(escapeValue).join(", ") + "]");
+      } else {
+        nstack.push(escapeValue(item.value));
+      }
+    } else if (type === IOP2) {
+      n2 = nstack.pop();
+      n1 = nstack.pop();
+      f = item.value;
+      if (toJS) {
+        if (f === "^") {
+          nstack.push("Math.pow(" + n1 + ", " + n2 + ")");
+        } else if (f === "and") {
+          nstack.push("(!!" + n1 + " && !!" + n2 + ")");
+        } else if (f === "or") {
+          nstack.push("(!!" + n1 + " || !!" + n2 + ")");
+        } else if (f === "||") {
+          nstack.push("(function(a,b){ return Array.isArray(a) && Array.isArray(b) ? a.concat(b) : String(a) + String(b); }((" + n1 + "),(" + n2 + ")))");
+        } else if (f === "==") {
+          nstack.push("(" + n1 + " === " + n2 + ")");
+        } else if (f === "!=") {
+          nstack.push("(" + n1 + " !== " + n2 + ")");
+        } else if (f === "[") {
+          nstack.push(n1 + "[(" + n2 + ") | 0]");
+        } else {
+          nstack.push("(" + n1 + " " + f + " " + n2 + ")");
+        }
+      } else {
+        if (f === "[") {
+          nstack.push(n1 + "[" + n2 + "]");
+        } else {
+          nstack.push("(" + n1 + " " + f + " " + n2 + ")");
+        }
+      }
+    } else if (type === IOP3) {
+      n3 = nstack.pop();
+      n2 = nstack.pop();
+      n1 = nstack.pop();
+      f = item.value;
+      if (f === "?") {
+        nstack.push("(" + n1 + " ? " + n2 + " : " + n3 + ")");
+      } else {
+        throw new Error("invalid Expression");
+      }
+    } else if (type === IVAR || type === IVARNAME) {
+      nstack.push(item.value);
+    } else if (type === IOP1) {
+      n1 = nstack.pop();
+      f = item.value;
+      if (f === "-" || f === "+") {
+        nstack.push("(" + f + n1 + ")");
+      } else if (toJS) {
+        if (f === "not") {
+          nstack.push("(!" + n1 + ")");
+        } else if (f === "!") {
+          nstack.push("fac(" + n1 + ")");
+        } else {
+          nstack.push(f + "(" + n1 + ")");
+        }
+      } else if (f === "!") {
+        nstack.push("(" + n1 + "!)");
+      } else {
+        nstack.push("(" + f + " " + n1 + ")");
+      }
+    } else if (type === IFUNCALL) {
+      argCount = item.value;
+      args = [];
+      while (argCount-- > 0) {
+        args.unshift(nstack.pop());
+      }
+      f = nstack.pop();
+      nstack.push(f + "(" + args.join(", ") + ")");
+    } else if (type === IFUNDEF) {
+      n2 = nstack.pop();
+      argCount = item.value;
+      args = [];
+      while (argCount-- > 0) {
+        args.unshift(nstack.pop());
+      }
+      n1 = nstack.pop();
+      if (toJS) {
+        nstack.push("(" + n1 + " = function(" + args.join(", ") + ") { return " + n2 + " })");
+      } else {
+        nstack.push("(" + n1 + "(" + args.join(", ") + ") = " + n2 + ")");
+      }
+    } else if (type === IMEMBER) {
+      n1 = nstack.pop();
+      nstack.push(n1 + "." + item.value);
+    } else if (type === IARRAY) {
+      argCount = item.value;
+      args = [];
+      while (argCount-- > 0) {
+        args.unshift(nstack.pop());
+      }
+      nstack.push("[" + args.join(", ") + "]");
+    } else if (type === IEXPR) {
+      nstack.push("(" + expressionToString(item.value, toJS) + ")");
+    } else if (type === IENDSTATEMENT) ;
+    else {
+      throw new Error("invalid Expression");
+    }
+  }
+  if (nstack.length > 1) {
+    if (toJS) {
+      nstack = [nstack.join(",")];
+    } else {
+      nstack = [nstack.join(";")];
+    }
+  }
+  return String(nstack[0]);
+}
+function escapeValue(v) {
+  if (typeof v === "string") {
+    return JSON.stringify(v).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  }
+  return v;
+}
+function contains(array2, obj) {
+  for (var i = 0; i < array2.length; i++) {
+    if (array2[i] === obj) {
+      return true;
+    }
+  }
+  return false;
+}
+function getSymbols(tokens, symbols, options) {
+  options = options || {};
+  var withMembers = !!options.withMembers;
+  var prevVar = null;
+  for (var i = 0; i < tokens.length; i++) {
+    var item = tokens[i];
+    if (item.type === IVAR || item.type === IVARNAME) {
+      if (!withMembers && !contains(symbols, item.value)) {
+        symbols.push(item.value);
+      } else if (prevVar !== null) {
+        if (!contains(symbols, prevVar)) {
+          symbols.push(prevVar);
+        }
+        prevVar = item.value;
+      } else {
+        prevVar = item.value;
+      }
+    } else if (item.type === IMEMBER && withMembers && prevVar !== null) {
+      prevVar += "." + item.value;
+    } else if (item.type === IEXPR) {
+      getSymbols(item.value, symbols, options);
+    } else if (prevVar !== null) {
+      if (!contains(symbols, prevVar)) {
+        symbols.push(prevVar);
+      }
+      prevVar = null;
+    }
+  }
+  if (prevVar !== null && !contains(symbols, prevVar)) {
+    symbols.push(prevVar);
+  }
+}
+function Expression(tokens, parser) {
+  this.tokens = tokens;
+  this.parser = parser;
+  this.unaryOps = parser.unaryOps;
+  this.binaryOps = parser.binaryOps;
+  this.ternaryOps = parser.ternaryOps;
+  this.functions = parser.functions;
+}
+Expression.prototype.simplify = function(values) {
+  values = values || {};
+  return new Expression(simplify(this.tokens, this.unaryOps, this.binaryOps, this.ternaryOps, values), this.parser);
+};
+Expression.prototype.substitute = function(variable, expr) {
+  if (!(expr instanceof Expression)) {
+    expr = this.parser.parse(String(expr));
+  }
+  return new Expression(substitute(this.tokens, variable, expr), this.parser);
+};
+Expression.prototype.evaluate = function(values) {
+  values = values || {};
+  return evaluate(this.tokens, this, values);
+};
+Expression.prototype.toString = function() {
+  return expressionToString(this.tokens, false);
+};
+Expression.prototype.symbols = function(options) {
+  options = options || {};
+  var vars = [];
+  getSymbols(this.tokens, vars, options);
+  return vars;
+};
+Expression.prototype.variables = function(options) {
+  options = options || {};
+  var vars = [];
+  getSymbols(this.tokens, vars, options);
+  var functions = this.functions;
+  return vars.filter(function(name) {
+    return !(name in functions);
+  });
+};
+Expression.prototype.toJSFunction = function(param, variables) {
+  var expr = this;
+  var f = new Function(param, "with(this.functions) with (this.ternaryOps) with (this.binaryOps) with (this.unaryOps) { return " + expressionToString(this.simplify(variables).tokens, true) + "; }");
+  return function() {
+    return f.apply(expr, arguments);
+  };
+};
+var TEOF = "TEOF";
+var TOP = "TOP";
+var TNUMBER = "TNUMBER";
+var TSTRING = "TSTRING";
+var TPAREN = "TPAREN";
+var TBRACKET = "TBRACKET";
+var TCOMMA = "TCOMMA";
+var TNAME = "TNAME";
+var TSEMICOLON = "TSEMICOLON";
+function Token(type, value, index2) {
+  this.type = type;
+  this.value = value;
+  this.index = index2;
+}
+Token.prototype.toString = function() {
+  return this.type + ": " + this.value;
+};
+function TokenStream(parser, expression) {
+  this.pos = 0;
+  this.current = null;
+  this.unaryOps = parser.unaryOps;
+  this.binaryOps = parser.binaryOps;
+  this.ternaryOps = parser.ternaryOps;
+  this.consts = parser.consts;
+  this.expression = expression;
+  this.savedPosition = 0;
+  this.savedCurrent = null;
+  this.options = parser.options;
+  this.parser = parser;
+}
+TokenStream.prototype.newToken = function(type, value, pos) {
+  return new Token(type, value, pos != null ? pos : this.pos);
+};
+TokenStream.prototype.save = function() {
+  this.savedPosition = this.pos;
+  this.savedCurrent = this.current;
+};
+TokenStream.prototype.restore = function() {
+  this.pos = this.savedPosition;
+  this.current = this.savedCurrent;
+};
+TokenStream.prototype.next = function() {
+  if (this.pos >= this.expression.length) {
+    return this.newToken(TEOF, "EOF");
+  }
+  if (this.isWhitespace() || this.isComment()) {
+    return this.next();
+  } else if (this.isRadixInteger() || this.isNumber() || this.isOperator() || this.isString() || this.isParen() || this.isBracket() || this.isComma() || this.isSemicolon() || this.isNamedOp() || this.isConst() || this.isName()) {
+    return this.current;
+  } else {
+    this.parseError('Unknown character "' + this.expression.charAt(this.pos) + '"');
+  }
+};
+TokenStream.prototype.isString = function() {
+  var r = false;
+  var startPos = this.pos;
+  var quote = this.expression.charAt(startPos);
+  if (quote === "'" || quote === '"') {
+    var index2 = this.expression.indexOf(quote, startPos + 1);
+    while (index2 >= 0 && this.pos < this.expression.length) {
+      this.pos = index2 + 1;
+      if (this.expression.charAt(index2 - 1) !== "\\") {
+        var rawString = this.expression.substring(startPos + 1, index2);
+        this.current = this.newToken(TSTRING, this.unescape(rawString), startPos);
+        r = true;
+        break;
+      }
+      index2 = this.expression.indexOf(quote, index2 + 1);
+    }
+  }
+  return r;
+};
+TokenStream.prototype.isParen = function() {
+  var c = this.expression.charAt(this.pos);
+  if (c === "(" || c === ")") {
+    this.current = this.newToken(TPAREN, c);
+    this.pos++;
+    return true;
+  }
+  return false;
+};
+TokenStream.prototype.isBracket = function() {
+  var c = this.expression.charAt(this.pos);
+  if ((c === "[" || c === "]") && this.isOperatorEnabled("[")) {
+    this.current = this.newToken(TBRACKET, c);
+    this.pos++;
+    return true;
+  }
+  return false;
+};
+TokenStream.prototype.isComma = function() {
+  var c = this.expression.charAt(this.pos);
+  if (c === ",") {
+    this.current = this.newToken(TCOMMA, ",");
+    this.pos++;
+    return true;
+  }
+  return false;
+};
+TokenStream.prototype.isSemicolon = function() {
+  var c = this.expression.charAt(this.pos);
+  if (c === ";") {
+    this.current = this.newToken(TSEMICOLON, ";");
+    this.pos++;
+    return true;
+  }
+  return false;
+};
+TokenStream.prototype.isConst = function() {
+  var startPos = this.pos;
+  var i = startPos;
+  for (; i < this.expression.length; i++) {
+    var c = this.expression.charAt(i);
+    if (c.toUpperCase() === c.toLowerCase()) {
+      if (i === this.pos || c !== "_" && c !== "." && (c < "0" || c > "9")) {
+        break;
+      }
+    }
+  }
+  if (i > startPos) {
+    var str = this.expression.substring(startPos, i);
+    if (str in this.consts) {
+      this.current = this.newToken(TNUMBER, this.consts[str]);
+      this.pos += str.length;
+      return true;
+    }
+  }
+  return false;
+};
+TokenStream.prototype.isNamedOp = function() {
+  var startPos = this.pos;
+  var i = startPos;
+  for (; i < this.expression.length; i++) {
+    var c = this.expression.charAt(i);
+    if (c.toUpperCase() === c.toLowerCase()) {
+      if (i === this.pos || c !== "_" && (c < "0" || c > "9")) {
+        break;
+      }
+    }
+  }
+  if (i > startPos) {
+    var str = this.expression.substring(startPos, i);
+    if (this.isOperatorEnabled(str) && (str in this.binaryOps || str in this.unaryOps || str in this.ternaryOps)) {
+      this.current = this.newToken(TOP, str);
+      this.pos += str.length;
+      return true;
+    }
+  }
+  return false;
+};
+TokenStream.prototype.isName = function() {
+  var startPos = this.pos;
+  var i = startPos;
+  var hasLetter = false;
+  for (; i < this.expression.length; i++) {
+    var c = this.expression.charAt(i);
+    if (c.toUpperCase() === c.toLowerCase()) {
+      if (i === this.pos && (c === "$" || c === "_")) {
+        if (c === "_") {
+          hasLetter = true;
+        }
+        continue;
+      } else if (i === this.pos || !hasLetter || c !== "_" && (c < "0" || c > "9")) {
+        break;
+      }
+    } else {
+      hasLetter = true;
+    }
+  }
+  if (hasLetter) {
+    var str = this.expression.substring(startPos, i);
+    this.current = this.newToken(TNAME, str);
+    this.pos += str.length;
+    return true;
+  }
+  return false;
+};
+TokenStream.prototype.isWhitespace = function() {
+  var r = false;
+  var c = this.expression.charAt(this.pos);
+  while (c === " " || c === "	" || c === "\n" || c === "\r") {
+    r = true;
+    this.pos++;
+    if (this.pos >= this.expression.length) {
+      break;
+    }
+    c = this.expression.charAt(this.pos);
+  }
+  return r;
+};
+var codePointPattern = /^[0-9a-f]{4}$/i;
+TokenStream.prototype.unescape = function(v) {
+  var index2 = v.indexOf("\\");
+  if (index2 < 0) {
+    return v;
+  }
+  var buffer = v.substring(0, index2);
+  while (index2 >= 0) {
+    var c = v.charAt(++index2);
+    switch (c) {
+      case "'":
+        buffer += "'";
+        break;
+      case '"':
+        buffer += '"';
+        break;
+      case "\\":
+        buffer += "\\";
+        break;
+      case "/":
+        buffer += "/";
+        break;
+      case "b":
+        buffer += "\b";
+        break;
+      case "f":
+        buffer += "\f";
+        break;
+      case "n":
+        buffer += "\n";
+        break;
+      case "r":
+        buffer += "\r";
+        break;
+      case "t":
+        buffer += "	";
+        break;
+      case "u":
+        var codePoint = v.substring(index2 + 1, index2 + 5);
+        if (!codePointPattern.test(codePoint)) {
+          this.parseError("Illegal escape sequence: \\u" + codePoint);
+        }
+        buffer += String.fromCharCode(parseInt(codePoint, 16));
+        index2 += 4;
+        break;
+      default:
+        throw this.parseError('Illegal escape sequence: "\\' + c + '"');
+    }
+    ++index2;
+    var backslash = v.indexOf("\\", index2);
+    buffer += v.substring(index2, backslash < 0 ? v.length : backslash);
+    index2 = backslash;
+  }
+  return buffer;
+};
+TokenStream.prototype.isComment = function() {
+  var c = this.expression.charAt(this.pos);
+  if (c === "/" && this.expression.charAt(this.pos + 1) === "*") {
+    this.pos = this.expression.indexOf("*/", this.pos) + 2;
+    if (this.pos === 1) {
+      this.pos = this.expression.length;
+    }
+    return true;
+  }
+  return false;
+};
+TokenStream.prototype.isRadixInteger = function() {
+  var pos = this.pos;
+  if (pos >= this.expression.length - 2 || this.expression.charAt(pos) !== "0") {
+    return false;
+  }
+  ++pos;
+  var radix;
+  var validDigit;
+  if (this.expression.charAt(pos) === "x") {
+    radix = 16;
+    validDigit = /^[0-9a-f]$/i;
+    ++pos;
+  } else if (this.expression.charAt(pos) === "b") {
+    radix = 2;
+    validDigit = /^[01]$/i;
+    ++pos;
+  } else {
+    return false;
+  }
+  var valid = false;
+  var startPos = pos;
+  while (pos < this.expression.length) {
+    var c = this.expression.charAt(pos);
+    if (validDigit.test(c)) {
+      pos++;
+      valid = true;
+    } else {
+      break;
+    }
+  }
+  if (valid) {
+    this.current = this.newToken(TNUMBER, parseInt(this.expression.substring(startPos, pos), radix));
+    this.pos = pos;
+  }
+  return valid;
+};
+TokenStream.prototype.isNumber = function() {
+  var valid = false;
+  var pos = this.pos;
+  var startPos = pos;
+  var resetPos = pos;
+  var foundDot = false;
+  var foundDigits = false;
+  var c;
+  while (pos < this.expression.length) {
+    c = this.expression.charAt(pos);
+    if (c >= "0" && c <= "9" || !foundDot && c === ".") {
+      if (c === ".") {
+        foundDot = true;
+      } else {
+        foundDigits = true;
+      }
+      pos++;
+      valid = foundDigits;
+    } else {
+      break;
+    }
+  }
+  if (valid) {
+    resetPos = pos;
+  }
+  if (c === "e" || c === "E") {
+    pos++;
+    var acceptSign = true;
+    var validExponent = false;
+    while (pos < this.expression.length) {
+      c = this.expression.charAt(pos);
+      if (acceptSign && (c === "+" || c === "-")) {
+        acceptSign = false;
+      } else if (c >= "0" && c <= "9") {
+        validExponent = true;
+        acceptSign = false;
+      } else {
+        break;
+      }
+      pos++;
+    }
+    if (!validExponent) {
+      pos = resetPos;
+    }
+  }
+  if (valid) {
+    this.current = this.newToken(TNUMBER, parseFloat(this.expression.substring(startPos, pos)));
+    this.pos = pos;
+  } else {
+    this.pos = resetPos;
+  }
+  return valid;
+};
+TokenStream.prototype.isOperator = function() {
+  var startPos = this.pos;
+  var c = this.expression.charAt(this.pos);
+  if (c === "+" || c === "-" || c === "*" || c === "/" || c === "%" || c === "^" || c === "?" || c === ":" || c === ".") {
+    this.current = this.newToken(TOP, c);
+  } else if (c === "∙" || c === "•") {
+    this.current = this.newToken(TOP, "*");
+  } else if (c === ">") {
+    if (this.expression.charAt(this.pos + 1) === "=") {
+      this.current = this.newToken(TOP, ">=");
+      this.pos++;
+    } else {
+      this.current = this.newToken(TOP, ">");
+    }
+  } else if (c === "<") {
+    if (this.expression.charAt(this.pos + 1) === "=") {
+      this.current = this.newToken(TOP, "<=");
+      this.pos++;
+    } else {
+      this.current = this.newToken(TOP, "<");
+    }
+  } else if (c === "|") {
+    if (this.expression.charAt(this.pos + 1) === "|") {
+      this.current = this.newToken(TOP, "||");
+      this.pos++;
+    } else {
+      return false;
+    }
+  } else if (c === "=") {
+    if (this.expression.charAt(this.pos + 1) === "=") {
+      this.current = this.newToken(TOP, "==");
+      this.pos++;
+    } else {
+      this.current = this.newToken(TOP, c);
+    }
+  } else if (c === "!") {
+    if (this.expression.charAt(this.pos + 1) === "=") {
+      this.current = this.newToken(TOP, "!=");
+      this.pos++;
+    } else {
+      this.current = this.newToken(TOP, c);
+    }
+  } else {
+    return false;
+  }
+  this.pos++;
+  if (this.isOperatorEnabled(this.current.value)) {
+    return true;
+  } else {
+    this.pos = startPos;
+    return false;
+  }
+};
+TokenStream.prototype.isOperatorEnabled = function(op) {
+  return this.parser.isOperatorEnabled(op);
+};
+TokenStream.prototype.getCoordinates = function() {
+  var line = 0;
+  var column;
+  var newline = -1;
+  do {
+    line++;
+    column = this.pos - newline;
+    newline = this.expression.indexOf("\n", newline + 1);
+  } while (newline >= 0 && newline < this.pos);
+  return {
+    line,
+    column
+  };
+};
+TokenStream.prototype.parseError = function(msg) {
+  var coords = this.getCoordinates();
+  throw new Error("parse error [" + coords.line + ":" + coords.column + "]: " + msg);
+};
+function ParserState(parser, tokenStream, options) {
+  this.parser = parser;
+  this.tokens = tokenStream;
+  this.current = null;
+  this.nextToken = null;
+  this.next();
+  this.savedCurrent = null;
+  this.savedNextToken = null;
+  this.allowMemberAccess = options.allowMemberAccess !== false;
+}
+ParserState.prototype.next = function() {
+  this.current = this.nextToken;
+  return this.nextToken = this.tokens.next();
+};
+ParserState.prototype.tokenMatches = function(token, value) {
+  if (typeof value === "undefined") {
+    return true;
+  } else if (Array.isArray(value)) {
+    return contains(value, token.value);
+  } else if (typeof value === "function") {
+    return value(token);
+  } else {
+    return token.value === value;
+  }
+};
+ParserState.prototype.save = function() {
+  this.savedCurrent = this.current;
+  this.savedNextToken = this.nextToken;
+  this.tokens.save();
+};
+ParserState.prototype.restore = function() {
+  this.tokens.restore();
+  this.current = this.savedCurrent;
+  this.nextToken = this.savedNextToken;
+};
+ParserState.prototype.accept = function(type, value) {
+  if (this.nextToken.type === type && this.tokenMatches(this.nextToken, value)) {
+    this.next();
+    return true;
+  }
+  return false;
+};
+ParserState.prototype.expect = function(type, value) {
+  if (!this.accept(type, value)) {
+    var coords = this.tokens.getCoordinates();
+    throw new Error("parse error [" + coords.line + ":" + coords.column + "]: Expected " + (value || type));
+  }
+};
+ParserState.prototype.parseAtom = function(instr) {
+  var unaryOps = this.tokens.unaryOps;
+  function isPrefixOperator(token) {
+    return token.value in unaryOps;
+  }
+  if (this.accept(TNAME) || this.accept(TOP, isPrefixOperator)) {
+    instr.push(new Instruction(IVAR, this.current.value));
+  } else if (this.accept(TNUMBER)) {
+    instr.push(new Instruction(INUMBER, this.current.value));
+  } else if (this.accept(TSTRING)) {
+    instr.push(new Instruction(INUMBER, this.current.value));
+  } else if (this.accept(TPAREN, "(")) {
+    this.parseExpression(instr);
+    this.expect(TPAREN, ")");
+  } else if (this.accept(TBRACKET, "[")) {
+    if (this.accept(TBRACKET, "]")) {
+      instr.push(new Instruction(IARRAY, 0));
+    } else {
+      var argCount = this.parseArrayList(instr);
+      instr.push(new Instruction(IARRAY, argCount));
+    }
+  } else {
+    throw new Error("unexpected " + this.nextToken);
+  }
+};
+ParserState.prototype.parseExpression = function(instr) {
+  var exprInstr = [];
+  if (this.parseUntilEndStatement(instr, exprInstr)) {
+    return;
+  }
+  this.parseVariableAssignmentExpression(exprInstr);
+  if (this.parseUntilEndStatement(instr, exprInstr)) {
+    return;
+  }
+  this.pushExpression(instr, exprInstr);
+};
+ParserState.prototype.pushExpression = function(instr, exprInstr) {
+  for (var i = 0, len = exprInstr.length; i < len; i++) {
+    instr.push(exprInstr[i]);
+  }
+};
+ParserState.prototype.parseUntilEndStatement = function(instr, exprInstr) {
+  if (!this.accept(TSEMICOLON)) return false;
+  if (this.nextToken && this.nextToken.type !== TEOF && !(this.nextToken.type === TPAREN && this.nextToken.value === ")")) {
+    exprInstr.push(new Instruction(IENDSTATEMENT));
+  }
+  if (this.nextToken.type !== TEOF) {
+    this.parseExpression(exprInstr);
+  }
+  instr.push(new Instruction(IEXPR, exprInstr));
+  return true;
+};
+ParserState.prototype.parseArrayList = function(instr) {
+  var argCount = 0;
+  while (!this.accept(TBRACKET, "]")) {
+    this.parseExpression(instr);
+    ++argCount;
+    while (this.accept(TCOMMA)) {
+      this.parseExpression(instr);
+      ++argCount;
+    }
+  }
+  return argCount;
+};
+ParserState.prototype.parseVariableAssignmentExpression = function(instr) {
+  this.parseConditionalExpression(instr);
+  while (this.accept(TOP, "=")) {
+    var varName = instr.pop();
+    var varValue = [];
+    var lastInstrIndex = instr.length - 1;
+    if (varName.type === IFUNCALL) {
+      if (!this.tokens.isOperatorEnabled("()=")) {
+        throw new Error("function definition is not permitted");
+      }
+      for (var i = 0, len = varName.value + 1; i < len; i++) {
+        var index2 = lastInstrIndex - i;
+        if (instr[index2].type === IVAR) {
+          instr[index2] = new Instruction(IVARNAME, instr[index2].value);
+        }
+      }
+      this.parseVariableAssignmentExpression(varValue);
+      instr.push(new Instruction(IEXPR, varValue));
+      instr.push(new Instruction(IFUNDEF, varName.value));
+      continue;
+    }
+    if (varName.type !== IVAR && varName.type !== IMEMBER) {
+      throw new Error("expected variable for assignment");
+    }
+    this.parseVariableAssignmentExpression(varValue);
+    instr.push(new Instruction(IVARNAME, varName.value));
+    instr.push(new Instruction(IEXPR, varValue));
+    instr.push(binaryInstruction("="));
+  }
+};
+ParserState.prototype.parseConditionalExpression = function(instr) {
+  this.parseOrExpression(instr);
+  while (this.accept(TOP, "?")) {
+    var trueBranch = [];
+    var falseBranch = [];
+    this.parseConditionalExpression(trueBranch);
+    this.expect(TOP, ":");
+    this.parseConditionalExpression(falseBranch);
+    instr.push(new Instruction(IEXPR, trueBranch));
+    instr.push(new Instruction(IEXPR, falseBranch));
+    instr.push(ternaryInstruction("?"));
+  }
+};
+ParserState.prototype.parseOrExpression = function(instr) {
+  this.parseAndExpression(instr);
+  while (this.accept(TOP, "or")) {
+    var falseBranch = [];
+    this.parseAndExpression(falseBranch);
+    instr.push(new Instruction(IEXPR, falseBranch));
+    instr.push(binaryInstruction("or"));
+  }
+};
+ParserState.prototype.parseAndExpression = function(instr) {
+  this.parseComparison(instr);
+  while (this.accept(TOP, "and")) {
+    var trueBranch = [];
+    this.parseComparison(trueBranch);
+    instr.push(new Instruction(IEXPR, trueBranch));
+    instr.push(binaryInstruction("and"));
+  }
+};
+var COMPARISON_OPERATORS = ["==", "!=", "<", "<=", ">=", ">", "in"];
+ParserState.prototype.parseComparison = function(instr) {
+  this.parseAddSub(instr);
+  while (this.accept(TOP, COMPARISON_OPERATORS)) {
+    var op = this.current;
+    this.parseAddSub(instr);
+    instr.push(binaryInstruction(op.value));
+  }
+};
+var ADD_SUB_OPERATORS = ["+", "-", "||"];
+ParserState.prototype.parseAddSub = function(instr) {
+  this.parseTerm(instr);
+  while (this.accept(TOP, ADD_SUB_OPERATORS)) {
+    var op = this.current;
+    this.parseTerm(instr);
+    instr.push(binaryInstruction(op.value));
+  }
+};
+var TERM_OPERATORS = ["*", "/", "%"];
+ParserState.prototype.parseTerm = function(instr) {
+  this.parseFactor(instr);
+  while (this.accept(TOP, TERM_OPERATORS)) {
+    var op = this.current;
+    this.parseFactor(instr);
+    instr.push(binaryInstruction(op.value));
+  }
+};
+ParserState.prototype.parseFactor = function(instr) {
+  var unaryOps = this.tokens.unaryOps;
+  function isPrefixOperator(token) {
+    return token.value in unaryOps;
+  }
+  this.save();
+  if (this.accept(TOP, isPrefixOperator)) {
+    if (this.current.value !== "-" && this.current.value !== "+") {
+      if (this.nextToken.type === TPAREN && this.nextToken.value === "(") {
+        this.restore();
+        this.parseExponential(instr);
+        return;
+      } else if (this.nextToken.type === TSEMICOLON || this.nextToken.type === TCOMMA || this.nextToken.type === TEOF || this.nextToken.type === TPAREN && this.nextToken.value === ")") {
+        this.restore();
+        this.parseAtom(instr);
+        return;
+      }
+    }
+    var op = this.current;
+    this.parseFactor(instr);
+    instr.push(unaryInstruction(op.value));
+  } else {
+    this.parseExponential(instr);
+  }
+};
+ParserState.prototype.parseExponential = function(instr) {
+  this.parsePostfixExpression(instr);
+  while (this.accept(TOP, "^")) {
+    this.parseFactor(instr);
+    instr.push(binaryInstruction("^"));
+  }
+};
+ParserState.prototype.parsePostfixExpression = function(instr) {
+  this.parseFunctionCall(instr);
+  while (this.accept(TOP, "!")) {
+    instr.push(unaryInstruction("!"));
+  }
+};
+ParserState.prototype.parseFunctionCall = function(instr) {
+  var unaryOps = this.tokens.unaryOps;
+  function isPrefixOperator(token) {
+    return token.value in unaryOps;
+  }
+  if (this.accept(TOP, isPrefixOperator)) {
+    var op = this.current;
+    this.parseAtom(instr);
+    instr.push(unaryInstruction(op.value));
+  } else {
+    this.parseMemberExpression(instr);
+    while (this.accept(TPAREN, "(")) {
+      if (this.accept(TPAREN, ")")) {
+        instr.push(new Instruction(IFUNCALL, 0));
+      } else {
+        var argCount = this.parseArgumentList(instr);
+        instr.push(new Instruction(IFUNCALL, argCount));
+      }
+    }
+  }
+};
+ParserState.prototype.parseArgumentList = function(instr) {
+  var argCount = 0;
+  while (!this.accept(TPAREN, ")")) {
+    this.parseExpression(instr);
+    ++argCount;
+    while (this.accept(TCOMMA)) {
+      this.parseExpression(instr);
+      ++argCount;
+    }
+  }
+  return argCount;
+};
+ParserState.prototype.parseMemberExpression = function(instr) {
+  this.parseAtom(instr);
+  while (this.accept(TOP, ".") || this.accept(TBRACKET, "[")) {
+    var op = this.current;
+    if (op.value === ".") {
+      if (!this.allowMemberAccess) {
+        throw new Error('unexpected ".", member access is not permitted');
+      }
+      this.expect(TNAME);
+      instr.push(new Instruction(IMEMBER, this.current.value));
+    } else if (op.value === "[") {
+      if (!this.tokens.isOperatorEnabled("[")) {
+        throw new Error('unexpected "[]", arrays are disabled');
+      }
+      this.parseExpression(instr);
+      this.expect(TBRACKET, "]");
+      instr.push(binaryInstruction("["));
+    } else {
+      throw new Error("unexpected symbol: " + op.value);
+    }
+  }
+};
+function add(a, b) {
+  return Number(a) + Number(b);
+}
+function sub(a, b) {
+  return a - b;
+}
+function mul(a, b) {
+  return a * b;
+}
+function div(a, b) {
+  return a / b;
+}
+function mod(a, b) {
+  return a % b;
+}
+function concat(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.concat(b);
+  }
+  return "" + a + b;
+}
+function equal(a, b) {
+  return a === b;
+}
+function notEqual(a, b) {
+  return a !== b;
+}
+function greaterThan(a, b) {
+  return a > b;
+}
+function lessThan(a, b) {
+  return a < b;
+}
+function greaterThanEqual(a, b) {
+  return a >= b;
+}
+function lessThanEqual(a, b) {
+  return a <= b;
+}
+function andOperator(a, b) {
+  return Boolean(a && b);
+}
+function orOperator(a, b) {
+  return Boolean(a || b);
+}
+function inOperator(a, b) {
+  return contains(b, a);
+}
+function sinh(a) {
+  return (Math.exp(a) - Math.exp(-a)) / 2;
+}
+function cosh(a) {
+  return (Math.exp(a) + Math.exp(-a)) / 2;
+}
+function tanh(a) {
+  if (a === Infinity) return 1;
+  if (a === -Infinity) return -1;
+  return (Math.exp(a) - Math.exp(-a)) / (Math.exp(a) + Math.exp(-a));
+}
+function asinh(a) {
+  if (a === -Infinity) return a;
+  return Math.log(a + Math.sqrt(a * a + 1));
+}
+function acosh(a) {
+  return Math.log(a + Math.sqrt(a * a - 1));
+}
+function atanh(a) {
+  return Math.log((1 + a) / (1 - a)) / 2;
+}
+function log10(a) {
+  return Math.log(a) * Math.LOG10E;
+}
+function neg(a) {
+  return -a;
+}
+function not(a) {
+  return !a;
+}
+function trunc(a) {
+  return a < 0 ? Math.ceil(a) : Math.floor(a);
+}
+function random(a) {
+  return Math.random() * (a || 1);
+}
+function factorial(a) {
+  return gamma(a + 1);
+}
+function isInteger(value) {
+  return isFinite(value) && value === Math.round(value);
+}
+var GAMMA_G = 4.7421875;
+var GAMMA_P = [
+  0.9999999999999971,
+  57.15623566586292,
+  -59.59796035547549,
+  14.136097974741746,
+  -0.4919138160976202,
+  3399464998481189e-20,
+  4652362892704858e-20,
+  -9837447530487956e-20,
+  1580887032249125e-19,
+  -21026444172410488e-20,
+  21743961811521265e-20,
+  -1643181065367639e-19,
+  8441822398385275e-20,
+  -26190838401581408e-21,
+  36899182659531625e-22
+];
+function gamma(n) {
+  var t, x2;
+  if (isInteger(n)) {
+    if (n <= 0) {
+      return isFinite(n) ? Infinity : NaN;
+    }
+    if (n > 171) {
+      return Infinity;
+    }
+    var value = n - 2;
+    var res = n - 1;
+    while (value > 1) {
+      res *= value;
+      value--;
+    }
+    if (res === 0) {
+      res = 1;
+    }
+    return res;
+  }
+  if (n < 0.5) {
+    return Math.PI / (Math.sin(Math.PI * n) * gamma(1 - n));
+  }
+  if (n >= 171.35) {
+    return Infinity;
+  }
+  if (n > 85) {
+    var twoN = n * n;
+    var threeN = twoN * n;
+    var fourN = threeN * n;
+    var fiveN = fourN * n;
+    return Math.sqrt(2 * Math.PI / n) * Math.pow(n / Math.E, n) * (1 + 1 / (12 * n) + 1 / (288 * twoN) - 139 / (51840 * threeN) - 571 / (2488320 * fourN) + 163879 / (209018880 * fiveN) + 5246819 / (75246796800 * fiveN * n));
+  }
+  --n;
+  x2 = GAMMA_P[0];
+  for (var i = 1; i < GAMMA_P.length; ++i) {
+    x2 += GAMMA_P[i] / (n + i);
+  }
+  t = n + GAMMA_G + 0.5;
+  return Math.sqrt(2 * Math.PI) * Math.pow(t, n + 0.5) * Math.exp(-t) * x2;
+}
+function stringOrArrayLength(s) {
+  if (Array.isArray(s)) {
+    return s.length;
+  }
+  return String(s).length;
+}
+function hypot() {
+  var sum = 0;
+  var larg = 0;
+  for (var i = 0; i < arguments.length; i++) {
+    var arg = Math.abs(arguments[i]);
+    var div2;
+    if (larg < arg) {
+      div2 = larg / arg;
+      sum = sum * div2 * div2 + 1;
+      larg = arg;
+    } else if (arg > 0) {
+      div2 = arg / larg;
+      sum += div2 * div2;
+    } else {
+      sum += arg;
+    }
+  }
+  return larg === Infinity ? Infinity : larg * Math.sqrt(sum);
+}
+function condition(cond, yep, nope) {
+  return cond ? yep : nope;
+}
+function roundTo(value, exp) {
+  if (typeof exp === "undefined" || +exp === 0) {
+    return Math.round(value);
+  }
+  value = +value;
+  exp = -+exp;
+  if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
+    return NaN;
+  }
+  value = value.toString().split("e");
+  value = Math.round(+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
+  value = value.toString().split("e");
+  return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
+}
+function setVar(name, value, variables) {
+  if (variables) variables[name] = value;
+  return value;
+}
+function arrayIndex(array2, index2) {
+  return array2[index2 | 0];
+}
+function max(array2) {
+  if (arguments.length === 1 && Array.isArray(array2)) {
+    return Math.max.apply(Math, array2);
+  } else {
+    return Math.max.apply(Math, arguments);
+  }
+}
+function min(array2) {
+  if (arguments.length === 1 && Array.isArray(array2)) {
+    return Math.min.apply(Math, array2);
+  } else {
+    return Math.min.apply(Math, arguments);
+  }
+}
+function arrayMap(f, a) {
+  if (typeof f !== "function") {
+    throw new Error("First argument to map is not a function");
+  }
+  if (!Array.isArray(a)) {
+    throw new Error("Second argument to map is not an array");
+  }
+  return a.map(function(x2, i) {
+    return f(x2, i);
+  });
+}
+function arrayFold(f, init, a) {
+  if (typeof f !== "function") {
+    throw new Error("First argument to fold is not a function");
+  }
+  if (!Array.isArray(a)) {
+    throw new Error("Second argument to fold is not an array");
+  }
+  return a.reduce(function(acc, x2, i) {
+    return f(acc, x2, i);
+  }, init);
+}
+function arrayFilter(f, a) {
+  if (typeof f !== "function") {
+    throw new Error("First argument to filter is not a function");
+  }
+  if (!Array.isArray(a)) {
+    throw new Error("Second argument to filter is not an array");
+  }
+  return a.filter(function(x2, i) {
+    return f(x2, i);
+  });
+}
+function stringOrArrayIndexOf(target, s) {
+  if (!(Array.isArray(s) || typeof s === "string")) {
+    throw new Error("Second argument to indexOf is not a string or array");
+  }
+  return s.indexOf(target);
+}
+function arrayJoin(sep, a) {
+  if (!Array.isArray(a)) {
+    throw new Error("Second argument to join is not an array");
+  }
+  return a.join(sep);
+}
+function sign(x2) {
+  return (x2 > 0) - (x2 < 0) || +x2;
+}
+var ONE_THIRD = 1 / 3;
+function cbrt(x2) {
+  return x2 < 0 ? -Math.pow(-x2, ONE_THIRD) : Math.pow(x2, ONE_THIRD);
+}
+function expm1(x2) {
+  return Math.exp(x2) - 1;
+}
+function log1p(x2) {
+  return Math.log(1 + x2);
+}
+function log2(x2) {
+  return Math.log(x2) / Math.LN2;
+}
+function Parser(options) {
+  this.options = options || {};
+  this.unaryOps = {
+    sin: Math.sin,
+    cos: Math.cos,
+    tan: Math.tan,
+    asin: Math.asin,
+    acos: Math.acos,
+    atan: Math.atan,
+    sinh: Math.sinh || sinh,
+    cosh: Math.cosh || cosh,
+    tanh: Math.tanh || tanh,
+    asinh: Math.asinh || asinh,
+    acosh: Math.acosh || acosh,
+    atanh: Math.atanh || atanh,
+    sqrt: Math.sqrt,
+    cbrt: Math.cbrt || cbrt,
+    log: Math.log,
+    log2: Math.log2 || log2,
+    ln: Math.log,
+    lg: Math.log10 || log10,
+    log10: Math.log10 || log10,
+    expm1: Math.expm1 || expm1,
+    log1p: Math.log1p || log1p,
+    abs: Math.abs,
+    ceil: Math.ceil,
+    floor: Math.floor,
+    round: Math.round,
+    trunc: Math.trunc || trunc,
+    "-": neg,
+    "+": Number,
+    exp: Math.exp,
+    not,
+    length: stringOrArrayLength,
+    "!": factorial,
+    sign: Math.sign || sign
+  };
+  this.binaryOps = {
+    "+": add,
+    "-": sub,
+    "*": mul,
+    "/": div,
+    "%": mod,
+    "^": Math.pow,
+    "||": concat,
+    "==": equal,
+    "!=": notEqual,
+    ">": greaterThan,
+    "<": lessThan,
+    ">=": greaterThanEqual,
+    "<=": lessThanEqual,
+    and: andOperator,
+    or: orOperator,
+    "in": inOperator,
+    "=": setVar,
+    "[": arrayIndex
+  };
+  this.ternaryOps = {
+    "?": condition
+  };
+  this.functions = {
+    random,
+    fac: factorial,
+    min,
+    max,
+    hypot: Math.hypot || hypot,
+    pyt: Math.hypot || hypot,
+    // backward compat
+    pow: Math.pow,
+    atan2: Math.atan2,
+    "if": condition,
+    gamma,
+    roundTo,
+    map: arrayMap,
+    fold: arrayFold,
+    filter: arrayFilter,
+    indexOf: stringOrArrayIndexOf,
+    join: arrayJoin
+  };
+  this.consts = {
+    E: Math.E,
+    PI: Math.PI,
+    "true": true,
+    "false": false
+  };
+}
+Parser.prototype.parse = function(expr) {
+  var instr = [];
+  var parserState = new ParserState(
+    this,
+    new TokenStream(this, expr),
+    { allowMemberAccess: this.options.allowMemberAccess }
+  );
+  parserState.parseExpression(instr);
+  parserState.expect(TEOF, "EOF");
+  return new Expression(instr, this);
+};
+Parser.prototype.evaluate = function(expr, variables) {
+  return this.parse(expr).evaluate(variables);
+};
+var sharedParser = new Parser();
+Parser.parse = function(expr) {
+  return sharedParser.parse(expr);
+};
+Parser.evaluate = function(expr, variables) {
+  return sharedParser.parse(expr).evaluate(variables);
+};
+var optionNameMap = {
+  "+": "add",
+  "-": "subtract",
+  "*": "multiply",
+  "/": "divide",
+  "%": "remainder",
+  "^": "power",
+  "!": "factorial",
+  "<": "comparison",
+  ">": "comparison",
+  "<=": "comparison",
+  ">=": "comparison",
+  "==": "comparison",
+  "!=": "comparison",
+  "||": "concatenate",
+  "and": "logical",
+  "or": "logical",
+  "not": "logical",
+  "?": "conditional",
+  ":": "conditional",
+  "=": "assignment",
+  "[": "array",
+  "()=": "fndef"
+};
+function getOptionName(op) {
+  return optionNameMap.hasOwnProperty(op) ? optionNameMap[op] : op;
+}
+Parser.prototype.isOperatorEnabled = function(op) {
+  var optionName = getOptionName(op);
+  var operators = this.options.operators || {};
+  return !(optionName in operators) || !!operators[optionName];
+};
 const _hoisted_1$t = {
   key: 0,
   class: "lew-label-box"
@@ -19579,7 +21183,6 @@ const _sfc_main$F = /* @__PURE__ */ defineComponent({
     const emit = __emit;
     const formSchema = inject("formSchema", ref(null));
     const formData = inject("formData", ref({}));
-    const formUpdateKey = inject("formUpdateKey", ref(0));
     const asMap = {
       "input": LewInput,
       "textarea": LewTextarea,
@@ -19676,38 +21279,22 @@ const _sfc_main$F = /* @__PURE__ */ defineComponent({
         justifyContent: direction === "x" && between ? "flex-end" : "flex-start"
       };
     });
-    const getVisible = computed(() => {
-      if (typeof props.visible === "function") {
-        return props.visible(formData.value);
-      }
-      return props.visible;
-    });
-    const getDisabled = computed(() => {
-      if (typeof props.disabled === "function") {
-        return props.disabled(formData.value);
-      }
-      return props.disabled;
-    });
-    const getReadonly = computed(() => {
-      if (typeof props.readonly === "function") {
-        return props.readonly(formData.value);
-      }
-      return props.readonly;
-    });
     const getDynamicProps = computed(() => {
       if (typeof props.props === "function") {
         return props.props(formData.value);
       }
       return props.props;
     });
-    watchEffect(() => {
-      formUpdateKey.value;
-      formData.value;
-    });
+    function runFunc(func) {
+      if (typeof func === "function") {
+        return func(formData.value);
+      }
+      return func;
+    }
     __expose({ validate, setError, setIgnoreValidate });
     return (_ctx, _cache) => {
       const _directive_tooltip = resolveDirective("tooltip");
-      return unref(getVisible) ? (openBlock(), createElementBlock("div", {
+      return runFunc(_ctx.visible) ? (openBlock(), createElementBlock("div", {
         key: 0,
         ref_key: "formItemRef",
         ref: formItemRef,
@@ -19747,8 +21334,8 @@ const _sfc_main$F = /* @__PURE__ */ defineComponent({
             "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => modelValue.value = $event)
           }, {
             size: _ctx.size,
-            readonly: unref(getReadonly),
-            disabled: unref(getDisabled),
+            readonly: runFunc(_ctx.readonly),
+            disabled: runFunc(_ctx.disabled),
             ...unref(getDynamicProps),
             width: _ctx.as && ["input-number", "tabs", "button"].includes(_ctx.as) ? unref(getDynamicProps).width : "100%",
             popoverWidth: _ctx.as && ["select"].includes(_ctx.as) ? "100%" : void 0
@@ -19769,7 +21356,7 @@ const _sfc_main$F = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewFormItem = /* @__PURE__ */ _export_sfc(_sfc_main$F, [["__scopeId", "data-v-83ae1c96"]]);
+const LewFormItem = /* @__PURE__ */ _export_sfc(_sfc_main$F, [["__scopeId", "data-v-32907163"]]);
 const _sfc_main$E = /* @__PURE__ */ defineComponent({
   __name: "LewForm",
   props: formProps,
@@ -19780,11 +21367,27 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({
     const formMap = ref({});
     const formLabelRef = ref();
     const autoLabelWidth = ref(0);
-    const componentOptions = cloneDeep(props.options) || [];
+    const componentOptions = ref(props.options);
     const formItemRefMap = ref({});
-    const formUpdateKey = ref(0);
+    const parser = new Parser();
+    function normalizeProp(value) {
+      return (formData) => {
+        if (typeof value === "function") {
+          return value(formData);
+        }
+        if (typeof value === "string") {
+          try {
+            console.log(formData);
+            return Boolean(parser.evaluate(value, formData));
+          } catch {
+            return false;
+          }
+        }
+        return Boolean(value);
+      };
+    }
     const formSchema = computed(() => {
-      const schemaMap = componentOptions.reduce((acc, item) => {
+      const schemaMap = componentOptions.value.reduce((acc, item) => {
         if (item.field && item.rule) {
           acc[item.field] = typeof item.rule === "string" ? new Function("Yup", `return ${item.rule}`)(Yup) : item.rule;
         }
@@ -19798,7 +21401,7 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({
     }));
     function getForm() {
       let formData = formatFormByMap(toRaw(formMap.value));
-      componentOptions.forEach((item) => {
+      componentOptions.value.forEach((item) => {
         if (item.outputFormat && item.field && formData[item.field]) {
           const _value = item.outputFormat({ item, value: formData[item.field] });
           if (typeof _value === "object" && !Array.isArray(_value)) {
@@ -19812,7 +21415,7 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({
       return formData;
     }
     function setForm(value = {}) {
-      componentOptions.forEach((item) => {
+      componentOptions.value.forEach((item) => {
         if (!item.field)
           return;
         let v = retrieveNestedFieldValue(value, item.field);
@@ -19824,7 +21427,7 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({
       });
     }
     function resetError() {
-      componentOptions.forEach((item) => item.field && resetFieldError(item.field));
+      componentOptions.value.forEach((item) => item.field && resetFieldError(item.field));
     }
     function resetFieldError(field, ignore = false) {
       const ref2 = formItemRefMap.value[field];
@@ -19852,18 +21455,10 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({
     provide("formMethods", props.formMethods);
     provide("formSchema", formSchema);
     provide("formData", formMap);
-    provide("formUpdateKey", formUpdateKey);
     watch(
       () => props.size,
       () => nextTick(() => autoLabelWidth.value = formLabelRef.value?.getWidth())
     );
-    watch(
-      () => formMap.value,
-      () => {
-        formUpdateKey.value++;
-      },
-      { deep: true }
-    );
     const GAP_MAP = {
       small: "24px",
       medium: "26px",
@@ -19906,9 +21501,10 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({
             direction: _ctx.direction,
             size: _ctx.size,
             labelWidth: unref(getLabelWidth),
-            disabled: _ctx.disabled,
-            readonly: _ctx.readonly,
             ...item,
+            disabled: item.disabled ? normalizeProp(item.disabled) : () => Boolean(_ctx.disabled),
+            readonly: item.readonly ? normalizeProp(item.readonly) : () => Boolean(_ctx.readonly),
+            visible: item.visible === void 0 ? () => true : normalizeProp(item.visible),
             required: unref(getFormItemRequired)(item)
           }, {
             onChange: _cache[0] || (_cache[0] = () => emit("change", getForm()))
@@ -19918,7 +21514,7 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewForm = /* @__PURE__ */ _export_sfc(_sfc_main$E, [["__scopeId", "data-v-2eb97031"]]);
+const LewForm = /* @__PURE__ */ _export_sfc(_sfc_main$E, [["__scopeId", "data-v-2babc77a"]]);
 const inputEmits = {
   change: (value) => value,
   input: (value) => value,
@@ -20693,11 +22289,11 @@ const _sfc_main$C = /* @__PURE__ */ defineComponent({
     }
     function plus() {
       lewInputRef.value.stepUp();
-      modelValue.value = lewInputRef.value.value;
+      modelValue.value = Number(lewInputRef.value.value);
       longClickTimer.value = setTimeout(() => {
         longClickTimer.value = setInterval(() => {
           lewInputRef.value.stepUp();
-          modelValue.value = lewInputRef.value.value;
+          modelValue.value = Number(lewInputRef.value.value);
           emit("change", cloneDeep(modelValue.value));
           if (props.max !== void 0 && lewInputRef.value.value >= Number(props.max || 0)) {
             clearTimer();
@@ -20707,11 +22303,11 @@ const _sfc_main$C = /* @__PURE__ */ defineComponent({
     }
     function minus() {
       lewInputRef.value.stepDown();
-      modelValue.value = lewInputRef.value.value;
+      modelValue.value = Number(lewInputRef.value.value);
       longClickTimer.value = setTimeout(() => {
         longClickTimer.value = setInterval(() => {
           lewInputRef.value.stepDown();
-          modelValue.value = lewInputRef.value.value;
+          modelValue.value = Number(lewInputRef.value.value);
           emit("change", cloneDeep(modelValue.value));
           if (props.min !== void 0 && lewInputRef.value.value <= Number(props.min || 0)) {
             clearTimer();
@@ -20791,7 +22387,7 @@ const _sfc_main$C = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewInputNumber = /* @__PURE__ */ _export_sfc(_sfc_main$C, [["__scopeId", "data-v-a92b8be3"]]);
+const LewInputNumber = /* @__PURE__ */ _export_sfc(_sfc_main$C, [["__scopeId", "data-v-3760ac9e"]]);
 const inputTableEmits = {
   change: (value) => value
 };
@@ -21162,7 +22758,7 @@ const _sfc_main$A = /* @__PURE__ */ defineComponent({
         }
       });
     }
-    function add() {
+    function add2() {
       if ((modelValue.value || []).length >= props.maxRows) {
         LewMessage.warning(locale.t("inputTable.maxRows"));
         return;
@@ -21260,7 +22856,7 @@ const _sfc_main$A = /* @__PURE__ */ defineComponent({
                     y: "center",
                     class: normalizeClass(["add-btn", { disabled: unref(isMaxRowsReached) }]),
                     style: normalizeStyle(unref(styleConfig).addButtonStyle),
-                    onClick: add
+                    onClick: add2
                   }, {
                     default: withCtx(() => [
                       createVNode(CommonIcon, {
@@ -21443,9 +23039,7 @@ const _sfc_main$z = /* @__PURE__ */ defineComponent({
         return;
       try {
         if (props.maxLength > 0 && Array.isArray(modelValue.value) && modelValue.value.length >= props.maxLength) {
-          LewMessage.warning(
-            locale.t("inputTag.maxLength", { maxLength: props.maxLength })
-          );
+          LewMessage.warning(locale.t("inputTag.maxLength", { maxLength: props.maxLength }));
           return;
         }
         isInputActive.value = true;
@@ -21526,9 +23120,7 @@ const _sfc_main$z = /* @__PURE__ */ defineComponent({
         if (props.maxLength > 0 && _value.length >= props.maxLength) {
           inputValue.value = "";
           isInputActive.value = false;
-          LewMessage.warning(
-            locale.t("inputTag.maxLength", { maxLength: props.maxLength })
-          );
+          LewMessage.warning(locale.t("inputTag.maxLength", { maxLength: props.maxLength }));
           return;
         }
         _value.push(inputValue.value);
@@ -21597,6 +23189,7 @@ const _sfc_main$z = /* @__PURE__ */ defineComponent({
     }
     function onBlur() {
       isInputActive.value = false;
+      isTagMarkedForDeletion.value = false;
       if (inputValue.value) {
         addTag();
       }
@@ -21610,8 +23203,8 @@ const _sfc_main$z = /* @__PURE__ */ defineComponent({
     const getTagStyle = computed(() => (index2) => {
       return {
         maxWidth: "100%",
-        backgroundColor: isInputActive.value && isTagMarkedForDeletion.value && index2 === (modelValue.value || []).length - 1 ? "var(--lew-color-red-light)" : "",
-        color: isInputActive.value && isTagMarkedForDeletion.value && index2 === (modelValue.value || []).length - 1 ? "var(--lew-color-red-dark)" : "var(--lew-color-primary-dark)"
+        backgroundColor: isTagMarkedForDeletion.value && index2 === (modelValue.value || []).length - 1 ? "var(--lew-color-red-light)" : "",
+        color: isTagMarkedForDeletion.value && index2 === (modelValue.value || []).length - 1 ? "var(--lew-color-red-dark)" : "var(--lew-color-primary-dark)"
       };
     });
     return (_ctx, _cache) => {
@@ -21687,7 +23280,7 @@ const _sfc_main$z = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewInputTag = /* @__PURE__ */ _export_sfc(_sfc_main$z, [["__scopeId", "data-v-bafe25d6"]]);
+const LewInputTag = /* @__PURE__ */ _export_sfc(_sfc_main$z, [["__scopeId", "data-v-3efd3712"]]);
 const radioEmits = {
   change: () => true
 };
@@ -26909,12 +28502,6 @@ const _sfc_main$l = /* @__PURE__ */ defineComponent({
   }
 });
 const LewUpload = /* @__PURE__ */ _export_sfc(_sfc_main$l, [["__scopeId", "data-v-741ec8ee"]]);
-const avatarEmits = {
-  load: () => {
-  },
-  error: () => {
-  }
-};
 const statusValues = ["online", "processing", "away", "offline", "busy"];
 const placementValues = ["top-left", "top-right", "bottom-left", "bottom-right"];
 const shapeValues = ["circle", "square", "sharp"];
@@ -26947,6 +28534,7 @@ const avatarProps = {
   },
   src: {
     type: String,
+    default: "",
     validator: validators.string({
       componentName: "LewAvatar",
       propName: "src"
@@ -27007,10 +28595,8 @@ const _hoisted_2$a = ["alt", "src"];
 const _sfc_main$k = /* @__PURE__ */ defineComponent({
   __name: "LewAvatar",
   props: avatarProps,
-  emits: avatarEmits,
-  setup(__props, { emit: __emit }) {
+  setup(__props) {
     const props = __props;
-    const emit = __emit;
     const BORDER_RADIUS_MAP = {
       circle: "50%",
       sharp: "0",
@@ -27075,11 +28661,16 @@ const _sfc_main$k = /* @__PURE__ */ defineComponent({
       processing: "var(--lew-color-info)",
       away: "var(--lew-color-warning)"
     };
-    const { isLoading, error } = useImage({
-      src: props.src,
-      onLoaded: () => emit("load"),
-      onError: () => emit("error")
+    const imageOptions = ref({
+      src: props.src
     });
+    watch(
+      () => props.src,
+      (newVal) => {
+        imageOptions.value.src = newVal;
+      }
+    );
+    const { isLoading, error } = useImage(imageOptions);
     const avatarStyleObject = computed(() => ({
       width: any2px(props.size),
       height: any2px(props.size)
@@ -27102,15 +28693,13 @@ const _sfc_main$k = /* @__PURE__ */ defineComponent({
       };
     });
     const altText = computed(() => {
-      if (!props.alt)
-        return "";
+      if (!props.alt) return "";
       const result = props.alt.split(" ").map((word) => word.charAt(0)).join("").toUpperCase();
       return result.length > 2 ? result.charAt(0) : result;
     });
     const dotStyleObject = computed(() => {
       const { status, statusPlacement, shape, size } = props;
-      if (!status)
-        return {};
+      if (!status) return {};
       const statusPlacementConfig = shape === "circle" ? STATUS_PLACEMENT_CONFIG_CIRCLE : STATUS_PLACEMENT_CONFIG_SQUARE;
       return {
         ...statusPlacementConfig[statusPlacement],
@@ -27137,29 +28726,29 @@ const _sfc_main$k = /* @__PURE__ */ defineComponent({
           class: "lew-avatar-box",
           style: normalizeStyle(avatarBoxStyleObject.value)
         }, [
-          _ctx.src ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
-            unref(isLoading) || _ctx.loading ? (openBlock(), createElementBlock("div", _hoisted_1$c)) : !unref(error) ? (openBlock(), createElementBlock("img", {
-              key: 1,
+          unref(isLoading) || _ctx.loading ? (openBlock(), createElementBlock("div", _hoisted_1$c)) : _ctx.src ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+            !unref(error) ? (openBlock(), createElementBlock("img", {
+              key: 0,
               alt: _ctx.alt,
               src: _ctx.src,
               lazy: "",
               style: normalizeStyle(imageStyleObject.value)
             }, null, 12, _hoisted_2$a)) : _ctx.alt ? (openBlock(), createElementBlock("div", {
-              key: 2,
+              key: 1,
               class: "lew-avatar-text",
               style: normalizeStyle(textStyleObject.value)
             }, toDisplayString$1(altText.value), 5)) : (openBlock(), createBlock(CommonIcon, {
-              key: 3,
+              key: 2,
               class: "lew-avatar-user-icon",
               size: getIconSize.value,
               type: "user"
             }, null, 8, ["size"]))
           ], 64)) : _ctx.alt ? (openBlock(), createElementBlock("div", {
-            key: 1,
+            key: 2,
             class: "lew-avatar-text",
             style: normalizeStyle(textStyleObject.value)
           }, toDisplayString$1(altText.value), 5)) : (openBlock(), createBlock(CommonIcon, {
-            key: 2,
+            key: 3,
             class: "lew-avatar-user-icon",
             size: getIconSize.value,
             type: "user"
@@ -27173,7 +28762,7 @@ const _sfc_main$k = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewAvatar = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["__scopeId", "data-v-d0850c9b"]]);
+const LewAvatar = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["__scopeId", "data-v-c104afd2"]]);
 const badgeProps = {
   text: {
     type: String,
@@ -27566,11 +29155,6 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
   }
 });
 const LewFlex = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__scopeId", "data-v-8faad083"]]);
-const imageEmits = {
-  load: (event) => event,
-  error: (event) => event,
-  click: (event) => event
-};
 const _imports_0 = "data:image/svg+xml,%3csvg%20t='1726823972943'%20class='icon'%20viewBox='0%200%201024%201024'%20version='1.1'%20xmlns='http://www.w3.org/2000/svg'%20p-id='6153'%20xmlns:xlink='http://www.w3.org/1999/xlink'%20width='200'%20height='200'%3e%3cpath%20d='M692.712%20172.458h-43.443l-21.561%2037.727-120.367%20210.648%20170.073%20170.092-118.896%20222.89-20.127%2037.727H926.996V172.458H692.712z%20m-21.561%2037.727h218.118v312.869L758.998%20392.783l-129.346%2097.015-75.265-75.265%20116.764-204.348z%20m218.118%20603.63h-287.97l122.575-229.832-67.267-67.267%2098.863-74.133L889.269%20576.4v237.415z'%20fill='%23DBDBDB'%20p-id='6154'%3e%3c/path%3e%3cpath%20d='M441.206%20414.533L557.97%20210.185l21.561-37.727H97.004v679.083H467.991l20.127-37.727%20122.575-229.832-169.487-169.449zM134.731%20210.185h379.796L394.16%20420.833l170.073%20170.092-12.488%2023.409L282.47%20528.92%20134.731%20632.33V210.185z%20m310.624%20603.63H134.731V678.394l154.077-107.861%20244.866%2077.661-88.319%20165.621z'%20fill='%23DBDBDB'%20p-id='6155'%3e%3c/path%3e%3cpath%20d='M361.093%20370.524c0-36.463-29.559-66.022-66.022-66.022s-66.022%2029.559-66.022%2066.022%2029.559%2066.022%2066.022%2066.022%2066.022-29.559%2066.022-66.022z%20m-94.318%200c0-15.6%2012.695-28.295%2028.295-28.295%2015.6%200%2028.295%2012.695%2028.295%2028.295%200%2015.6-12.695%2028.295-28.295%2028.295-15.6%200-28.295-12.695-28.295-28.295z'%20fill='%23DBDBDB'%20p-id='6156'%3e%3c/path%3e%3c/svg%3e";
 const imageProps = {
   src: {
@@ -27676,9 +29260,14 @@ const _sfc_main$g = /* @__PURE__ */ defineComponent({
         height: any2px(height)
       };
     });
-    const { isLoading, error } = useImage({
-      src: props.src
-    });
+    const imageOptions = ref({ src: props.src });
+    watch(
+      () => props.src,
+      (newVal) => {
+        imageOptions.value.src = newVal;
+      }
+    );
+    const { isLoading, error } = useImage(imageOptions);
     return (_ctx, _cache) => {
       const _directive_tooltip = resolveDirective("tooltip");
       return openBlock(), createBlock(unref(LewFlex), {
@@ -27719,7 +29308,7 @@ const _sfc_main$g = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LewImage = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["__scopeId", "data-v-95fcf03f"]]);
+const LewImage = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["__scopeId", "data-v-eb70b553"]]);
 const markProps = {
   color: {
     type: String,
@@ -29930,7 +31519,6 @@ const components = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   actionBoxProps,
   alertEmits,
   alertProps,
-  avatarEmits,
   avatarProps,
   backTopProps,
   badgeProps,
@@ -29983,7 +31571,6 @@ const components = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   formModalProps,
   formProps,
   formTypeAsMap,
-  imageEmits,
   imageProps,
   inputEmits,
   inputModel,
@@ -30770,7 +32357,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         0
       );
     }
-    function add(type, title, content, duration, showProgress, width2) {
+    function add2(type, title, content, duration, showProgress, width2) {
       const id = getUniqueId();
       document.getElementById("lew-notification")?.classList.remove("notification-hidden");
       notifications.value.unshift({
@@ -30811,7 +32398,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
     }
     __expose({
-      add,
+      add: add2,
       handleClose
     });
     return (_ctx, _cache) => {
@@ -37395,7 +38982,6 @@ export {
   actionBoxProps,
   alertEmits,
   alertProps,
-  avatarEmits,
   avatarProps,
   backTopProps,
   badgeProps,
@@ -37457,7 +39043,6 @@ export {
   formTypeAsMap,
   fr,
   getLocale,
-  imageEmits,
   imageProps,
   initLewContextMenu,
   inputEmits,