@ibiz-template/runtime 0.5.7-alpha.2 → 0.5.7-alpha.3

package/dist/index.esm.js

@@ -1073,10 +1073,10 @@ function getViewEngines(view) {
   if (viewLayoutPanel) {
     appViewEngines.push(...viewLayoutPanel.appViewEngines || []);
   }
-  return appViewEngines.filter((engine) => {
-    switch (engine.engineCat) {
+  return appViewEngines.filter((engine2) => {
+    switch (engine2.engineCat) {
       case "CTRL":
-        ibiz.log.warn("\u672A\u652F\u6301\u7684\u5F15\u64CE\u5206\u7C7B\uFF1A".concat(engine.engineType));
+        ibiz.log.warn("\u672A\u652F\u6301\u7684\u5F15\u64CE\u5206\u7C7B\uFF1A".concat(engine2.engineType));
         return false;
       default:
         return true;
@@ -2644,6 +2644,12 @@ var ViewType = /* @__PURE__ */ ((ViewType2) => {
   return ViewType2;
 })(ViewType || {});
 
+// src/constant/preset-identifier.ts
+var PresetIdentifier = /* @__PURE__ */ ((PresetIdentifier2) => {
+  PresetIdentifier2["MESSAGE"] = "preset-message";
+  return PresetIdentifier2;
+})(PresetIdentifier || {});
+
 // src/utils/modal/modal.ts
 var Modal = class {
   constructor(opts) {
@@ -3236,6 +3242,1608 @@ async function handleAllSettled(values, isThrow = true) {
   return successResult;
 }
 
+// src/utils/anime/anime-element-util.ts
+var baseStyle = {
+  position: "fixed",
+  zIndex: "10000"
+};
+function cloneElement(clone31, teleport = document.body, isRemoveChild = true) {
+  const element = getAnimationElement(clone31);
+  if (element == null) {
+    throw new Error("Cannot clone a null or undefined element.");
+  }
+  const clonedElement = element.cloneNode(true);
+  if (isRemoveChild) {
+    while (clonedElement.firstChild) {
+      clonedElement.removeChild(clonedElement.firstChild);
+    }
+  }
+  const styles = getElementAttribute(element);
+  setElementStyle(clonedElement, styles);
+  teleport.appendChild(clonedElement);
+  return clonedElement;
+}
+function setElementStyle(element, {
+  width,
+  height,
+  boundingLeft,
+  boundingTop
+}) {
+  element.style.left = "".concat(boundingLeft, "px");
+  element.style.top = "".concat(boundingTop, "px");
+  element.style.width = "".concat(width, "px");
+  element.style.height = "".concat(height, "px");
+  Object.assign(element.style, baseStyle);
+}
+function getElementAttribute(element) {
+  const width = element.offsetWidth;
+  const height = element.offsetHeight;
+  const styles = window.getComputedStyle(element);
+  const padding = parseFloat(styles.padding);
+  const { left: boundingLeft, top: boundingTop } = element.getBoundingClientRect();
+  return {
+    width,
+    height,
+    padding,
+    boundingLeft,
+    boundingTop
+  };
+}
+function getAnimationElement(element) {
+  if (typeof element === "string") {
+    return document.querySelector(element);
+  }
+  return element;
+}
+function destroyElement(ele) {
+  if (ele) {
+    ele.remove();
+  }
+}
+
+// ../../node_modules/.pnpm/animejs@3.2.2/node_modules/animejs/lib/anime.es.js
+var defaultInstanceSettings = {
+  update: null,
+  begin: null,
+  loopBegin: null,
+  changeBegin: null,
+  change: null,
+  changeComplete: null,
+  loopComplete: null,
+  complete: null,
+  loop: 1,
+  direction: "normal",
+  autoplay: true,
+  timelineOffset: 0
+};
+var defaultTweenSettings = {
+  duration: 1e3,
+  delay: 0,
+  endDelay: 0,
+  easing: "easeOutElastic(1, .5)",
+  round: 0
+};
+var validTransforms = ["translateX", "translateY", "translateZ", "rotate", "rotateX", "rotateY", "rotateZ", "scale", "scaleX", "scaleY", "scaleZ", "skew", "skewX", "skewY", "perspective", "matrix", "matrix3d"];
+var cache = {
+  CSS: {},
+  springs: {}
+};
+function minMax(val, min, max) {
+  return Math.min(Math.max(val, min), max);
+}
+function stringContains(str, text) {
+  return str.indexOf(text) > -1;
+}
+function applyArguments(func, args) {
+  return func.apply(null, args);
+}
+var is = {
+  arr: function(a) {
+    return Array.isArray(a);
+  },
+  obj: function(a) {
+    return stringContains(Object.prototype.toString.call(a), "Object");
+  },
+  pth: function(a) {
+    return is.obj(a) && a.hasOwnProperty("totalLength");
+  },
+  svg: function(a) {
+    return a instanceof SVGElement;
+  },
+  inp: function(a) {
+    return a instanceof HTMLInputElement;
+  },
+  dom: function(a) {
+    return a.nodeType || is.svg(a);
+  },
+  str: function(a) {
+    return typeof a === "string";
+  },
+  fnc: function(a) {
+    return typeof a === "function";
+  },
+  und: function(a) {
+    return typeof a === "undefined";
+  },
+  nil: function(a) {
+    return is.und(a) || a === null;
+  },
+  hex: function(a) {
+    return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a);
+  },
+  rgb: function(a) {
+    return /^rgb/.test(a);
+  },
+  hsl: function(a) {
+    return /^hsl/.test(a);
+  },
+  col: function(a) {
+    return is.hex(a) || is.rgb(a) || is.hsl(a);
+  },
+  key: function(a) {
+    return !defaultInstanceSettings.hasOwnProperty(a) && !defaultTweenSettings.hasOwnProperty(a) && a !== "targets" && a !== "keyframes";
+  }
+};
+function parseEasingParameters(string) {
+  var match = /\(([^)]+)\)/.exec(string);
+  return match ? match[1].split(",").map(function(p) {
+    return parseFloat(p);
+  }) : [];
+}
+function spring(string, duration) {
+  var params = parseEasingParameters(string);
+  var mass = minMax(is.und(params[0]) ? 1 : params[0], 0.1, 100);
+  var stiffness = minMax(is.und(params[1]) ? 100 : params[1], 0.1, 100);
+  var damping = minMax(is.und(params[2]) ? 10 : params[2], 0.1, 100);
+  var velocity = minMax(is.und(params[3]) ? 0 : params[3], 0.1, 100);
+  var w0 = Math.sqrt(stiffness / mass);
+  var zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  var wd = zeta < 1 ? w0 * Math.sqrt(1 - zeta * zeta) : 0;
+  var a = 1;
+  var b = zeta < 1 ? (zeta * w0 + -velocity) / wd : -velocity + w0;
+  function solver(t) {
+    var progress = duration ? duration * t / 1e3 : t;
+    if (zeta < 1) {
+      progress = Math.exp(-progress * zeta * w0) * (a * Math.cos(wd * progress) + b * Math.sin(wd * progress));
+    } else {
+      progress = (a + b * progress) * Math.exp(-progress * w0);
+    }
+    if (t === 0 || t === 1) {
+      return t;
+    }
+    return 1 - progress;
+  }
+  function getDuration() {
+    var cached = cache.springs[string];
+    if (cached) {
+      return cached;
+    }
+    var frame = 1 / 6;
+    var elapsed = 0;
+    var rest = 0;
+    while (true) {
+      elapsed += frame;
+      if (solver(elapsed) === 1) {
+        rest++;
+        if (rest >= 16) {
+          break;
+        }
+      } else {
+        rest = 0;
+      }
+    }
+    var duration2 = elapsed * frame * 1e3;
+    cache.springs[string] = duration2;
+    return duration2;
+  }
+  return duration ? solver : getDuration;
+}
+function steps(steps2) {
+  if (steps2 === void 0)
+    steps2 = 10;
+  return function(t) {
+    return Math.ceil(minMax(t, 1e-6, 1) * steps2) * (1 / steps2);
+  };
+}
+var bezier = function() {
+  var kSplineTableSize = 11;
+  var kSampleStepSize = 1 / (kSplineTableSize - 1);
+  function A(aA1, aA2) {
+    return 1 - 3 * aA2 + 3 * aA1;
+  }
+  function B(aA1, aA2) {
+    return 3 * aA2 - 6 * aA1;
+  }
+  function C(aA1) {
+    return 3 * aA1;
+  }
+  function calcBezier(aT, aA1, aA2) {
+    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+  }
+  function getSlope(aT, aA1, aA2) {
+    return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);
+  }
+  function binarySubdivide(aX, aA, aB, mX1, mX2) {
+    var currentX, currentT, i = 0;
+    do {
+      currentT = aA + (aB - aA) / 2;
+      currentX = calcBezier(currentT, mX1, mX2) - aX;
+      if (currentX > 0) {
+        aB = currentT;
+      } else {
+        aA = currentT;
+      }
+    } while (Math.abs(currentX) > 1e-7 && ++i < 10);
+    return currentT;
+  }
+  function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
+    for (var i = 0; i < 4; ++i) {
+      var currentSlope = getSlope(aGuessT, mX1, mX2);
+      if (currentSlope === 0) {
+        return aGuessT;
+      }
+      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+      aGuessT -= currentX / currentSlope;
+    }
+    return aGuessT;
+  }
+  function bezier2(mX1, mY1, mX2, mY2) {
+    if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
+      return;
+    }
+    var sampleValues = new Float32Array(kSplineTableSize);
+    if (mX1 !== mY1 || mX2 !== mY2) {
+      for (var i = 0; i < kSplineTableSize; ++i) {
+        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+      }
+    }
+    function getTForX(aX) {
+      var intervalStart = 0;
+      var currentSample = 1;
+      var lastSample = kSplineTableSize - 1;
+      for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+        intervalStart += kSampleStepSize;
+      }
+      --currentSample;
+      var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+      var guessForT = intervalStart + dist * kSampleStepSize;
+      var initialSlope = getSlope(guessForT, mX1, mX2);
+      if (initialSlope >= 1e-3) {
+        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+      } else if (initialSlope === 0) {
+        return guessForT;
+      } else {
+        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+      }
+    }
+    return function(x) {
+      if (mX1 === mY1 && mX2 === mY2) {
+        return x;
+      }
+      if (x === 0 || x === 1) {
+        return x;
+      }
+      return calcBezier(getTForX(x), mY1, mY2);
+    };
+  }
+  return bezier2;
+}();
+var penner = function() {
+  var eases = { linear: function() {
+    return function(t) {
+      return t;
+    };
+  } };
+  var functionEasings = {
+    Sine: function() {
+      return function(t) {
+        return 1 - Math.cos(t * Math.PI / 2);
+      };
+    },
+    Expo: function() {
+      return function(t) {
+        return t ? Math.pow(2, 10 * t - 10) : 0;
+      };
+    },
+    Circ: function() {
+      return function(t) {
+        return 1 - Math.sqrt(1 - t * t);
+      };
+    },
+    Back: function() {
+      return function(t) {
+        return t * t * (3 * t - 2);
+      };
+    },
+    Bounce: function() {
+      return function(t) {
+        var pow2, b = 4;
+        while (t < ((pow2 = Math.pow(2, --b)) - 1) / 11) {
+        }
+        return 1 / Math.pow(4, 3 - b) - 7.5625 * Math.pow((pow2 * 3 - 2) / 22 - t, 2);
+      };
+    },
+    Elastic: function(amplitude, period) {
+      if (amplitude === void 0)
+        amplitude = 1;
+      if (period === void 0)
+        period = 0.5;
+      var a = minMax(amplitude, 1, 10);
+      var p = minMax(period, 0.1, 2);
+      return function(t) {
+        return t === 0 || t === 1 ? t : -a * Math.pow(2, 10 * (t - 1)) * Math.sin((t - 1 - p / (Math.PI * 2) * Math.asin(1 / a)) * (Math.PI * 2) / p);
+      };
+    }
+  };
+  var baseEasings = ["Quad", "Cubic", "Quart", "Quint"];
+  baseEasings.forEach(function(name, i) {
+    functionEasings[name] = function() {
+      return function(t) {
+        return Math.pow(t, i + 2);
+      };
+    };
+  });
+  Object.keys(functionEasings).forEach(function(name) {
+    var easeIn = functionEasings[name];
+    eases["easeIn" + name] = easeIn;
+    eases["easeOut" + name] = function(a, b) {
+      return function(t) {
+        return 1 - easeIn(a, b)(1 - t);
+      };
+    };
+    eases["easeInOut" + name] = function(a, b) {
+      return function(t) {
+        return t < 0.5 ? easeIn(a, b)(t * 2) / 2 : 1 - easeIn(a, b)(t * -2 + 2) / 2;
+      };
+    };
+    eases["easeOutIn" + name] = function(a, b) {
+      return function(t) {
+        return t < 0.5 ? (1 - easeIn(a, b)(1 - t * 2)) / 2 : (easeIn(a, b)(t * 2 - 1) + 1) / 2;
+      };
+    };
+  });
+  return eases;
+}();
+function parseEasings(easing, duration) {
+  if (is.fnc(easing)) {
+    return easing;
+  }
+  var name = easing.split("(")[0];
+  var ease = penner[name];
+  var args = parseEasingParameters(easing);
+  switch (name) {
+    case "spring":
+      return spring(easing, duration);
+    case "cubicBezier":
+      return applyArguments(bezier, args);
+    case "steps":
+      return applyArguments(steps, args);
+    default:
+      return applyArguments(ease, args);
+  }
+}
+function selectString(str) {
+  try {
+    var nodes = document.querySelectorAll(str);
+    return nodes;
+  } catch (e) {
+    return;
+  }
+}
+function filterArray(arr, callback) {
+  var len = arr.length;
+  var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
+  var result = [];
+  for (var i = 0; i < len; i++) {
+    if (i in arr) {
+      var val = arr[i];
+      if (callback.call(thisArg, val, i, arr)) {
+        result.push(val);
+      }
+    }
+  }
+  return result;
+}
+function flattenArray(arr) {
+  return arr.reduce(function(a, b) {
+    return a.concat(is.arr(b) ? flattenArray(b) : b);
+  }, []);
+}
+function toArray(o) {
+  if (is.arr(o)) {
+    return o;
+  }
+  if (is.str(o)) {
+    o = selectString(o) || o;
+  }
+  if (o instanceof NodeList || o instanceof HTMLCollection) {
+    return [].slice.call(o);
+  }
+  return [o];
+}
+function arrayContains(arr, val) {
+  return arr.some(function(a) {
+    return a === val;
+  });
+}
+function cloneObject(o) {
+  var clone31 = {};
+  for (var p in o) {
+    clone31[p] = o[p];
+  }
+  return clone31;
+}
+function replaceObjectProps(o1, o2) {
+  var o = cloneObject(o1);
+  for (var p in o1) {
+    o[p] = o2.hasOwnProperty(p) ? o2[p] : o1[p];
+  }
+  return o;
+}
+function mergeObjects(o1, o2) {
+  var o = cloneObject(o1);
+  for (var p in o2) {
+    o[p] = is.und(o1[p]) ? o2[p] : o1[p];
+  }
+  return o;
+}
+function rgbToRgba(rgbValue) {
+  var rgb = /rgb\((\d+,\s*[\d]+,\s*[\d]+)\)/g.exec(rgbValue);
+  return rgb ? "rgba(" + rgb[1] + ",1)" : rgbValue;
+}
+function hexToRgba(hexValue) {
+  var rgx = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+  var hex = hexValue.replace(rgx, function(m, r2, g2, b2) {
+    return r2 + r2 + g2 + g2 + b2 + b2;
+  });
+  var rgb = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  var r = parseInt(rgb[1], 16);
+  var g = parseInt(rgb[2], 16);
+  var b = parseInt(rgb[3], 16);
+  return "rgba(" + r + "," + g + "," + b + ",1)";
+}
+function hslToRgba(hslValue) {
+  var hsl = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(hslValue) || /hsla\((\d+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)/g.exec(hslValue);
+  var h = parseInt(hsl[1], 10) / 360;
+  var s = parseInt(hsl[2], 10) / 100;
+  var l = parseInt(hsl[3], 10) / 100;
+  var a = hsl[4] || 1;
+  function hue2rgb(p2, q2, t) {
+    if (t < 0) {
+      t += 1;
+    }
+    if (t > 1) {
+      t -= 1;
+    }
+    if (t < 1 / 6) {
+      return p2 + (q2 - p2) * 6 * t;
+    }
+    if (t < 1 / 2) {
+      return q2;
+    }
+    if (t < 2 / 3) {
+      return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+    }
+    return p2;
+  }
+  var r, g, b;
+  if (s == 0) {
+    r = g = b = l;
+  } else {
+    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    var p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return "rgba(" + r * 255 + "," + g * 255 + "," + b * 255 + "," + a + ")";
+}
+function colorToRgb(val) {
+  if (is.rgb(val)) {
+    return rgbToRgba(val);
+  }
+  if (is.hex(val)) {
+    return hexToRgba(val);
+  }
+  if (is.hsl(val)) {
+    return hslToRgba(val);
+  }
+}
+function getUnit(val) {
+  var split = /[+-]?\d*\.?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?(%|px|pt|em|rem|in|cm|mm|ex|ch|pc|vw|vh|vmin|vmax|deg|rad|turn)?$/.exec(val);
+  if (split) {
+    return split[1];
+  }
+}
+function getTransformUnit(propName) {
+  if (stringContains(propName, "translate") || propName === "perspective") {
+    return "px";
+  }
+  if (stringContains(propName, "rotate") || stringContains(propName, "skew")) {
+    return "deg";
+  }
+}
+function getFunctionValue(val, animatable) {
+  if (!is.fnc(val)) {
+    return val;
+  }
+  return val(animatable.target, animatable.id, animatable.total);
+}
+function getAttribute(el, prop) {
+  return el.getAttribute(prop);
+}
+function convertPxToUnit(el, value, unit) {
+  var valueUnit = getUnit(value);
+  if (arrayContains([unit, "deg", "rad", "turn"], valueUnit)) {
+    return value;
+  }
+  var cached = cache.CSS[value + unit];
+  if (!is.und(cached)) {
+    return cached;
+  }
+  var baseline = 100;
+  var tempEl = document.createElement(el.tagName);
+  var parentEl = el.parentNode && el.parentNode !== document ? el.parentNode : document.body;
+  parentEl.appendChild(tempEl);
+  tempEl.style.position = "absolute";
+  tempEl.style.width = baseline + unit;
+  var factor = baseline / tempEl.offsetWidth;
+  parentEl.removeChild(tempEl);
+  var convertedUnit = factor * parseFloat(value);
+  cache.CSS[value + unit] = convertedUnit;
+  return convertedUnit;
+}
+function getCSSValue(el, prop, unit) {
+  if (prop in el.style) {
+    var uppercasePropName = prop.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+    var value = el.style[prop] || getComputedStyle(el).getPropertyValue(uppercasePropName) || "0";
+    return unit ? convertPxToUnit(el, value, unit) : value;
+  }
+}
+function getAnimationType(el, prop) {
+  if (is.dom(el) && !is.inp(el) && (!is.nil(getAttribute(el, prop)) || is.svg(el) && el[prop])) {
+    return "attribute";
+  }
+  if (is.dom(el) && arrayContains(validTransforms, prop)) {
+    return "transform";
+  }
+  if (is.dom(el) && (prop !== "transform" && getCSSValue(el, prop))) {
+    return "css";
+  }
+  if (el[prop] != null) {
+    return "object";
+  }
+}
+function getElementTransforms(el) {
+  if (!is.dom(el)) {
+    return;
+  }
+  var str = el.style.transform || "";
+  var reg2 = /(\w+)\(([^)]*)\)/g;
+  var transforms = /* @__PURE__ */ new Map();
+  var m;
+  while (m = reg2.exec(str)) {
+    transforms.set(m[1], m[2]);
+  }
+  return transforms;
+}
+function getTransformValue(el, propName, animatable, unit) {
+  var defaultVal = stringContains(propName, "scale") ? 1 : 0 + getTransformUnit(propName);
+  var value = getElementTransforms(el).get(propName) || defaultVal;
+  if (animatable) {
+    animatable.transforms.list.set(propName, value);
+    animatable.transforms["last"] = propName;
+  }
+  return unit ? convertPxToUnit(el, value, unit) : value;
+}
+function getOriginalTargetValue(target, propName, unit, animatable) {
+  switch (getAnimationType(target, propName)) {
+    case "transform":
+      return getTransformValue(target, propName, animatable, unit);
+    case "css":
+      return getCSSValue(target, propName, unit);
+    case "attribute":
+      return getAttribute(target, propName);
+    default:
+      return target[propName] || 0;
+  }
+}
+function getRelativeValue(to, from) {
+  var operator = /^(\*=|\+=|-=)/.exec(to);
+  if (!operator) {
+    return to;
+  }
+  var u = getUnit(to) || 0;
+  var x = parseFloat(from);
+  var y = parseFloat(to.replace(operator[0], ""));
+  switch (operator[0][0]) {
+    case "+":
+      return x + y + u;
+    case "-":
+      return x - y + u;
+    case "*":
+      return x * y + u;
+  }
+}
+function validateValue(val, unit) {
+  if (is.col(val)) {
+    return colorToRgb(val);
+  }
+  if (/\s/g.test(val)) {
+    return val;
+  }
+  var originalUnit = getUnit(val);
+  var unitLess = originalUnit ? val.substr(0, val.length - originalUnit.length) : val;
+  if (unit) {
+    return unitLess + unit;
+  }
+  return unitLess;
+}
+function getDistance(p1, p2) {
+  return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+}
+function getCircleLength(el) {
+  return Math.PI * 2 * getAttribute(el, "r");
+}
+function getRectLength(el) {
+  return getAttribute(el, "width") * 2 + getAttribute(el, "height") * 2;
+}
+function getLineLength(el) {
+  return getDistance(
+    { x: getAttribute(el, "x1"), y: getAttribute(el, "y1") },
+    { x: getAttribute(el, "x2"), y: getAttribute(el, "y2") }
+  );
+}
+function getPolylineLength(el) {
+  var points = el.points;
+  var totalLength = 0;
+  var previousPos;
+  for (var i = 0; i < points.numberOfItems; i++) {
+    var currentPos = points.getItem(i);
+    if (i > 0) {
+      totalLength += getDistance(previousPos, currentPos);
+    }
+    previousPos = currentPos;
+  }
+  return totalLength;
+}
+function getPolygonLength(el) {
+  var points = el.points;
+  return getPolylineLength(el) + getDistance(points.getItem(points.numberOfItems - 1), points.getItem(0));
+}
+function getTotalLength(el) {
+  if (el.getTotalLength) {
+    return el.getTotalLength();
+  }
+  switch (el.tagName.toLowerCase()) {
+    case "circle":
+      return getCircleLength(el);
+    case "rect":
+      return getRectLength(el);
+    case "line":
+      return getLineLength(el);
+    case "polyline":
+      return getPolylineLength(el);
+    case "polygon":
+      return getPolygonLength(el);
+  }
+}
+function setDashoffset(el) {
+  var pathLength = getTotalLength(el);
+  el.setAttribute("stroke-dasharray", pathLength);
+  return pathLength;
+}
+function getParentSvgEl(el) {
+  var parentEl = el.parentNode;
+  while (is.svg(parentEl)) {
+    if (!is.svg(parentEl.parentNode)) {
+      break;
+    }
+    parentEl = parentEl.parentNode;
+  }
+  return parentEl;
+}
+function getParentSvg(pathEl, svgData) {
+  var svg = svgData || {};
+  var parentSvgEl = svg.el || getParentSvgEl(pathEl);
+  var rect = parentSvgEl.getBoundingClientRect();
+  var viewBoxAttr = getAttribute(parentSvgEl, "viewBox");
+  var width = rect.width;
+  var height = rect.height;
+  var viewBox = svg.viewBox || (viewBoxAttr ? viewBoxAttr.split(" ") : [0, 0, width, height]);
+  return {
+    el: parentSvgEl,
+    viewBox,
+    x: viewBox[0] / 1,
+    y: viewBox[1] / 1,
+    w: width,
+    h: height,
+    vW: viewBox[2],
+    vH: viewBox[3]
+  };
+}
+function getPath(path2, percent) {
+  var pathEl = is.str(path2) ? selectString(path2)[0] : path2;
+  var p = percent || 100;
+  return function(property) {
+    return {
+      property,
+      el: pathEl,
+      svg: getParentSvg(pathEl),
+      totalLength: getTotalLength(pathEl) * (p / 100)
+    };
+  };
+}
+function getPathProgress(path2, progress, isPathTargetInsideSVG) {
+  function point(offset) {
+    if (offset === void 0)
+      offset = 0;
+    var l = progress + offset >= 1 ? progress + offset : 0;
+    return path2.el.getPointAtLength(l);
+  }
+  var svg = getParentSvg(path2.el, path2.svg);
+  var p = point();
+  var p0 = point(-1);
+  var p1 = point(1);
+  var scaleX = isPathTargetInsideSVG ? 1 : svg.w / svg.vW;
+  var scaleY = isPathTargetInsideSVG ? 1 : svg.h / svg.vH;
+  switch (path2.property) {
+    case "x":
+      return (p.x - svg.x) * scaleX;
+    case "y":
+      return (p.y - svg.y) * scaleY;
+    case "angle":
+      return Math.atan2(p1.y - p0.y, p1.x - p0.x) * 180 / Math.PI;
+  }
+}
+function decomposeValue(val, unit) {
+  var rgx = /[+-]?\d*\.?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g;
+  var value = validateValue(is.pth(val) ? val.totalLength : val, unit) + "";
+  return {
+    original: value,
+    numbers: value.match(rgx) ? value.match(rgx).map(Number) : [0],
+    strings: is.str(val) || unit ? value.split(rgx) : []
+  };
+}
+function parseTargets(targets) {
+  var targetsArray = targets ? flattenArray(is.arr(targets) ? targets.map(toArray) : toArray(targets)) : [];
+  return filterArray(targetsArray, function(item, pos, self) {
+    return self.indexOf(item) === pos;
+  });
+}
+function getAnimatables(targets) {
+  var parsed = parseTargets(targets);
+  return parsed.map(function(t, i) {
+    return { target: t, id: i, total: parsed.length, transforms: { list: getElementTransforms(t) } };
+  });
+}
+function normalizePropertyTweens(prop, tweenSettings) {
+  var settings = cloneObject(tweenSettings);
+  if (/^spring/.test(settings.easing)) {
+    settings.duration = spring(settings.easing);
+  }
+  if (is.arr(prop)) {
+    var l = prop.length;
+    var isFromTo = l === 2 && !is.obj(prop[0]);
+    if (!isFromTo) {
+      if (!is.fnc(tweenSettings.duration)) {
+        settings.duration = tweenSettings.duration / l;
+      }
+    } else {
+      prop = { value: prop };
+    }
+  }
+  var propArray = is.arr(prop) ? prop : [prop];
+  return propArray.map(function(v, i) {
+    var obj = is.obj(v) && !is.pth(v) ? v : { value: v };
+    if (is.und(obj.delay)) {
+      obj.delay = !i ? tweenSettings.delay : 0;
+    }
+    if (is.und(obj.endDelay)) {
+      obj.endDelay = i === propArray.length - 1 ? tweenSettings.endDelay : 0;
+    }
+    return obj;
+  }).map(function(k) {
+    return mergeObjects(k, settings);
+  });
+}
+function flattenKeyframes(keyframes) {
+  var propertyNames = filterArray(flattenArray(keyframes.map(function(key) {
+    return Object.keys(key);
+  })), function(p) {
+    return is.key(p);
+  }).reduce(function(a, b) {
+    if (a.indexOf(b) < 0) {
+      a.push(b);
+    }
+    return a;
+  }, []);
+  var properties = {};
+  var loop = function(i2) {
+    var propName = propertyNames[i2];
+    properties[propName] = keyframes.map(function(key) {
+      var newKey = {};
+      for (var p in key) {
+        if (is.key(p)) {
+          if (p == propName) {
+            newKey.value = key[p];
+          }
+        } else {
+          newKey[p] = key[p];
+        }
+      }
+      return newKey;
+    });
+  };
+  for (var i = 0; i < propertyNames.length; i++)
+    loop(i);
+  return properties;
+}
+function getProperties(tweenSettings, params) {
+  var properties = [];
+  var keyframes = params.keyframes;
+  if (keyframes) {
+    params = mergeObjects(flattenKeyframes(keyframes), params);
+  }
+  for (var p in params) {
+    if (is.key(p)) {
+      properties.push({
+        name: p,
+        tweens: normalizePropertyTweens(params[p], tweenSettings)
+      });
+    }
+  }
+  return properties;
+}
+function normalizeTweenValues(tween, animatable) {
+  var t = {};
+  for (var p in tween) {
+    var value = getFunctionValue(tween[p], animatable);
+    if (is.arr(value)) {
+      value = value.map(function(v) {
+        return getFunctionValue(v, animatable);
+      });
+      if (value.length === 1) {
+        value = value[0];
+      }
+    }
+    t[p] = value;
+  }
+  t.duration = parseFloat(t.duration);
+  t.delay = parseFloat(t.delay);
+  return t;
+}
+function normalizeTweens(prop, animatable) {
+  var previousTween;
+  return prop.tweens.map(function(t) {
+    var tween = normalizeTweenValues(t, animatable);
+    var tweenValue = tween.value;
+    var to = is.arr(tweenValue) ? tweenValue[1] : tweenValue;
+    var toUnit = getUnit(to);
+    var originalValue = getOriginalTargetValue(animatable.target, prop.name, toUnit, animatable);
+    var previousValue = previousTween ? previousTween.to.original : originalValue;
+    var from = is.arr(tweenValue) ? tweenValue[0] : previousValue;
+    var fromUnit = getUnit(from) || getUnit(originalValue);
+    var unit = toUnit || fromUnit;
+    if (is.und(to)) {
+      to = previousValue;
+    }
+    tween.from = decomposeValue(from, unit);
+    tween.to = decomposeValue(getRelativeValue(to, from), unit);
+    tween.start = previousTween ? previousTween.end : 0;
+    tween.end = tween.start + tween.delay + tween.duration + tween.endDelay;
+    tween.easing = parseEasings(tween.easing, tween.duration);
+    tween.isPath = is.pth(tweenValue);
+    tween.isPathTargetInsideSVG = tween.isPath && is.svg(animatable.target);
+    tween.isColor = is.col(tween.from.original);
+    if (tween.isColor) {
+      tween.round = 1;
+    }
+    previousTween = tween;
+    return tween;
+  });
+}
+var setProgressValue = {
+  css: function(t, p, v) {
+    return t.style[p] = v;
+  },
+  attribute: function(t, p, v) {
+    return t.setAttribute(p, v);
+  },
+  object: function(t, p, v) {
+    return t[p] = v;
+  },
+  transform: function(t, p, v, transforms, manual) {
+    transforms.list.set(p, v);
+    if (p === transforms.last || manual) {
+      var str = "";
+      transforms.list.forEach(function(value, prop) {
+        str += prop + "(" + value + ") ";
+      });
+      t.style.transform = str;
+    }
+  }
+};
+function setTargetsValue(targets, properties) {
+  var animatables = getAnimatables(targets);
+  animatables.forEach(function(animatable) {
+    for (var property in properties) {
+      var value = getFunctionValue(properties[property], animatable);
+      var target = animatable.target;
+      var valueUnit = getUnit(value);
+      var originalValue = getOriginalTargetValue(target, property, valueUnit, animatable);
+      var unit = valueUnit || getUnit(originalValue);
+      var to = getRelativeValue(validateValue(value, unit), originalValue);
+      var animType = getAnimationType(target, property);
+      setProgressValue[animType](target, property, to, animatable.transforms, true);
+    }
+  });
+}
+function createAnimation(animatable, prop) {
+  var animType = getAnimationType(animatable.target, prop.name);
+  if (animType) {
+    var tweens = normalizeTweens(prop, animatable);
+    var lastTween = tweens[tweens.length - 1];
+    return {
+      type: animType,
+      property: prop.name,
+      animatable,
+      tweens,
+      duration: lastTween.end,
+      delay: tweens[0].delay,
+      endDelay: lastTween.endDelay
+    };
+  }
+}
+function getAnimations(animatables, properties) {
+  return filterArray(flattenArray(animatables.map(function(animatable) {
+    return properties.map(function(prop) {
+      return createAnimation(animatable, prop);
+    });
+  })), function(a) {
+    return !is.und(a);
+  });
+}
+function getInstanceTimings(animations, tweenSettings) {
+  var animLength = animations.length;
+  var getTlOffset = function(anim) {
+    return anim.timelineOffset ? anim.timelineOffset : 0;
+  };
+  var timings = {};
+  timings.duration = animLength ? Math.max.apply(Math, animations.map(function(anim) {
+    return getTlOffset(anim) + anim.duration;
+  })) : tweenSettings.duration;
+  timings.delay = animLength ? Math.min.apply(Math, animations.map(function(anim) {
+    return getTlOffset(anim) + anim.delay;
+  })) : tweenSettings.delay;
+  timings.endDelay = animLength ? timings.duration - Math.max.apply(Math, animations.map(function(anim) {
+    return getTlOffset(anim) + anim.duration - anim.endDelay;
+  })) : tweenSettings.endDelay;
+  return timings;
+}
+var instanceID = 0;
+function createNewInstance(params) {
+  var instanceSettings = replaceObjectProps(defaultInstanceSettings, params);
+  var tweenSettings = replaceObjectProps(defaultTweenSettings, params);
+  var properties = getProperties(tweenSettings, params);
+  var animatables = getAnimatables(params.targets);
+  var animations = getAnimations(animatables, properties);
+  var timings = getInstanceTimings(animations, tweenSettings);
+  var id = instanceID;
+  instanceID++;
+  return mergeObjects(instanceSettings, {
+    id,
+    children: [],
+    animatables,
+    animations,
+    duration: timings.duration,
+    delay: timings.delay,
+    endDelay: timings.endDelay
+  });
+}
+var activeInstances = [];
+var engine = function() {
+  var raf;
+  function play() {
+    if (!raf && (!isDocumentHidden() || !anime.suspendWhenDocumentHidden) && activeInstances.length > 0) {
+      raf = requestAnimationFrame(step);
+    }
+  }
+  function step(t) {
+    var activeInstancesLength = activeInstances.length;
+    var i = 0;
+    while (i < activeInstancesLength) {
+      var activeInstance = activeInstances[i];
+      if (!activeInstance.paused) {
+        activeInstance.tick(t);
+        i++;
+      } else {
+        activeInstances.splice(i, 1);
+        activeInstancesLength--;
+      }
+    }
+    raf = i > 0 ? requestAnimationFrame(step) : void 0;
+  }
+  function handleVisibilityChange() {
+    if (!anime.suspendWhenDocumentHidden) {
+      return;
+    }
+    if (isDocumentHidden()) {
+      raf = cancelAnimationFrame(raf);
+    } else {
+      activeInstances.forEach(
+        function(instance) {
+          return instance._onDocumentVisibility();
+        }
+      );
+      engine();
+    }
+  }
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+  }
+  return play;
+}();
+function isDocumentHidden() {
+  return !!document && document.hidden;
+}
+function anime(params) {
+  if (params === void 0)
+    params = {};
+  var startTime = 0, lastTime = 0, now = 0;
+  var children, childrenLength = 0;
+  var resolve = null;
+  function makePromise(instance2) {
+    var promise2 = window.Promise && new Promise(function(_resolve) {
+      return resolve = _resolve;
+    });
+    instance2.finished = promise2;
+    return promise2;
+  }
+  var instance = createNewInstance(params);
+  var promise = makePromise(instance);
+  function toggleInstanceDirection() {
+    var direction = instance.direction;
+    if (direction !== "alternate") {
+      instance.direction = direction !== "normal" ? "normal" : "reverse";
+    }
+    instance.reversed = !instance.reversed;
+    children.forEach(function(child) {
+      return child.reversed = instance.reversed;
+    });
+  }
+  function adjustTime(time) {
+    return instance.reversed ? instance.duration - time : time;
+  }
+  function resetTime() {
+    startTime = 0;
+    lastTime = adjustTime(instance.currentTime) * (1 / anime.speed);
+  }
+  function seekChild(time, child) {
+    if (child) {
+      child.seek(time - child.timelineOffset);
+    }
+  }
+  function syncInstanceChildren(time) {
+    if (!instance.reversePlayback) {
+      for (var i = 0; i < childrenLength; i++) {
+        seekChild(time, children[i]);
+      }
+    } else {
+      for (var i$1 = childrenLength; i$1--; ) {
+        seekChild(time, children[i$1]);
+      }
+    }
+  }
+  function setAnimationsProgress(insTime) {
+    var i = 0;
+    var animations = instance.animations;
+    var animationsLength = animations.length;
+    while (i < animationsLength) {
+      var anim = animations[i];
+      var animatable = anim.animatable;
+      var tweens = anim.tweens;
+      var tweenLength = tweens.length - 1;
+      var tween = tweens[tweenLength];
+      if (tweenLength) {
+        tween = filterArray(tweens, function(t) {
+          return insTime < t.end;
+        })[0] || tween;
+      }
+      var elapsed = minMax(insTime - tween.start - tween.delay, 0, tween.duration) / tween.duration;
+      var eased = isNaN(elapsed) ? 1 : tween.easing(elapsed);
+      var strings = tween.to.strings;
+      var round = tween.round;
+      var numbers = [];
+      var toNumbersLength = tween.to.numbers.length;
+      var progress = void 0;
+      for (var n = 0; n < toNumbersLength; n++) {
+        var value = void 0;
+        var toNumber = tween.to.numbers[n];
+        var fromNumber = tween.from.numbers[n] || 0;
+        if (!tween.isPath) {
+          value = fromNumber + eased * (toNumber - fromNumber);
+        } else {
+          value = getPathProgress(tween.value, eased * toNumber, tween.isPathTargetInsideSVG);
+        }
+        if (round) {
+          if (!(tween.isColor && n > 2)) {
+            value = Math.round(value * round) / round;
+          }
+        }
+        numbers.push(value);
+      }
+      var stringsLength = strings.length;
+      if (!stringsLength) {
+        progress = numbers[0];
+      } else {
+        progress = strings[0];
+        for (var s = 0; s < stringsLength; s++) {
+          var a = strings[s];
+          var b = strings[s + 1];
+          var n$1 = numbers[s];
+          if (!isNaN(n$1)) {
+            if (!b) {
+              progress += n$1 + " ";
+            } else {
+              progress += n$1 + b;
+            }
+          }
+        }
+      }
+      setProgressValue[anim.type](animatable.target, anim.property, progress, animatable.transforms);
+      anim.currentValue = progress;
+      i++;
+    }
+  }
+  function setCallback(cb) {
+    if (instance[cb] && !instance.passThrough) {
+      instance[cb](instance);
+    }
+  }
+  function countIteration() {
+    if (instance.remaining && instance.remaining !== true) {
+      instance.remaining--;
+    }
+  }
+  function setInstanceProgress(engineTime) {
+    var insDuration = instance.duration;
+    var insDelay = instance.delay;
+    var insEndDelay = insDuration - instance.endDelay;
+    var insTime = adjustTime(engineTime);
+    instance.progress = minMax(insTime / insDuration * 100, 0, 100);
+    instance.reversePlayback = insTime < instance.currentTime;
+    if (children) {
+      syncInstanceChildren(insTime);
+    }
+    if (!instance.began && instance.currentTime > 0) {
+      instance.began = true;
+      setCallback("begin");
+    }
+    if (!instance.loopBegan && instance.currentTime > 0) {
+      instance.loopBegan = true;
+      setCallback("loopBegin");
+    }
+    if (insTime <= insDelay && instance.currentTime !== 0) {
+      setAnimationsProgress(0);
+    }
+    if (insTime >= insEndDelay && instance.currentTime !== insDuration || !insDuration) {
+      setAnimationsProgress(insDuration);
+    }
+    if (insTime > insDelay && insTime < insEndDelay) {
+      if (!instance.changeBegan) {
+        instance.changeBegan = true;
+        instance.changeCompleted = false;
+        setCallback("changeBegin");
+      }
+      setCallback("change");
+      setAnimationsProgress(insTime);
+    } else {
+      if (instance.changeBegan) {
+        instance.changeCompleted = true;
+        instance.changeBegan = false;
+        setCallback("changeComplete");
+      }
+    }
+    instance.currentTime = minMax(insTime, 0, insDuration);
+    if (instance.began) {
+      setCallback("update");
+    }
+    if (engineTime >= insDuration) {
+      lastTime = 0;
+      countIteration();
+      if (!instance.remaining) {
+        instance.paused = true;
+        if (!instance.completed) {
+          instance.completed = true;
+          setCallback("loopComplete");
+          setCallback("complete");
+          if (!instance.passThrough && "Promise" in window) {
+            resolve();
+            promise = makePromise(instance);
+          }
+        }
+      } else {
+        startTime = now;
+        setCallback("loopComplete");
+        instance.loopBegan = false;
+        if (instance.direction === "alternate") {
+          toggleInstanceDirection();
+        }
+      }
+    }
+  }
+  instance.reset = function() {
+    var direction = instance.direction;
+    instance.passThrough = false;
+    instance.currentTime = 0;
+    instance.progress = 0;
+    instance.paused = true;
+    instance.began = false;
+    instance.loopBegan = false;
+    instance.changeBegan = false;
+    instance.completed = false;
+    instance.changeCompleted = false;
+    instance.reversePlayback = false;
+    instance.reversed = direction === "reverse";
+    instance.remaining = instance.loop;
+    children = instance.children;
+    childrenLength = children.length;
+    for (var i = childrenLength; i--; ) {
+      instance.children[i].reset();
+    }
+    if (instance.reversed && instance.loop !== true || direction === "alternate" && instance.loop === 1) {
+      instance.remaining++;
+    }
+    setAnimationsProgress(instance.reversed ? instance.duration : 0);
+  };
+  instance._onDocumentVisibility = resetTime;
+  instance.set = function(targets, properties) {
+    setTargetsValue(targets, properties);
+    return instance;
+  };
+  instance.tick = function(t) {
+    now = t;
+    if (!startTime) {
+      startTime = now;
+    }
+    setInstanceProgress((now + (lastTime - startTime)) * anime.speed);
+  };
+  instance.seek = function(time) {
+    setInstanceProgress(adjustTime(time));
+  };
+  instance.pause = function() {
+    instance.paused = true;
+    resetTime();
+  };
+  instance.play = function() {
+    if (!instance.paused) {
+      return;
+    }
+    if (instance.completed) {
+      instance.reset();
+    }
+    instance.paused = false;
+    activeInstances.push(instance);
+    resetTime();
+    engine();
+  };
+  instance.reverse = function() {
+    toggleInstanceDirection();
+    instance.completed = instance.reversed ? false : true;
+    resetTime();
+  };
+  instance.restart = function() {
+    instance.reset();
+    instance.play();
+  };
+  instance.remove = function(targets) {
+    var targetsArray = parseTargets(targets);
+    removeTargetsFromInstance(targetsArray, instance);
+  };
+  instance.reset();
+  if (instance.autoplay) {
+    instance.play();
+  }
+  return instance;
+}
+function removeTargetsFromAnimations(targetsArray, animations) {
+  for (var a = animations.length; a--; ) {
+    if (arrayContains(targetsArray, animations[a].animatable.target)) {
+      animations.splice(a, 1);
+    }
+  }
+}
+function removeTargetsFromInstance(targetsArray, instance) {
+  var animations = instance.animations;
+  var children = instance.children;
+  removeTargetsFromAnimations(targetsArray, animations);
+  for (var c = children.length; c--; ) {
+    var child = children[c];
+    var childAnimations = child.animations;
+    removeTargetsFromAnimations(targetsArray, childAnimations);
+    if (!childAnimations.length && !child.children.length) {
+      children.splice(c, 1);
+    }
+  }
+  if (!animations.length && !children.length) {
+    instance.pause();
+  }
+}
+function removeTargetsFromActiveInstances(targets) {
+  var targetsArray = parseTargets(targets);
+  for (var i = activeInstances.length; i--; ) {
+    var instance = activeInstances[i];
+    removeTargetsFromInstance(targetsArray, instance);
+  }
+}
+function stagger(val, params) {
+  if (params === void 0)
+    params = {};
+  var direction = params.direction || "normal";
+  var easing = params.easing ? parseEasings(params.easing) : null;
+  var grid = params.grid;
+  var axis = params.axis;
+  var fromIndex = params.from || 0;
+  var fromFirst = fromIndex === "first";
+  var fromCenter = fromIndex === "center";
+  var fromLast = fromIndex === "last";
+  var isRange = is.arr(val);
+  var val1 = isRange ? parseFloat(val[0]) : parseFloat(val);
+  var val2 = isRange ? parseFloat(val[1]) : 0;
+  var unit = getUnit(isRange ? val[1] : val) || 0;
+  var start = params.start || 0 + (isRange ? val1 : 0);
+  var values = [];
+  var maxValue = 0;
+  return function(el, i, t) {
+    if (fromFirst) {
+      fromIndex = 0;
+    }
+    if (fromCenter) {
+      fromIndex = (t - 1) / 2;
+    }
+    if (fromLast) {
+      fromIndex = t - 1;
+    }
+    if (!values.length) {
+      for (var index = 0; index < t; index++) {
+        if (!grid) {
+          values.push(Math.abs(fromIndex - index));
+        } else {
+          var fromX = !fromCenter ? fromIndex % grid[0] : (grid[0] - 1) / 2;
+          var fromY = !fromCenter ? Math.floor(fromIndex / grid[0]) : (grid[1] - 1) / 2;
+          var toX = index % grid[0];
+          var toY = Math.floor(index / grid[0]);
+          var distanceX = fromX - toX;
+          var distanceY = fromY - toY;
+          var value = Math.sqrt(distanceX * distanceX + distanceY * distanceY);
+          if (axis === "x") {
+            value = -distanceX;
+          }
+          if (axis === "y") {
+            value = -distanceY;
+          }
+          values.push(value);
+        }
+        maxValue = Math.max.apply(Math, values);
+      }
+      if (easing) {
+        values = values.map(function(val3) {
+          return easing(val3 / maxValue) * maxValue;
+        });
+      }
+      if (direction === "reverse") {
+        values = values.map(function(val3) {
+          return axis ? val3 < 0 ? val3 * -1 : -val3 : Math.abs(maxValue - val3);
+        });
+      }
+    }
+    var spacing = isRange ? (val2 - val1) / maxValue : val1;
+    return start + spacing * (Math.round(values[i] * 100) / 100) + unit;
+  };
+}
+function timeline(params) {
+  if (params === void 0)
+    params = {};
+  var tl = anime(params);
+  tl.duration = 0;
+  tl.add = function(instanceParams, timelineOffset) {
+    var tlIndex = activeInstances.indexOf(tl);
+    var children = tl.children;
+    if (tlIndex > -1) {
+      activeInstances.splice(tlIndex, 1);
+    }
+    function passThrough(ins2) {
+      ins2.passThrough = true;
+    }
+    for (var i = 0; i < children.length; i++) {
+      passThrough(children[i]);
+    }
+    var insParams = mergeObjects(instanceParams, replaceObjectProps(defaultTweenSettings, params));
+    insParams.targets = insParams.targets || params.targets;
+    var tlDuration = tl.duration;
+    insParams.autoplay = false;
+    insParams.direction = tl.direction;
+    insParams.timelineOffset = is.und(timelineOffset) ? tlDuration : getRelativeValue(timelineOffset, tlDuration);
+    passThrough(tl);
+    tl.seek(insParams.timelineOffset);
+    var ins = anime(insParams);
+    passThrough(ins);
+    children.push(ins);
+    var timings = getInstanceTimings(children, params);
+    tl.delay = timings.delay;
+    tl.endDelay = timings.endDelay;
+    tl.duration = timings.duration;
+    tl.seek(0);
+    tl.reset();
+    if (tl.autoplay) {
+      tl.play();
+    }
+    return tl;
+  };
+  return tl;
+}
+anime.version = "3.2.1";
+anime.speed = 1;
+anime.suspendWhenDocumentHidden = true;
+anime.running = activeInstances;
+anime.remove = removeTargetsFromActiveInstances;
+anime.get = getOriginalTargetValue;
+anime.set = setTargetsValue;
+anime.convertPx = convertPxToUnit;
+anime.path = getPath;
+anime.setDashoffset = setDashoffset;
+anime.stagger = stagger;
+anime.timeline = timeline;
+anime.easing = parseEasings;
+anime.penner = penner;
+anime.random = function(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+var anime_es_default = anime;
+
+// src/utils/anime/anime.ts
+var defaultOptions = {
+  // 动画时间
+  duration: 1e3,
+  // 循环执行
+  loop: false,
+  // 运行速度曲线
+  easing: "easeInOutSine"
+};
+function handleBefore(AnimeParams, extraOptions) {
+  const params = {};
+  if (extraOptions.complete && AnimeParams.complete) {
+    const optionComplete = extraOptions.complete;
+    const animeComplete = AnimeParams.complete;
+    params.complete = (ins) => {
+      optionComplete(ins);
+      animeComplete(ins);
+    };
+  }
+  return { ...AnimeParams, ...extraOptions, ...params };
+}
+function moveToTarget(moveElement, targetElement, extraOpts = {}) {
+  const { left: toLeft, top: toTop } = moveElement.getBoundingClientRect();
+  const { left: clientX, top: clientY } = targetElement.getBoundingClientRect();
+  const x = clientX - toLeft;
+  const y = clientY - toTop;
+  return new Promise((resolve) => {
+    const opts = {
+      targets: moveElement,
+      translateX: x,
+      translateY: y,
+      ...defaultOptions,
+      // 完成回调
+      complete: () => {
+        resolve(true);
+      }
+    };
+    const options = handleBefore(opts, extraOpts);
+    anime_es_default(options);
+  });
+}
+function resize(targets, extraOpts = {}) {
+  return new Promise((resolve) => {
+    const opts = {
+      scale: [1, 0.8, 1],
+      targets,
+      ...defaultOptions,
+      // 完成回调
+      complete: () => {
+        resolve(true);
+      }
+    };
+    const options = handleBefore(opts, extraOpts);
+    anime_es_default(options);
+  });
+}
+
+// src/utils/anime/anime-util/anime-util.ts
+var AnimeUtil = class {
+  /**
+   * 元素移动到指定位置 移动点至指定元素
+   *
+   * @author zk
+   * @date 2024-01-24 09:01:37
+   * @param {Event} event
+   * @param {HTMLElement} toElement
+   * @param {anime.AnimeParams} [options={}]
+   * @return {*}  {Promise<boolean>}
+   * @memberof AnimeUtil
+   */
+  async movePoint(element, tElement, options = {}) {
+    const targetElement = getAnimationElement(tElement);
+    if (!targetElement) {
+      ibiz.log.debug("\u7EC8\u70B9\u5143\u7D20\u4E0D\u5B58\u5728");
+      return false;
+    }
+    const moveElement = cloneElement(element, document.body);
+    if (!moveElement) {
+      ibiz.log.debug("\u52A8\u753B\u5143\u7D20\u4E0D\u5B58\u5728");
+      return false;
+    }
+    const { padding, width, height } = getElementAttribute(moveElement);
+    const option = {
+      borderRadius: ["0%", "50%"],
+      maxWidth: [width, "6px"],
+      maxHeight: [height, "6px"],
+      minWidth: [width, "6px"],
+      minHeight: [height, "6px"],
+      padding: [padding, "6px"],
+      duration: 700
+    };
+    Object.assign(option, options);
+    const result = await moveToTarget(moveElement, targetElement, option);
+    destroyElement(moveElement);
+    return result;
+  }
+  /**
+   * 元素移动动画 元素a 移动到元素b
+   *
+   * @author zk
+   * @date 2024-01-24 06:01:35\
+   * @param {HTMLElement} element
+   * @param {HTMLElement} toElement
+   * @param {IAnimationOptions} [options={}]
+   * @return {*}  {Promise<boolean>}
+   * @memberof AnimeUtil
+   */
+  moveToTarget(element, toElement, options = {}) {
+    return moveToTarget(element, toElement, options);
+  }
+  /**
+   * 目标调整大小
+   *
+   * @author zk
+   * @date 2024-01-22 03:01:42
+   * @param {HTMLElement} target
+   * @param {anime.AnimeParams} [options={}]
+   * @param {IData} [builtInParams={}]
+   */
+  resize(targets, options = {}) {
+    return resize(targets, options);
+  }
+  /**
+   * 目标移动和调整大小
+   *
+   * @author zk
+   * @date 2024-01-24 06:01:15
+   * @param {HTMLElement} element
+   * @param {HTMLElement} toElement
+   * @param {IAnimationOptions} [options={}]
+   * @return {*}  {Promise<boolean>}
+   * @memberof AnimeUtil
+   */
+  async moveAndResize(element, toElement, options = {}) {
+    const result = await this.movePoint(element, toElement, options);
+    if (result) {
+      await this.resize(toElement, { duration: 500 });
+    }
+    return result;
+  }
+};
+
 // src/command/app/open-app-view/open-app-view.ts
 import { ModelError as ModelError15, RuntimeError as RuntimeError24 } from "@ibiz-template/core";
 import { clone as clone17 } from "ramda";
@@ -4648,7 +6256,7 @@ var DynamicCodeListCache = class {
       const { predefinedType } = this.codeList;
       if (predefinedType) {
         this.isPredefined = true;
-        if (!["OPERATOR", "RUNTIME"].includes(predefinedType)) {
+        if (!["OPERATOR", "RUNTIME", "DEMAINSTATE"].includes(predefinedType)) {
           throw new ModelError5(
             this.codeList,
             "\u9884\u5B9A\u4E49\u7C7B\u578B".concat(predefinedType, "\u6682\u4E0D\u652F\u6301")
@@ -4759,8 +6367,11 @@ var DynamicCodeListCache = class {
       tempParams.size = 1e4;
     }
     if (this.isPredefined && this.codeList.codeName) {
-      const index = this.codeList.codeName.indexOf("__");
-      const tag = index !== -1 ? this.codeList.codeName.substring(index + 2) : this.codeList.codeName;
+      let tag = this.codeList.codeName;
+      if (this.codeList.predefinedType === "OPERATOR") {
+        const index = this.codeList.codeName.indexOf("__");
+        tag = index !== -1 ? this.codeList.codeName.substring(index + 2) : this.codeList.codeName;
+      }
       const res2 = await app.net.get(
         "/dictionaries/codelist/".concat(tag),
         tempParams
@@ -4958,14 +6569,13 @@ var DECache = class {
    *
    * @param {*} context
    * @param {IDataEntity} entity
-   * @param {boolean} [ignoreDuplicate=true] 是否忽略主键重复（不忽略报错，忽略则覆盖）
    * @return {*}  {boolean}
    * @memberof EntityCache
    */
-  add(context, entity, ignoreDuplicate = true) {
+  add(context, entity) {
     if (this.isUnionKey) {
       this.calcUnionKey(entity);
-      if (ignoreDuplicate === false && this.checkData(context, entity.srfkey)) {
+      if (this.checkData(context, entity.srfkey)) {
         throw new RuntimeError15(
           "\u65B0\u5EFA\u8054\u5408\u4E3B\u952E\u6570\u636E\u5931\u8D25\uFF0C\u5DF2\u6709\u4E3B\u952E\u4E3A".concat(entity.srfkey, "\u7684\u6570\u636E")
         );
@@ -5019,15 +6629,14 @@ var DECache = class {
    *
    * @param {IContext} context
    * @param {IDataEntity} entity
-   * @param {boolean} [ignoreDuplicate=true] 是否忽略主键重复（不忽略报错，忽略则覆盖）
    * @return {*}  {IDataEntity}
    * @memberof EntityCache
    */
-  update(context, entity, ignoreDuplicate = true) {
+  update(context, entity) {
     const oldKey = entity.srfkey;
     if (this.isUnionKey) {
       this.calcUnionKey(entity);
-      if (ignoreDuplicate === false && oldKey !== entity.srfkey && this.checkData(context, entity.srfkey)) {
+      if (oldKey !== entity.srfkey && this.checkData(context, entity.srfkey)) {
         throw new RuntimeError15(
           "\u66F4\u65B0\u8054\u5408\u4E3B\u952E\u6570\u636E\u5931\u8D25\uFF0C\u5DF2\u6709\u4E3B\u952E\u4E3A".concat(entity.srfkey, "\u7684\u6570\u636E")
         );
@@ -5477,6 +7086,34 @@ function fieldValueToBoolean(value) {
   return [1, "1", true, "true"].includes(value);
 }
 
+// src/service/utils/dyna-sys-params/dyna-sys-params.ts
+async function calcDynaSysParams(appDataEntityId, context, opts = {}) {
+  const appId2 = opts.appId || context.srfappid;
+  const viewParams = opts.viewParams || {};
+  const loadModelParams = {};
+  const appDe = await ibiz.hub.getAppDataEntity(appDataEntityId, appId2);
+  if (viewParams.srfkey) {
+    loadModelParams.srfkey = viewParams.srfkey;
+  } else {
+    const srfkey = context[appDe.codeName.toLowerCase()];
+    if (srfkey) {
+      loadModelParams.srfkey = srfkey;
+    }
+  }
+  if (viewParams.srfparentkey && viewParams.srfparentdeanme) {
+    loadModelParams.srfparentkey = viewParams.srfparentkey;
+    loadModelParams.srfparentdeanme = viewParams.srfparentdeanme;
+  } else {
+    const match = getMatchResPath(context, appDe);
+    if (match && match.keys.length > 1) {
+      const parentDeKey = match.keys[match.keys.length - 2];
+      loadModelParams.srfparentkey = viewParams.srfparentkey || context[parentDeKey];
+      loadModelParams.srfparentdeanme = viewParams.srfparentdeanme || parentDeKey;
+    }
+  }
+  return loadModelParams;
+}
+
 // src/service/service/code-list/code-list.service.ts
 import { RuntimeError as RuntimeError16 } from "@ibiz-template/core";
 var CodeListService = class {
@@ -6459,6 +8096,7 @@ var MethodDto = class {
    * @return {*}  {Promise<IDataEntity[]>}
    */
   async sets(context, data) {
+    const uiDomain = ibiz.uiDomainManager.get(context.srfsessionid);
     return Promise.all(
       data.map(async (datum) => {
         const all = this.fields.filter((field) => field.type === "DTOS").map(async (field) => {
@@ -6469,7 +8107,14 @@ var MethodDto = class {
             if (!field.refAppDataEntityId) {
               return;
             }
+            const configs = uiDomain.getDERConfig(field.refAppDataEntityId);
+            const deRs = configs.find((rs) => {
+              return rs.majorAppDataEntityId === this.entity.id;
+            });
             const dto = await this.getFieldDto(context, field);
+            if (!deRs) {
+              dto.service.local.clear();
+            }
             const items = datum[key];
             if (items && items.length > 0) {
               const pKey = datum[this.entity.keyAppDEFieldId];
@@ -7575,6 +9220,9 @@ var V7AuthService = class {
               true
             );
           }
+          ibiz.hub.getAllApps().forEach((app) => {
+            app.initMqtt();
+          });
         }
         this.extendLogin();
       }, wait);
@@ -9173,18 +10821,13 @@ var DEActionMethod = class extends Method {
       if (isArray6(addData)) {
         resultData = await Promise.all(
           addData.map(
-            (item) => this.service.local.add(
-              context,
-              this.attach(context, item),
-              false
-            )
+            (item) => this.service.local.add(context, this.attach(context, item))
           )
         );
       } else {
         resultData = await this.service.local.add(
           context,
-          this.attach(context, addData),
-          false
+          this.attach(context, addData)
         );
       }
       return new HttpResponse3(resultData);
@@ -9356,18 +10999,13 @@ var DEActionMethod = class extends Method {
       if (isArray6(updateData)) {
         resultData = await Promise.all(
           updateData.map(
-            (item) => this.service.local.update(
-              context,
-              this.attach(context, item),
-              false
-            )
+            (item) => this.service.local.update(context, this.attach(context, item))
           )
         );
       } else {
         resultData = await this.service.local.update(
           context,
-          this.attach(context, updateData),
-          false
+          this.attach(context, updateData)
         );
       }
       if (resultData) {
@@ -9798,6 +11436,9 @@ var TreeDataSetNodeData = class _TreeDataSetNodeData extends TreeNodeData {
     const dataItemKeyMap = /* @__PURE__ */ new Map();
     const dataItemDefaultMap = /* @__PURE__ */ new Map();
     (_a = model.detreeNodeDataItems) == null ? void 0 : _a.forEach((dataItem) => {
+      if (!dataItem.appDEFieldId) {
+        return;
+      }
       const dataItemKey = dataItem.id.toLowerCase();
       const deFieldKey = dataItem.appDEFieldId.toLowerCase();
       dataItemKeyMap.set(dataItemKey, deFieldKey);
@@ -9807,6 +11448,9 @@ var TreeDataSetNodeData = class _TreeDataSetNodeData extends TreeNodeData {
     });
     const nodeColumnKeyMap = /* @__PURE__ */ new Map();
     (_b = model.detreeNodeColumns) == null ? void 0 : _b.forEach((column) => {
+      if (column.columnType !== "DEFGRIDCOLUMN") {
+        return;
+      }
       const columnKey = column.detreeColumnId;
       const dataItemKey = column.dataItemName;
       if (!columnKey || !dataItemKey) {
@@ -10505,6 +12149,7 @@ var MqttService = class {
   close() {
     var _a;
     (_a = this.client) == null ? void 0 : _a.end();
+    this.evt.reset();
   }
 };
 
@@ -11034,17 +12679,7 @@ var Application = class {
   async init() {
     await this.authority.init();
     await this.loadAppModelStyle();
-    if (ibiz.env.enableMqtt && ibiz.appData && ibiz.appData.mqtttopic && ibiz.auth.isAnonymous !== true) {
-      this.mqtt = new MqttService(
-        ibiz.appData.mqtttopic,
-        getToken(),
-        this.model.appId
-      );
-      this.mqtt.evt.on("message", (message) => {
-        ibiz.mc.command.asyncAction.next(message);
-      });
-      await this.mqtt.connect();
-    }
+    await this.initMqtt();
   }
   /**
    * 加载应用模型全局样式
@@ -11140,6 +12775,28 @@ var Application = class {
       return logic.id === deUILogicId;
     });
   }
+  /**
+   * 初始化Mqtt服务
+   * @author lxm
+   * @date 2024-01-25 10:47:06
+   * @return {*}  {Promise<void>}
+   */
+  async initMqtt() {
+    if (this.mqtt) {
+      this.mqtt.close();
+    }
+    if (ibiz.env.enableMqtt && ibiz.appData && ibiz.appData.mqtttopic && ibiz.auth.isAnonymous !== true) {
+      this.mqtt = new MqttService(
+        ibiz.appData.mqtttopic,
+        getToken(),
+        this.model.appId
+      );
+      this.mqtt.evt.on("message", (message) => {
+        ibiz.mc.command.asyncAction.next(message);
+      });
+      await this.mqtt.connect();
+    }
+  }
 };
 
 // src/hub/convert/app-menu-convert/app-menu-convert.ts
@@ -12758,12 +14415,12 @@ var ViewController = class extends BaseController {
   initEngines() {
     const engineModels = getViewEngines(this.model);
     if (engineModels.length) {
-      engineModels.forEach((engine) => {
-        const ins = ibiz.engine.getEngine(engine, this);
+      engineModels.forEach((engine2) => {
+        const ins = ibiz.engine.getEngine(engine2, this);
         if (ins) {
           this.engines.push(ins);
         } else {
-          ibiz.log.warn("\u672A\u627E\u5230\u89C6\u56FE\u5F15\u64CE\u5B9E\u73B0\uFF1A", engine);
+          ibiz.log.warn("\u672A\u627E\u5230\u89C6\u56FE\u5F15\u64CE\u5B9E\u73B0\uFF1A", engine2);
         }
       });
     } else {
@@ -12854,14 +14511,14 @@ var ViewController = class extends BaseController {
     }
     this.initViewMsg();
     if (this.engines.length) {
-      await Promise.all(this.engines.map((engine) => engine.onCreated()));
+      await Promise.all(this.engines.map((engine2) => engine2.onCreated()));
     }
   }
   async onMounted() {
     var _a;
     await super.onMounted();
     if (this.engines.length) {
-      await Promise.all(this.engines.map((engine) => engine.onMounted()));
+      await Promise.all(this.engines.map((engine2) => engine2.onMounted()));
     }
     (_a = this.scheduler) == null ? void 0 : _a.startTimerTrigger();
   }
@@ -12869,7 +14526,7 @@ var ViewController = class extends BaseController {
     const srfSessionId = this.context.srfsessionid;
     await super.onDestroyed();
     if (this.engines.length) {
-      await Promise.all(this.engines.map((engine) => engine.onDestroyed()));
+      await Promise.all(this.engines.map((engine2) => engine2.onDestroyed()));
     }
     Object.values(this.counters).forEach((counter) => counter.destroy());
     this.ctx.destroy();
@@ -12914,8 +14571,8 @@ var ViewController = class extends BaseController {
   }
   async call(key, args) {
     let result;
-    for (const engine of this.engines) {
-      result = await engine.call(key, args);
+    for (const engine2 of this.engines) {
+      result = await engine2.call(key, args);
       if (result !== void 0) {
         break;
       }
@@ -13168,6 +14825,11 @@ var EditorController = class {
         this.style.height = "".concat(height, "px");
       }
     }
+    if (this.model.editorItems) {
+      this.model.editorItems = this.model.editorItems.filter(
+        (item) => item.id !== this.model.id
+      );
+    }
   }
   /**
    * 公共参数处理，计算上下文和视图参数
@@ -14585,13 +16247,13 @@ import { RuntimeModelError as RuntimeModelError29 } from "@ibiz-template/core";
 // src/controller/control/chart/generator/base-series-generator.ts
 import { plus, RuntimeModelError as RuntimeModelError28, toNumberOrNil } from "@ibiz-template/core";
 import dayjs4 from "dayjs";
-import minMax from "dayjs/plugin/minMax";
+import minMax2 from "dayjs/plugin/minMax";
 import isSameOrBefore from "dayjs/plugin/isSameOrBefore";
 import quarterOfYear from "dayjs/plugin/quarterOfYear";
 import weekOfYear from "dayjs/plugin/weekOfYear";
 import isoWeek from "dayjs/plugin/isoWeek";
 import { clone as clone19, isNil as isNil22, mergeDeepRight } from "ramda";
-dayjs4.extend(minMax);
+dayjs4.extend(minMax2);
 dayjs4.extend(isSameOrBefore);
 dayjs4.extend(quarterOfYear);
 dayjs4.extend(weekOfYear);
@@ -17164,6 +18826,43 @@ var UIActionUtil = class {
         default:
       }
     }
+    const action = await getUIActionById(actionId, appId2);
+    if (action.asyncAction && !result.cancel) {
+      this.handleAsyncAction(params.event);
+    }
+  }
+  /**
+   * 处理异步行为
+   *
+   * @author zk
+   * @date 2024-01-23 11:01:58
+   * @static
+   * @param {(Event | undefined)} event
+   * @return {*}  {Promise<void>}
+   * @memberof UIActionUtil
+   */
+  static async handleAsyncAction(event) {
+    this.handleAsyncActionAnime(event);
+  }
+  /**
+   * 处理异步行为动画
+   *
+   * @author zk
+   * @date 2024-01-24 04:01:29
+   * @private
+   * @static
+   * @param {(Event | undefined)} event
+   * @return {*}  {Promise<void>}
+   * @memberof UIActionUtil
+   */
+  static async handleAsyncActionAnime(event) {
+    if (!event || !event.target) {
+      return;
+    }
+    await ibiz.util.anime.moveAndResize(
+      event.target,
+      "#".concat("preset-message" /* MESSAGE */)
+    );
   }
 };
 
@@ -28853,10 +30552,10 @@ var KanbanController = class extends DataViewControlController {
       } else {
         if (lastSort >= item[sortField]) {
           if (cacheArr.length > 0) {
-            cacheArr.forEach((cache) => {
-              cache[sortField] = getNextSort(cacheLastSort);
-              modifiedItems.push(cache);
-              cacheLastSort = cache[sortField];
+            cacheArr.forEach((cache2) => {
+              cache2[sortField] = getNextSort(cacheLastSort);
+              modifiedItems.push(cache2);
+              cacheLastSort = cache2[sortField];
             });
             lastSort = cacheLastSort;
             cacheLastSort = 0;
@@ -30051,8 +31750,60 @@ var TreeGridExFieldColumnController = class extends TreeGridExColumnController {
 };
 
 // src/controller/control/tree-grid-ex/tree-grid-ex-column/tree-grid-ex-ua-column/tree-grid-ex-ua-column.controller.ts
-import { RuntimeModelError as RuntimeModelError69 } from "@ibiz-template/core";
 var TreeGridExUAColumnController = class extends TreeGridExColumnController {
+  constructor() {
+    super(...arguments);
+    /**
+     * 该树表格列对应不同节点模型的节点列控制器
+     * @author lxm
+     * @date 2024-01-08 05:40:56
+     * @type {Map<string, IDETreeNodeUAColumn>}
+     */
+    this.nodeColumnMap = /* @__PURE__ */ new Map();
+  }
+  async init() {
+    await this.onInit();
+    await this.initNodeColumnMap();
+  }
+  /**
+   * 解析模型初始化节点对应的节点列模型
+   * @author lxm
+   * @date 2024-01-24 02:41:05
+   */
+  initNodeColumnMap() {
+    var _a;
+    (_a = this.treeGrid.model.detreeNodes) == null ? void 0 : _a.forEach((node) => {
+      var _a2;
+      if (node.treeNodeType !== "DE") {
+        return;
+      }
+      const nodeColumn = (_a2 = node.detreeNodeColumns) == null ? void 0 : _a2.find(
+        (column) => {
+          return column.detreeColumnId === this.model.id;
+        }
+      );
+      if (nodeColumn) {
+        this.nodeColumnMap.set(node.id, nodeColumn);
+      }
+    });
+  }
+  /**
+   * 获取界面行为组mode
+   * @author lxm
+   * @date 2024-01-24 04:13:03
+   * @param {ITreeGridExRowState} row
+   * @return {*}  {(IUIActionGroup | undefined)}
+   */
+  getUIActionGroup(row) {
+    let { deuiactionGroup } = this.model;
+    if (row.data._nodeType === "DE" && this.nodeColumnMap.get(row.data._nodeId)) {
+      const nodeColumn = this.nodeColumnMap.get(row.data._nodeId);
+      if (nodeColumn.deuiactionGroup) {
+        deuiactionGroup = nodeColumn.deuiactionGroup;
+      }
+    }
+    return deuiactionGroup;
+  }
   /**
    * 给rowController初始化操作列的状态
    *
@@ -30062,10 +31813,10 @@ var TreeGridExUAColumnController = class extends TreeGridExColumnController {
    */
   initActionStates(row) {
     var _a;
-    const { deuiactionGroup } = this.model;
+    const deuiactionGroup = this.getUIActionGroup(row);
     if (!deuiactionGroup) {
+      ibiz.log.warn("".concat(this.model.id, "\u64CD\u4F5C\u5217\u6CA1\u6709\u914D\u7F6E\u754C\u9762\u884C\u4E3A\u7EC4"));
       return;
-      throw new RuntimeModelError69(this.model, "\u64CD\u4F5C\u5217\u6CA1\u6709\u914D\u7F6E\u754C\u9762\u884C\u4E3A\u7EC4");
     }
     if (!((_a = deuiactionGroup.uiactionGroupDetails) == null ? void 0 : _a.length)) {
       ibiz.log.debug("\u64CD\u4F5C\u5217\u754C\u9762\u884C\u4E3A\u7EC4\u6CA1\u6709\u914D\u7F6E\u754C\u9762\u884C\u4E3A");
@@ -30119,7 +31870,7 @@ var TreeGridExUAColumnController = class extends TreeGridExColumnController {
 };
 
 // src/controller/control/tree-grid/tree-grid.controller.ts
-import { RuntimeModelError as RuntimeModelError70 } from "@ibiz-template/core";
+import { RuntimeModelError as RuntimeModelError69 } from "@ibiz-template/core";
 var TreeGridController = class extends GridController {
   constructor() {
     super(...arguments);
@@ -30164,10 +31915,10 @@ var TreeGridController = class extends GridController {
       return item.treeColumnMode === 2 || item.treeColumnMode === 3;
     });
     if (!treeGridParent) {
-      throw new RuntimeModelError70(this.model, "\u6811\u8868\u683C\u65E0\u503C\u5217\u6A21\u5F0F");
+      throw new RuntimeModelError69(this.model, "\u6811\u8868\u683C\u65E0\u503C\u5217\u6A21\u5F0F");
     }
     if (!treeGridValue) {
-      throw new RuntimeModelError70(this.model, "\u6811\u8868\u683C\u65E0\u7236\u503C\u5217\u6A21\u5F0F");
+      throw new RuntimeModelError69(this.model, "\u6811\u8868\u683C\u65E0\u7236\u503C\u5217\u6A21\u5F0F");
     }
     this.treeGridValueField = treeGridValue.appDEFieldId.toLowerCase();
     this.treeGridParentField = treeGridParent.appDEFieldId.toLowerCase();
@@ -31651,8 +33402,8 @@ var EngineFactory = class {
    * @param {string} key
    * @param {IViewEngine} engine
    */
-  register(key, engine) {
-    this.viewEngines.set(key, engine);
+  register(key, engine2) {
+    this.viewEngines.set(key, engine2);
   }
   /**
    * 注销视图引擎
@@ -31892,7 +33643,7 @@ var ViewEngineBase = class {
 };
 
 // src/engine/md-view.engine.ts
-import { RuntimeModelError as RuntimeModelError71 } from "@ibiz-template/core";
+import { RuntimeModelError as RuntimeModelError70 } from "@ibiz-template/core";
 import { clone as clone30 } from "ramda";
 var MDViewEngine = class extends ViewEngineBase {
   /**
@@ -32080,7 +33831,7 @@ var MDViewEngine = class extends ViewEngineBase {
       view: this.view
     }));
     if (result === -1) {
-      throw new RuntimeModelError71(this.view.model, "\u7F3A\u5C11newdata\u7684\u89C6\u56FE\u903B\u8F91");
+      throw new RuntimeModelError70(this.view.model, "\u7F3A\u5C11newdata\u7684\u89C6\u56FE\u903B\u8F91");
     } else {
       return {
         cancel: !result.ok
@@ -32103,7 +33854,7 @@ var MDViewEngine = class extends ViewEngineBase {
       (item) => item.id === "newdata"
     );
     if (!openAppViewLogic) {
-      throw new RuntimeModelError71(this.view.model, "\u7F3A\u5C11newdata\u7684\u89C6\u56FE\u903B\u8F91");
+      throw new RuntimeModelError70(this.view.model, "\u7F3A\u5C11newdata\u7684\u89C6\u56FE\u903B\u8F91");
     }
     const params = clone30(this.view.params);
     if (copyMode) {
@@ -32117,7 +33868,7 @@ var MDViewEngine = class extends ViewEngineBase {
       view: this.view
     }));
     if (result === -1) {
-      throw new RuntimeModelError71(this.view.model, "\u7F3A\u5C11newdata\u7684\u89C6\u56FE\u903B\u8F91");
+      throw new RuntimeModelError70(this.view.model, "\u7F3A\u5C11newdata\u7684\u89C6\u56FE\u903B\u8F91");
     } else {
       return {
         cancel: !result.ok
@@ -32292,6 +34043,14 @@ var GlobalUtil = class {
      * @date 2024-01-18 14:01:23
      */
     this.viewStack = new ViewStack();
+    /**
+     * 动画工具类
+     *
+     * @author zk
+     * @date 2024-01-22 09:01:33
+     * @memberof GlobalUtil
+     */
+    this.anime = new AnimeUtil();
     this.error.register(new DefaultErrorHandler());
   }
   /**
@@ -32435,13 +34194,13 @@ var ScriptExecutor = class extends LogicExecutor {
 };
 
 // src/logic-scheduler/executor/app-de-ui-logic-executor.ts
-import { RuntimeModelError as RuntimeModelError72 } from "@ibiz-template/core";
+import { RuntimeModelError as RuntimeModelError71 } from "@ibiz-template/core";
 var AppDEUILogicExecutor = class extends LogicExecutor {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   execute(executeParams) {
     const { appDEUILogicId, appDataEntityId } = this.logic;
     if (!appDEUILogicId) {
-      throw new RuntimeModelError72(this.logic, "\u6CA1\u6709\u914D\u7F6E\u5B9E\u4F53\u754C\u9762\u903B\u8F91");
+      throw new RuntimeModelError71(this.logic, "\u6CA1\u6709\u914D\u7F6E\u5B9E\u4F53\u754C\u9762\u903B\u8F91");
     }
     execUILogic(appDEUILogicId, appDataEntityId, executeParams);
   }
@@ -32899,7 +34658,7 @@ var ItemDynaLogicTrigger = class extends LogicTrigger {
 };
 
 // src/logic-scheduler/trigger/timer-trigger.ts
-import { RuntimeError as RuntimeError69, RuntimeModelError as RuntimeModelError73 } from "@ibiz-template/core";
+import { RuntimeError as RuntimeError69, RuntimeModelError as RuntimeModelError72 } from "@ibiz-template/core";
 var TimerTrigger = class extends LogicTrigger {
   constructor() {
     super(...arguments);
@@ -32907,7 +34666,7 @@ var TimerTrigger = class extends LogicTrigger {
   }
   start() {
     if (!this.logic.timer) {
-      throw new RuntimeModelError73(this.logic, "\u5B9A\u65F6\u5668\u7F3A\u5C11\u5B9A\u65F6\u95F4\u9694");
+      throw new RuntimeModelError72(this.logic, "\u5B9A\u65F6\u5668\u7F3A\u5C11\u5B9A\u65F6\u95F4\u9694");
     }
     this.timer = setInterval(() => {
       if (!this.scheduler.defaultParamsCb) {
@@ -32929,7 +34688,7 @@ var TimerTrigger = class extends LogicTrigger {
 import {
   ModelError as ModelError34,
   RuntimeError as RuntimeError70,
-  RuntimeModelError as RuntimeModelError74
+  RuntimeModelError as RuntimeModelError73
 } from "@ibiz-template/core";
 import { notNilEmpty as notNilEmpty9 } from "qx-util";
 var AppUILogicExecutor = class extends LogicExecutor {
@@ -32975,7 +34734,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
     } else {
       openViewRef = appUILogic.openDataAppView;
       if (!openViewRef) {
-        throw new RuntimeModelError74(
+        throw new RuntimeModelError73(
           appUILogic,
           "opendata\u89C6\u56FE\u903B\u8F91\u6CA1\u6709\u914D\u7F6E\u9ED8\u8BA4\u6253\u5F00\u89C6\u56FE"
         );
@@ -32983,7 +34742,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
     }
     const openView = openViewRef.refAppViewId;
     if (!openView) {
-      throw new RuntimeModelError74(
+      throw new RuntimeModelError73(
         appUILogic,
         "opendata\u89C6\u56FE\u903B\u8F91\u7684\u9ED8\u8BA4\u6253\u5F00\u89C6\u56FE\u6CA1\u6709\u5B9E\u9645\u5F15\u7528\u89C6\u56FE"
       );
@@ -33013,7 +34772,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
     );
     const typeFileName = appDataEntity.formTypeAppDEFieldId || appDataEntity.dataTypeAppDEFieldId;
     if (!typeFileName) {
-      throw new RuntimeModelError74(
+      throw new RuntimeModelError73(
         appUILogic,
         "".concat(appDataEntity.codeName, "[\u591A\u8868\u5355\u5B9E\u4F53] or [\u7D22\u5F15\u5B9E\u4F53]\u7F3A\u5C11\u7C7B\u578B\u5C5E\u6027\u914D\u7F6E")
       );
@@ -33021,7 +34780,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
     const { data } = parameters;
     const formTypeValue = data[0][typeFileName];
     if (!formTypeValue) {
-      throw new RuntimeModelError74(appUILogic, "\u6570\u636E\u6E90\u65E0\u8868\u5355\u7C7B\u578B\u5E94\u7528\u5B9E\u4F53\u5C5E\u6027\u503C");
+      throw new RuntimeModelError73(appUILogic, "\u6570\u636E\u6E90\u65E0\u8868\u5355\u7C7B\u578B\u5E94\u7528\u5B9E\u4F53\u5C5E\u6027\u503C");
     }
     const openViewRefs = appUILogic.openDataAppViews;
     const findView = openViewRefs == null ? void 0 : openViewRefs.find((item) => item.refMode === formTypeValue);
@@ -33063,7 +34822,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
         return viewRef.refMode.toLowerCase() !== parentDeName;
       });
       if (!newViewRef) {
-        throw new RuntimeModelError74(
+        throw new RuntimeModelError73(
           appUILogic,
           "\u6CA1\u6709\u627E\u5230\u6279\u6DFB\u52A0\u9700\u8981\u6253\u5F00\u7684\u9009\u62E9\u89C6\u56FE"
         );
@@ -33073,7 +34832,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
     } else {
       newViewRef = newDataAppView;
       if (!newViewRef || !newViewRef.refAppViewId) {
-        throw new RuntimeModelError74(
+        throw new RuntimeModelError73(
           appUILogic,
           "newdata\u89C6\u56FE\u903B\u8F91\u6CA1\u6709\u914D\u7F6E\u9ED8\u8BA4\u65B0\u5EFA\u6570\u636E\u89C6\u56FE"
         );
@@ -33137,7 +34896,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
     const { wizardAppView, newDataAppViews } = appUILogic;
     const { context, params, ...rest } = parameters;
     if (!wizardAppView || !wizardAppView.refAppViewId) {
-      throw new RuntimeModelError74(appUILogic, "\u7F3A\u5C11\u9ED8\u8BA4\u7D22\u5F15\u5B9E\u4F53\u9009\u62E9\u89C6\u56FE");
+      throw new RuntimeModelError73(appUILogic, "\u7F3A\u5C11\u9ED8\u8BA4\u7D22\u5F15\u5B9E\u4F53\u9009\u62E9\u89C6\u56FE");
     }
     const result = await ibiz.commands.execute(
       OpenAppViewCommand.TAG,
@@ -33188,7 +34947,7 @@ var AppUILogicExecutor = class extends LogicExecutor {
       const minorDERs = selfDe.minorAppDERSs;
       const pickParentDeName = newViewRef.refMode.toLowerCase();
       if (!minorDERs) {
-        throw new RuntimeModelError74(selfDe, "\u5B9E\u4F53\u6CA1\u6709\u4ECE\u5173\u7CFB\u96C6\u5408\uFF01");
+        throw new RuntimeModelError73(selfDe, "\u5B9E\u4F53\u6CA1\u6709\u4ECE\u5173\u7CFB\u96C6\u5408\uFF01");
       }
       let pickParentFieldName = "";
       minorDERs == null ? void 0 : minorDERs.forEach((item) => {
@@ -33285,12 +35044,12 @@ var ControlEventTrigger = class extends LogicTrigger {
 };
 
 // src/logic-scheduler/executor/app-ui-action-executor.ts
-import { RuntimeModelError as RuntimeModelError75 } from "@ibiz-template/core";
+import { RuntimeModelError as RuntimeModelError74 } from "@ibiz-template/core";
 var AppDEUIActionExecutor = class extends LogicExecutor {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   execute(executeParams) {
     if (!this.logic.appDEUIActionId) {
-      throw new RuntimeModelError75(
+      throw new RuntimeModelError74(
         this.logic,
         "\u903B\u8F91\u4E2D\u7F3A\u5C11\u89E6\u53D1\u5E94\u7528\u5B9E\u4F53\u754C\u9762\u884C\u4E3Aid"
       );
@@ -33468,6 +35227,7 @@ export {
   AcFetchMethod,
   ActionBarPortletController,
   ActivityCounter,
+  AnimeUtil,
   AppCounter,
   AppDECounter,
   AppDECounterProvider,
@@ -33618,6 +35378,7 @@ export {
   PluginStaticResource,
   PortletPartController,
   PortletPartState,
+  PresetIdentifier,
   QXEventEx,
   RawItemPortletController,
   RawValueUtil,
@@ -33690,6 +35451,7 @@ export {
   calcContentAlignStyle,
   calcDeCodeNameById,
   calcDynaClass,
+  calcDynaSysParams,
   calcGridLayoutPos,
   calcLayoutHeightWidth,
   calcMainStateOPPrivsStrs,