agentworkshop 0.8.2 → 0.8.4

package/.output/server/chunks/build/firstNotUndefined-laiThpLD.mjs

@@ -0,0 +1,2082 @@
+import { z as filterEmpty, al as getSlot, ar as getEvents, as as contains, q as classNames, p as cloneElement, o as _extends, ao as PortalWrapper_default, at as hasProp, au as getComponent, av as findDOMNode, aw as addEventListenerWrap, ax as useProvidePortal, ay as getOptionProps, r as _objectSpread2$1, P as PropTypes, m as flattenChildren, az as getMotion, s as getTransitionProps, aA as supportsPassive_default } from '../virtual/entry.mjs';
+import { ref, unref, watchEffect, watch, defineComponent, createVNode, Fragment, provide, computed, shallowRef, inject, toRaw, nextTick, Transition, toRef, withDirectives, withModifiers, vShow, resolveDirective } from 'vue';
+
+var MapShim = (function() {
+  if (typeof Map !== "undefined") return Map;
+  function getIndex(arr, key) {
+    var result = -1;
+    arr.some(function(entry, index2) {
+      if (entry[0] === key) {
+        result = index2;
+        return true;
+      }
+      return false;
+    });
+    return result;
+  }
+  return (function() {
+    function class_1() {
+      this.__entries__ = [];
+    }
+    Object.defineProperty(class_1.prototype, "size", {
+      /**
+      * @returns {boolean}
+      */
+      get: function() {
+        return this.__entries__.length;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    class_1.prototype.get = function(key) {
+      var index2 = getIndex(this.__entries__, key);
+      var entry = this.__entries__[index2];
+      return entry && entry[1];
+    };
+    class_1.prototype.set = function(key, value) {
+      var index2 = getIndex(this.__entries__, key);
+      if (~index2) this.__entries__[index2][1] = value;
+      else this.__entries__.push([key, value]);
+    };
+    class_1.prototype.delete = function(key) {
+      var entries = this.__entries__;
+      var index2 = getIndex(entries, key);
+      if (~index2) entries.splice(index2, 1);
+    };
+    class_1.prototype.has = function(key) {
+      return !!~getIndex(this.__entries__, key);
+    };
+    class_1.prototype.clear = function() {
+      this.__entries__.splice(0);
+    };
+    class_1.prototype.forEach = function(callback, ctx) {
+      if (ctx === void 0) ctx = null;
+      for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
+        var entry = _a[_i];
+        callback.call(ctx, entry[1], entry[0]);
+      }
+    };
+    return class_1;
+  })();
+})();
+var global$1 = (function() {
+  if (typeof global !== "undefined" && global.Math === Math) return global;
+  if (typeof self !== "undefined" && self.Math === Math) return self;
+  return Function("return this")();
+})();
+var requestAnimationFrame$1 = (function() {
+  if (typeof requestAnimationFrame === "function") return requestAnimationFrame.bind(global$1);
+  return function(callback) {
+    return setTimeout(function() {
+      return callback(Date.now());
+    }, 1e3 / 60);
+  };
+})();
+var trailingTimeout = 2;
+function throttle(callback, delay) {
+  var leadingCall = false, trailingCall = false, lastCallTime = 0;
+  function resolvePending() {
+    if (leadingCall) {
+      leadingCall = false;
+      callback();
+    }
+    if (trailingCall) proxy();
+  }
+  function timeoutCallback() {
+    requestAnimationFrame$1(resolvePending);
+  }
+  function proxy() {
+    var timeStamp = Date.now();
+    if (leadingCall) {
+      if (timeStamp - lastCallTime < trailingTimeout) return;
+      trailingCall = true;
+    } else {
+      leadingCall = true;
+      trailingCall = false;
+      setTimeout(timeoutCallback, delay);
+    }
+    lastCallTime = timeStamp;
+  }
+  return proxy;
+}
+var REFRESH_DELAY = 20;
+var transitionKeys = [
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "width",
+  "height",
+  "size",
+  "weight"
+];
+var ResizeObserverController = (function() {
+  function ResizeObserverController2() {
+    this.connected_ = false;
+    this.mutationEventsAdded_ = false;
+    this.mutationsObserver_ = null;
+    this.observers_ = [];
+    this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
+    this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
+  }
+  ResizeObserverController2.prototype.addObserver = function(observer) {
+    if (!~this.observers_.indexOf(observer)) this.observers_.push(observer);
+    if (!this.connected_) this.connect_();
+  };
+  ResizeObserverController2.prototype.removeObserver = function(observer) {
+    var observers2 = this.observers_;
+    var index2 = observers2.indexOf(observer);
+    if (~index2) observers2.splice(index2, 1);
+    if (!observers2.length && this.connected_) this.disconnect_();
+  };
+  ResizeObserverController2.prototype.refresh = function() {
+    if (this.updateObservers_()) this.refresh();
+  };
+  ResizeObserverController2.prototype.updateObservers_ = function() {
+    var activeObservers = this.observers_.filter(function(observer) {
+      return observer.gatherActive(), observer.hasActive();
+    });
+    activeObservers.forEach(function(observer) {
+      return observer.broadcastActive();
+    });
+    return activeObservers.length > 0;
+  };
+  ResizeObserverController2.prototype.connect_ = function() {
+    return;
+  };
+  ResizeObserverController2.prototype.disconnect_ = function() {
+    return;
+  };
+  ResizeObserverController2.prototype.onTransitionEnd_ = function(_a) {
+    var _b = _a.propertyName, propertyName = _b === void 0 ? "" : _b;
+    if (transitionKeys.some(function(key) {
+      return !!~propertyName.indexOf(key);
+    })) this.refresh();
+  };
+  ResizeObserverController2.getInstance = function() {
+    if (!this.instance_) this.instance_ = new ResizeObserverController2();
+    return this.instance_;
+  };
+  ResizeObserverController2.instance_ = null;
+  return ResizeObserverController2;
+})();
+var defineConfigurable = (function(target, props) {
+  for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {
+    var key = _a[_i];
+    Object.defineProperty(target, key, {
+      value: props[key],
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  }
+  return target;
+});
+var getWindowOf = (function(target) {
+  return target && target.ownerDocument && target.ownerDocument.defaultView || global$1;
+});
+var emptyRect = createRectInit(0, 0, 0, 0);
+function getContentRect(target) {
+  return emptyRect;
+}
+function createReadOnlyRect(_a) {
+  var x = _a.x, y = _a.y, width = _a.width, height = _a.height;
+  var rect = Object.create((typeof DOMRectReadOnly !== "undefined" ? DOMRectReadOnly : Object).prototype);
+  defineConfigurable(rect, {
+    x,
+    y,
+    width,
+    height,
+    top: y,
+    right: x + width,
+    bottom: height + y,
+    left: x
+  });
+  return rect;
+}
+function createRectInit(x, y, width, height) {
+  return {
+    x,
+    y,
+    width,
+    height
+  };
+}
+var ResizeObservation = (function() {
+  function ResizeObservation2(target) {
+    this.broadcastWidth = 0;
+    this.broadcastHeight = 0;
+    this.contentRect_ = createRectInit(0, 0, 0, 0);
+    this.target = target;
+  }
+  ResizeObservation2.prototype.isActive = function() {
+    var rect = getContentRect(this.target);
+    this.contentRect_ = rect;
+    return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
+  };
+  ResizeObservation2.prototype.broadcastRect = function() {
+    var rect = this.contentRect_;
+    this.broadcastWidth = rect.width;
+    this.broadcastHeight = rect.height;
+    return rect;
+  };
+  return ResizeObservation2;
+})();
+var ResizeObserverEntry = /* @__PURE__ */ (function() {
+  function ResizeObserverEntry2(target, rectInit) {
+    var contentRect = createReadOnlyRect(rectInit);
+    defineConfigurable(this, {
+      target,
+      contentRect
+    });
+  }
+  return ResizeObserverEntry2;
+})();
+var ResizeObserverSPI = (function() {
+  function ResizeObserverSPI2(callback, controller, callbackCtx) {
+    this.activeObservations_ = [];
+    this.observations_ = new MapShim();
+    if (typeof callback !== "function") throw new TypeError("The callback provided as parameter 1 is not a function.");
+    this.callback_ = callback;
+    this.controller_ = controller;
+    this.callbackCtx_ = callbackCtx;
+  }
+  ResizeObserverSPI2.prototype.observe = function(target) {
+    if (!arguments.length) throw new TypeError("1 argument required, but only 0 present.");
+    if (typeof Element === "undefined" || !(Element instanceof Object)) return;
+    if (!(target instanceof getWindowOf(target).Element)) throw new TypeError('parameter 1 is not of type "Element".');
+    var observations = this.observations_;
+    if (observations.has(target)) return;
+    observations.set(target, new ResizeObservation(target));
+    this.controller_.addObserver(this);
+    this.controller_.refresh();
+  };
+  ResizeObserverSPI2.prototype.unobserve = function(target) {
+    if (!arguments.length) throw new TypeError("1 argument required, but only 0 present.");
+    if (typeof Element === "undefined" || !(Element instanceof Object)) return;
+    if (!(target instanceof getWindowOf(target).Element)) throw new TypeError('parameter 1 is not of type "Element".');
+    var observations = this.observations_;
+    if (!observations.has(target)) return;
+    observations.delete(target);
+    if (!observations.size) this.controller_.removeObserver(this);
+  };
+  ResizeObserverSPI2.prototype.disconnect = function() {
+    this.clearActive();
+    this.observations_.clear();
+    this.controller_.removeObserver(this);
+  };
+  ResizeObserverSPI2.prototype.gatherActive = function() {
+    var _this = this;
+    this.clearActive();
+    this.observations_.forEach(function(observation) {
+      if (observation.isActive()) _this.activeObservations_.push(observation);
+    });
+  };
+  ResizeObserverSPI2.prototype.broadcastActive = function() {
+    if (!this.hasActive()) return;
+    var ctx = this.callbackCtx_;
+    var entries = this.activeObservations_.map(function(observation) {
+      return new ResizeObserverEntry(observation.target, observation.broadcastRect());
+    });
+    this.callback_.call(ctx, entries, ctx);
+    this.clearActive();
+  };
+  ResizeObserverSPI2.prototype.clearActive = function() {
+    this.activeObservations_.splice(0);
+  };
+  ResizeObserverSPI2.prototype.hasActive = function() {
+    return this.activeObservations_.length > 0;
+  };
+  return ResizeObserverSPI2;
+})();
+var observers = typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : new MapShim();
+var ResizeObserver = /* @__PURE__ */ (function() {
+  function ResizeObserver2(callback) {
+    if (!(this instanceof ResizeObserver2)) throw new TypeError("Cannot call a class as a function.");
+    if (!arguments.length) throw new TypeError("1 argument required, but only 0 present.");
+    var observer = new ResizeObserverSPI(callback, ResizeObserverController.getInstance(), this);
+    observers.set(this, observer);
+  }
+  return ResizeObserver2;
+})();
+[
+  "observe",
+  "unobserve",
+  "disconnect"
+].forEach(function(method) {
+  ResizeObserver.prototype[method] = function() {
+    var _a;
+    return (_a = observers.get(this))[method].apply(_a, arguments);
+  };
+});
+var index = (function() {
+  if (typeof global$1.ResizeObserver !== "undefined") return global$1.ResizeObserver;
+  return ResizeObserver;
+})();
+var raf = (callback) => setTimeout(callback, 16);
+var caf = (num) => clearTimeout(num);
+var rafUUID = 0;
+var rafIds = /* @__PURE__ */ new Map();
+function cleanup(id) {
+  rafIds.delete(id);
+}
+function wrapperRaf(callback) {
+  let times = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
+  rafUUID += 1;
+  const id = rafUUID;
+  function callRef(leftTimes) {
+    if (leftTimes === 0) {
+      cleanup(id);
+      callback();
+    } else {
+      const realId = raf(() => {
+        callRef(leftTimes - 1);
+      });
+      rafIds.set(id, realId);
+    }
+  }
+  callRef(times);
+  return id;
+}
+wrapperRaf.cancel = (id) => {
+  const realId = rafIds.get(id);
+  cleanup(realId);
+  return caf(realId);
+};
+function returnEmptyString() {
+  return "";
+}
+function returnDocument(element) {
+  if (element) return element.ownerDocument;
+  return (void 0).document;
+}
+function noop() {
+}
+var triggerProps = () => ({
+  action: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]).def([]),
+  showAction: PropTypes.any.def([]),
+  hideAction: PropTypes.any.def([]),
+  getPopupClassNameFromAlign: PropTypes.any.def(returnEmptyString),
+  onPopupVisibleChange: Function,
+  afterPopupVisibleChange: PropTypes.func.def(noop),
+  popup: PropTypes.any,
+  arrow: PropTypes.bool.def(true),
+  popupStyle: {
+    type: Object,
+    default: void 0
+  },
+  prefixCls: PropTypes.string.def("rc-trigger-popup"),
+  popupClassName: PropTypes.string.def(""),
+  popupPlacement: String,
+  builtinPlacements: PropTypes.object,
+  popupTransitionName: String,
+  popupAnimation: PropTypes.any,
+  mouseEnterDelay: PropTypes.number.def(0),
+  mouseLeaveDelay: PropTypes.number.def(0.1),
+  zIndex: Number,
+  focusDelay: PropTypes.number.def(0),
+  blurDelay: PropTypes.number.def(0.15),
+  getPopupContainer: Function,
+  getDocument: PropTypes.func.def(returnDocument),
+  forceRender: {
+    type: Boolean,
+    default: void 0
+  },
+  destroyPopupOnHide: {
+    type: Boolean,
+    default: false
+  },
+  mask: {
+    type: Boolean,
+    default: false
+  },
+  maskClosable: {
+    type: Boolean,
+    default: true
+  },
+  popupAlign: PropTypes.object.def(() => ({})),
+  popupVisible: {
+    type: Boolean,
+    default: void 0
+  },
+  defaultPopupVisible: {
+    type: Boolean,
+    default: false
+  },
+  maskTransitionName: String,
+  maskAnimation: String,
+  stretch: String,
+  alignPoint: {
+    type: Boolean,
+    default: void 0
+  },
+  autoDestroy: {
+    type: Boolean,
+    default: false
+  },
+  mobile: Object,
+  getTriggerDOMNode: Function
+});
+var innerProps = {
+  visible: Boolean,
+  prefixCls: String,
+  zIndex: Number,
+  destroyPopupOnHide: Boolean,
+  forceRender: Boolean,
+  arrow: {
+    type: Boolean,
+    default: true
+  },
+  animation: [String, Object],
+  transitionName: String,
+  stretch: { type: String },
+  align: { type: Object },
+  point: { type: Object },
+  getRootDomNode: { type: Function },
+  getClassNameFromAlign: { type: Function },
+  onAlign: { type: Function },
+  onMouseenter: { type: Function },
+  onMouseleave: { type: Function },
+  onMousedown: { type: Function },
+  onTouchstart: { type: Function }
+};
+var mobileProps = _extends(_extends({}, innerProps), { mobile: { type: Object } });
+var popupProps = _extends(_extends({}, innerProps), {
+  mask: Boolean,
+  mobile: { type: Object },
+  maskAnimation: String,
+  maskTransitionName: String
+});
+function Mask(props) {
+  const { prefixCls, visible, zIndex, mask, maskAnimation, maskTransitionName } = props;
+  if (!mask) return null;
+  let motion = {};
+  if (maskTransitionName || maskAnimation) motion = getMotion({
+    prefixCls,
+    transitionName: maskTransitionName,
+    animation: maskAnimation
+  });
+  return createVNode(Transition, _objectSpread2$1({ "appear": true }, motion), { default: () => [withDirectives(createVNode("div", {
+    "style": { zIndex },
+    "class": `${prefixCls}-mask`
+  }, null), [[resolveDirective("if"), visible]])] });
+}
+Mask.displayName = "Mask";
+var MobilePopupInner_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "MobilePopupInner",
+  inheritAttrs: false,
+  props: mobileProps,
+  emits: [
+    "mouseenter",
+    "mouseleave",
+    "mousedown",
+    "touchstart",
+    "align"
+  ],
+  setup(props, _ref) {
+    let { expose, slots } = _ref;
+    const elementRef = ref();
+    expose({
+      forceAlign: () => {
+      },
+      getElement: () => elementRef.value
+    });
+    return () => {
+      var _a;
+      const { zIndex, visible, prefixCls, mobile: { popupClassName, popupStyle, popupMotion = {}, popupRender } = {} } = props;
+      const mergedStyle = _extends({ zIndex }, popupStyle);
+      let childNode = flattenChildren((_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots));
+      if (childNode.length > 1) {
+        childNode = createVNode("div", { "class": `${prefixCls}-content` }, [childNode]);
+      }
+      if (popupRender) childNode = popupRender(childNode);
+      const mergedClassName = classNames(prefixCls, popupClassName);
+      return createVNode(Transition, _objectSpread2$1({ "ref": elementRef }, popupMotion), { default: () => [visible ? createVNode("div", {
+        "class": mergedClassName,
+        "style": mergedStyle
+      }, [childNode]) : null] });
+    };
+  }
+});
+var useVisibleStatus_default = ((visible, doMeasure) => {
+  const status = shallowRef(null);
+  const rafRef = shallowRef();
+  const destroyRef = shallowRef(false);
+  function setStatus(nextStatus) {
+    if (!destroyRef.value) status.value = nextStatus;
+  }
+  function cancelRaf() {
+    wrapperRaf.cancel(rafRef.value);
+  }
+  function goNextStatus(callback) {
+    cancelRaf();
+    rafRef.value = wrapperRaf(() => {
+      let newStatus = status.value;
+      switch (status.value) {
+        case "align":
+          newStatus = "motion";
+          break;
+        case "motion":
+          newStatus = "stable";
+      }
+      setStatus(newStatus);
+      callback === null || callback === void 0 || callback();
+    });
+  }
+  watch(visible, () => {
+    setStatus("measure");
+  }, {
+    immediate: true,
+    flush: "post"
+  });
+  return [status, goNextStatus];
+});
+var useStretchStyle_default = ((stretch) => {
+  const targetSize = shallowRef({
+    width: 0,
+    height: 0
+  });
+  function measureStretch(element) {
+    targetSize.value = {
+      width: element.offsetWidth,
+      height: element.offsetHeight
+    };
+  }
+  return [computed(() => {
+    const sizeStyle = {};
+    if (stretch.value) {
+      const { width, height } = targetSize.value;
+      if (stretch.value.indexOf("height") !== -1 && height) sizeStyle.height = `${height}px`;
+      else if (stretch.value.indexOf("minHeight") !== -1 && height) sizeStyle.minHeight = `${height}px`;
+      if (stretch.value.indexOf("width") !== -1 && width) sizeStyle.width = `${width}px`;
+      else if (stretch.value.indexOf("minWidth") !== -1 && width) sizeStyle.minWidth = `${width}px`;
+    }
+    return sizeStyle;
+  }), measureStretch];
+});
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) Object.defineProperty(obj, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  else obj[key] = value;
+  return obj;
+}
+var vendorPrefix;
+var jsCssMap = {
+  Webkit: "-webkit-",
+  Moz: "-moz-",
+  ms: "-ms-",
+  O: "-o-"
+};
+function getVendorPrefix() {
+  if (vendorPrefix !== void 0) return vendorPrefix;
+  vendorPrefix = "";
+  var style = (void 0).createElement("p").style;
+  var testProp = "Transform";
+  for (var key in jsCssMap) if (key + testProp in style) vendorPrefix = key;
+  return vendorPrefix;
+}
+function getTransitionName() {
+  return getVendorPrefix() ? "".concat(getVendorPrefix(), "TransitionProperty") : "transitionProperty";
+}
+function getTransformName() {
+  return getVendorPrefix() ? "".concat(getVendorPrefix(), "Transform") : "transform";
+}
+function setTransitionProperty(node, value) {
+  var name = getTransitionName();
+  if (name) {
+    node.style[name] = value;
+    if (name !== "transitionProperty") node.style.transitionProperty = value;
+  }
+}
+function setTransform(node, value) {
+  var name = getTransformName();
+  if (name) {
+    node.style[name] = value;
+    if (name !== "transform") node.style.transform = value;
+  }
+}
+function getTransitionProperty(node) {
+  return node.style.transitionProperty || node.style[getTransitionName()];
+}
+function getTransformXY(node) {
+  var style = (void 0).getComputedStyle(node, null);
+  var transform = style.getPropertyValue("transform") || style.getPropertyValue(getTransformName());
+  if (transform && transform !== "none") {
+    var matrix = transform.replace(/[^0-9\-.,]/g, "").split(",");
+    return {
+      x: parseFloat(matrix[12] || matrix[4], 0),
+      y: parseFloat(matrix[13] || matrix[5], 0)
+    };
+  }
+  return {
+    x: 0,
+    y: 0
+  };
+}
+var matrix2d = /matrix\((.*)\)/;
+var matrix3d = /matrix3d\((.*)\)/;
+function setTransformXY(node, xy) {
+  var style = (void 0).getComputedStyle(node, null);
+  var transform = style.getPropertyValue("transform") || style.getPropertyValue(getTransformName());
+  if (transform && transform !== "none") {
+    var arr;
+    var match2d = transform.match(matrix2d);
+    if (match2d) {
+      match2d = match2d[1];
+      arr = match2d.split(",").map(function(item) {
+        return parseFloat(item, 10);
+      });
+      arr[4] = xy.x;
+      arr[5] = xy.y;
+      setTransform(node, "matrix(".concat(arr.join(","), ")"));
+    } else {
+      arr = transform.match(matrix3d)[1].split(",").map(function(item) {
+        return parseFloat(item, 10);
+      });
+      arr[12] = xy.x;
+      arr[13] = xy.y;
+      setTransform(node, "matrix3d(".concat(arr.join(","), ")"));
+    }
+  } else setTransform(node, "translateX(".concat(xy.x, "px) translateY(").concat(xy.y, "px) translateZ(0)"));
+}
+var getComputedStyleX;
+function forceRelayout(elem) {
+  var originalStyle = elem.style.display;
+  elem.style.display = "none";
+  elem.offsetHeight;
+  elem.style.display = originalStyle;
+}
+function css(el, name, v) {
+  var value = v;
+  if (_typeof(name) === "object") {
+    for (var i in name) if (name.hasOwnProperty(i)) css(el, i, name[i]);
+    return;
+  }
+  if (typeof value !== "undefined") {
+    if (typeof value === "number") value = "".concat(value, "px");
+    el.style[name] = value;
+    return;
+  }
+  return getComputedStyleX(el, name);
+}
+function getClientPosition(elem) {
+  var box;
+  var x;
+  var y;
+  var doc = elem.ownerDocument;
+  var body = doc.body;
+  var docElem = doc && doc.documentElement;
+  box = elem.getBoundingClientRect();
+  x = Math.floor(box.left);
+  y = Math.floor(box.top);
+  x -= docElem.clientLeft || body.clientLeft || 0;
+  y -= docElem.clientTop || body.clientTop || 0;
+  return {
+    left: x,
+    top: y
+  };
+}
+function getScroll(w, top) {
+  var ret = w["page".concat(top ? "Y" : "X", "Offset")];
+  var method = "scroll".concat(top ? "Top" : "Left");
+  if (typeof ret !== "number") {
+    var d = w.document;
+    ret = d.documentElement[method];
+    if (typeof ret !== "number") ret = d.body[method];
+  }
+  return ret;
+}
+function getScrollLeft(w) {
+  return getScroll(w);
+}
+function getScrollTop(w) {
+  return getScroll(w, true);
+}
+function getOffset(el) {
+  var pos = getClientPosition(el);
+  var doc = el.ownerDocument;
+  var w = doc.defaultView || doc.parentWindow;
+  pos.left += getScrollLeft(w);
+  pos.top += getScrollTop(w);
+  return pos;
+}
+function isWindow(obj) {
+  return obj !== null && obj !== void 0 && obj == obj.window;
+}
+function getDocument(node) {
+  if (isWindow(node)) return node.document;
+  if (node.nodeType === 9) return node;
+  return node.ownerDocument;
+}
+function getOffsetDirection(dir, option) {
+  if (dir === "left") return option.useCssRight ? "right" : dir;
+  return option.useCssBottom ? "bottom" : dir;
+}
+function oppositeOffsetDirection(dir) {
+  if (dir === "left") return "right";
+  else if (dir === "right") return "left";
+  else if (dir === "top") return "bottom";
+  else if (dir === "bottom") return "top";
+}
+function setLeftTop(elem, offset2, option) {
+  if (css(elem, "position") === "static") elem.style.position = "relative";
+  var presetH = -999;
+  var presetV = -999;
+  var horizontalProperty = getOffsetDirection("left", option);
+  var verticalProperty = getOffsetDirection("top", option);
+  var oppositeHorizontalProperty = oppositeOffsetDirection(horizontalProperty);
+  var oppositeVerticalProperty = oppositeOffsetDirection(verticalProperty);
+  if (horizontalProperty !== "left") presetH = 999;
+  if (verticalProperty !== "top") presetV = 999;
+  var originalTransition = "";
+  var originalOffset = getOffset(elem);
+  if ("left" in offset2 || "top" in offset2) {
+    originalTransition = getTransitionProperty(elem) || "";
+    setTransitionProperty(elem, "none");
+  }
+  if ("left" in offset2) {
+    elem.style[oppositeHorizontalProperty] = "";
+    elem.style[horizontalProperty] = "".concat(presetH, "px");
+  }
+  if ("top" in offset2) {
+    elem.style[oppositeVerticalProperty] = "";
+    elem.style[verticalProperty] = "".concat(presetV, "px");
+  }
+  forceRelayout(elem);
+  var old = getOffset(elem);
+  var originalStyle = {};
+  for (var key in offset2) if (offset2.hasOwnProperty(key)) {
+    var dir = getOffsetDirection(key, option);
+    var preset = key === "left" ? presetH : presetV;
+    var off = originalOffset[key] - old[key];
+    if (dir === key) originalStyle[dir] = preset + off;
+    else originalStyle[dir] = preset - off;
+  }
+  css(elem, originalStyle);
+  forceRelayout(elem);
+  if ("left" in offset2 || "top" in offset2) setTransitionProperty(elem, originalTransition);
+  var ret = {};
+  for (var _key in offset2) if (offset2.hasOwnProperty(_key)) {
+    var _dir = getOffsetDirection(_key, option);
+    var _off = offset2[_key] - originalOffset[_key];
+    if (_key === _dir) ret[_dir] = originalStyle[_dir] + _off;
+    else ret[_dir] = originalStyle[_dir] - _off;
+  }
+  css(elem, ret);
+}
+function setTransform$1(elem, offset2) {
+  var originalOffset = getOffset(elem);
+  var originalXY = getTransformXY(elem);
+  var resultXY = {
+    x: originalXY.x,
+    y: originalXY.y
+  };
+  if ("left" in offset2) resultXY.x = originalXY.x + offset2.left - originalOffset.left;
+  if ("top" in offset2) resultXY.y = originalXY.y + offset2.top - originalOffset.top;
+  setTransformXY(elem, resultXY);
+}
+function setOffset(elem, offset2, option) {
+  if (option.ignoreShake) {
+    var oriOffset = getOffset(elem);
+    var oLeft = oriOffset.left.toFixed(0);
+    var oTop = oriOffset.top.toFixed(0);
+    var tLeft = offset2.left.toFixed(0);
+    var tTop = offset2.top.toFixed(0);
+    if (oLeft === tLeft && oTop === tTop) return;
+  }
+  if (option.useCssRight || option.useCssBottom) setLeftTop(elem, offset2, option);
+  else if (option.useCssTransform && getTransformName() in (void 0).body.style) setTransform$1(elem, offset2);
+  else setLeftTop(elem, offset2, option);
+}
+function each(arr, fn) {
+  for (var i = 0; i < arr.length; i++) fn(arr[i]);
+}
+function isBorderBoxFn(elem) {
+  return getComputedStyleX(elem, "boxSizing") === "border-box";
+}
+var BOX_MODELS = [
+  "margin",
+  "border",
+  "padding"
+];
+var CONTENT_INDEX = -1;
+var PADDING_INDEX = 2;
+var BORDER_INDEX = 1;
+var MARGIN_INDEX = 0;
+function swap(elem, options, callback) {
+  var old = {};
+  var style = elem.style;
+  var name;
+  for (name in options) if (options.hasOwnProperty(name)) {
+    old[name] = style[name];
+    style[name] = options[name];
+  }
+  callback.call(elem);
+  for (name in options) if (options.hasOwnProperty(name)) style[name] = old[name];
+}
+function getPBMWidth(elem, props, which) {
+  var value = 0;
+  var prop;
+  var j;
+  var i;
+  for (j = 0; j < props.length; j++) {
+    prop = props[j];
+    if (prop) for (i = 0; i < which.length; i++) {
+      var cssProp = void 0;
+      if (prop === "border") cssProp = "".concat(prop).concat(which[i], "Width");
+      else cssProp = prop + which[i];
+      value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
+    }
+  }
+  return value;
+}
+var domUtils = { getParent: function getParent(element) {
+  var parent = element;
+  do
+    if (parent.nodeType === 11 && parent.host) parent = parent.host;
+    else parent = parent.parentNode;
+  while (parent && parent.nodeType !== 1 && parent.nodeType !== 9);
+  return parent;
+} };
+each(["Width", "Height"], function(name) {
+  domUtils["doc".concat(name)] = function(refWin) {
+    var d = refWin.document;
+    return Math.max(d.documentElement["scroll".concat(name)], d.body["scroll".concat(name)], domUtils["viewport".concat(name)](d));
+  };
+  domUtils["viewport".concat(name)] = function(win) {
+    var prop = "client".concat(name);
+    var doc = win.document;
+    var body = doc.body;
+    var documentElementProp = doc.documentElement[prop];
+    return doc.compatMode === "CSS1Compat" && documentElementProp || body && body[prop] || documentElementProp;
+  };
+});
+function getWH(elem, name, ex) {
+  var extra = ex;
+  if (isWindow(elem)) return name === "width" ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
+  else if (elem.nodeType === 9) return name === "width" ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
+  var which = name === "width" ? ["Left", "Right"] : ["Top", "Bottom"];
+  var borderBoxValue = name === "width" ? Math.floor(elem.getBoundingClientRect().width) : Math.floor(elem.getBoundingClientRect().height);
+  var isBorderBox = isBorderBoxFn(elem);
+  var cssBoxValue = 0;
+  if (borderBoxValue === null || borderBoxValue === void 0 || borderBoxValue <= 0) {
+    borderBoxValue = void 0;
+    cssBoxValue = getComputedStyleX(elem, name);
+    if (cssBoxValue === null || cssBoxValue === void 0 || Number(cssBoxValue) < 0) cssBoxValue = elem.style[name] || 0;
+    cssBoxValue = Math.floor(parseFloat(cssBoxValue)) || 0;
+  }
+  if (extra === void 0) extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
+  var borderBoxValueOrIsBorderBox = borderBoxValue !== void 0 || isBorderBox;
+  var val = borderBoxValue || cssBoxValue;
+  if (extra === CONTENT_INDEX) {
+    if (borderBoxValueOrIsBorderBox) return val - getPBMWidth(elem, ["border", "padding"], which);
+    return cssBoxValue;
+  } else if (borderBoxValueOrIsBorderBox) {
+    if (extra === BORDER_INDEX) return val;
+    return val + (extra === PADDING_INDEX ? -getPBMWidth(elem, ["border"], which) : getPBMWidth(elem, ["margin"], which));
+  }
+  return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which);
+}
+var cssShow = {
+  position: "absolute",
+  visibility: "hidden",
+  display: "block"
+};
+function getWHIgnoreDisplay() {
+  for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) args[_key2] = arguments[_key2];
+  var val;
+  var elem = args[0];
+  if (elem.offsetWidth !== 0) val = getWH.apply(void 0, args);
+  else swap(elem, cssShow, function() {
+    val = getWH.apply(void 0, args);
+  });
+  return val;
+}
+each(["width", "height"], function(name) {
+  var first = name.charAt(0).toUpperCase() + name.slice(1);
+  domUtils["outer".concat(first)] = function(el, includeMargin) {
+    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
+  };
+  var which = name === "width" ? ["Left", "Right"] : ["Top", "Bottom"];
+  domUtils[name] = function(elem, v) {
+    var val = v;
+    if (val !== void 0) {
+      if (elem) {
+        if (isBorderBoxFn(elem)) val += getPBMWidth(elem, ["padding", "border"], which);
+        return css(elem, name, val);
+      }
+      return;
+    }
+    return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
+  };
+});
+function mix(to, from) {
+  for (var i in from) if (from.hasOwnProperty(i)) to[i] = from[i];
+  return to;
+}
+var utils = {
+  getWindow: function getWindow(node) {
+    if (node && node.document && node.setTimeout) return node;
+    var doc = node.ownerDocument || node;
+    return doc.defaultView || doc.parentWindow;
+  },
+  getDocument,
+  offset: function offset(el, value, option) {
+    if (typeof value !== "undefined") setOffset(el, value, option || {});
+    else return getOffset(el);
+  },
+  isWindow,
+  each,
+  css,
+  clone: function clone(obj) {
+    var i;
+    var ret = {};
+    for (i in obj) if (obj.hasOwnProperty(i)) ret[i] = obj[i];
+    if (obj.overflow) {
+      for (i in obj) if (obj.hasOwnProperty(i)) ret.overflow[i] = obj.overflow[i];
+    }
+    return ret;
+  },
+  mix,
+  getWindowScrollLeft: function getWindowScrollLeft(w) {
+    return getScrollLeft(w);
+  },
+  getWindowScrollTop: function getWindowScrollTop(w) {
+    return getScrollTop(w);
+  },
+  merge: function merge() {
+    var ret = {};
+    for (var i = 0; i < arguments.length; i++) utils.mix(ret, i < 0 || arguments.length <= i ? void 0 : arguments[i]);
+    return ret;
+  },
+  viewportWidth: 0,
+  viewportHeight: 0
+};
+mix(utils, domUtils);
+var getParent2 = utils.getParent;
+function getOffsetParent(element) {
+  if (utils.isWindow(element) || element.nodeType === 9) return null;
+  var body = utils.getDocument(element).body;
+  var parent;
+  var positionStyle = utils.css(element, "position");
+  if (!(positionStyle === "fixed" || positionStyle === "absolute")) return element.nodeName.toLowerCase() === "html" ? null : getParent2(element);
+  for (parent = getParent2(element); parent && parent !== body && parent.nodeType !== 9; parent = getParent2(parent)) {
+    positionStyle = utils.css(parent, "position");
+    if (positionStyle !== "static") return parent;
+  }
+  return null;
+}
+var getParent$1 = utils.getParent;
+function isAncestorFixed(element) {
+  if (utils.isWindow(element) || element.nodeType === 9) return false;
+  var doc = utils.getDocument(element);
+  var body = doc.body;
+  var parent = null;
+  for (parent = getParent$1(element); parent && parent !== body && parent !== doc; parent = getParent$1(parent)) if (utils.css(parent, "position") === "fixed") return true;
+  return false;
+}
+function getVisibleRectForElement(element, alwaysByViewport) {
+  var visibleRect = {
+    left: 0,
+    right: Infinity,
+    top: 0,
+    bottom: Infinity
+  };
+  var el = getOffsetParent(element);
+  var doc = utils.getDocument(element);
+  var win = doc.defaultView || doc.parentWindow;
+  var body = doc.body;
+  var documentElement = doc.documentElement;
+  while (el) {
+    if (((void 0).userAgent.indexOf("MSIE") === -1 || el.clientWidth !== 0) && el !== body && el !== documentElement && utils.css(el, "overflow") !== "visible") {
+      var pos = utils.offset(el);
+      pos.left += el.clientLeft;
+      pos.top += el.clientTop;
+      visibleRect.top = Math.max(visibleRect.top, pos.top);
+      visibleRect.right = Math.min(visibleRect.right, pos.left + el.clientWidth);
+      visibleRect.bottom = Math.min(visibleRect.bottom, pos.top + el.clientHeight);
+      visibleRect.left = Math.max(visibleRect.left, pos.left);
+    } else if (el === body || el === documentElement) break;
+    el = getOffsetParent(el);
+  }
+  var originalPosition = null;
+  if (!utils.isWindow(element) && element.nodeType !== 9) {
+    originalPosition = element.style.position;
+    if (utils.css(element, "position") === "absolute") element.style.position = "fixed";
+  }
+  var scrollX = utils.getWindowScrollLeft(win);
+  var scrollY = utils.getWindowScrollTop(win);
+  var viewportWidth = utils.viewportWidth(win);
+  var viewportHeight = utils.viewportHeight(win);
+  var documentWidth = documentElement.scrollWidth;
+  var documentHeight = documentElement.scrollHeight;
+  var bodyStyle = (void 0).getComputedStyle(body);
+  if (bodyStyle.overflowX === "hidden") documentWidth = win.innerWidth;
+  if (bodyStyle.overflowY === "hidden") documentHeight = win.innerHeight;
+  if (element.style) element.style.position = originalPosition;
+  if (alwaysByViewport || isAncestorFixed(element)) {
+    visibleRect.left = Math.max(visibleRect.left, scrollX);
+    visibleRect.top = Math.max(visibleRect.top, scrollY);
+    visibleRect.right = Math.min(visibleRect.right, scrollX + viewportWidth);
+    visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + viewportHeight);
+  } else {
+    var maxVisibleWidth = Math.max(documentWidth, scrollX + viewportWidth);
+    visibleRect.right = Math.min(visibleRect.right, maxVisibleWidth);
+    var maxVisibleHeight = Math.max(documentHeight, scrollY + viewportHeight);
+    visibleRect.bottom = Math.min(visibleRect.bottom, maxVisibleHeight);
+  }
+  return visibleRect.top >= 0 && visibleRect.left >= 0 && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null;
+}
+function adjustForViewport(elFuturePos, elRegion, visibleRect, overflow) {
+  var pos = utils.clone(elFuturePos);
+  var size = {
+    width: elRegion.width,
+    height: elRegion.height
+  };
+  if (overflow.adjustX && pos.left < visibleRect.left) pos.left = visibleRect.left;
+  if (overflow.resizeWidth && pos.left >= visibleRect.left && pos.left + size.width > visibleRect.right) size.width -= pos.left + size.width - visibleRect.right;
+  if (overflow.adjustX && pos.left + size.width > visibleRect.right) pos.left = Math.max(visibleRect.right - size.width, visibleRect.left);
+  if (overflow.adjustY && pos.top < visibleRect.top) pos.top = visibleRect.top;
+  if (overflow.resizeHeight && pos.top >= visibleRect.top && pos.top + size.height > visibleRect.bottom) size.height -= pos.top + size.height - visibleRect.bottom;
+  if (overflow.adjustY && pos.top + size.height > visibleRect.bottom) pos.top = Math.max(visibleRect.bottom - size.height, visibleRect.top);
+  return utils.mix(pos, size);
+}
+function getRegion(node) {
+  var offset2;
+  var w;
+  var h;
+  if (!utils.isWindow(node) && node.nodeType !== 9) {
+    offset2 = utils.offset(node);
+    w = utils.outerWidth(node);
+    h = utils.outerHeight(node);
+  } else {
+    var win = utils.getWindow(node);
+    offset2 = {
+      left: utils.getWindowScrollLeft(win),
+      top: utils.getWindowScrollTop(win)
+    };
+    w = utils.viewportWidth(win);
+    h = utils.viewportHeight(win);
+  }
+  offset2.width = w;
+  offset2.height = h;
+  return offset2;
+}
+function getAlignOffset(region, align) {
+  var V = align.charAt(0);
+  var H = align.charAt(1);
+  var w = region.width;
+  var h = region.height;
+  var x = region.left;
+  var y = region.top;
+  if (V === "c") y += h / 2;
+  else if (V === "b") y += h;
+  if (H === "c") x += w / 2;
+  else if (H === "r") x += w;
+  return {
+    left: x,
+    top: y
+  };
+}
+function getElFuturePos(elRegion, refNodeRegion, points, offset2, targetOffset) {
+  var p1 = getAlignOffset(refNodeRegion, points[1]);
+  var p2 = getAlignOffset(elRegion, points[0]);
+  var diff = [p2.left - p1.left, p2.top - p1.top];
+  return {
+    left: Math.round(elRegion.left - diff[0] + offset2[0] - targetOffset[0]),
+    top: Math.round(elRegion.top - diff[1] + offset2[1] - targetOffset[1])
+  };
+}
+function isFailX(elFuturePos, elRegion, visibleRect) {
+  return elFuturePos.left < visibleRect.left || elFuturePos.left + elRegion.width > visibleRect.right;
+}
+function isFailY(elFuturePos, elRegion, visibleRect) {
+  return elFuturePos.top < visibleRect.top || elFuturePos.top + elRegion.height > visibleRect.bottom;
+}
+function isCompleteFailX(elFuturePos, elRegion, visibleRect) {
+  return elFuturePos.left > visibleRect.right || elFuturePos.left + elRegion.width < visibleRect.left;
+}
+function isCompleteFailY(elFuturePos, elRegion, visibleRect) {
+  return elFuturePos.top > visibleRect.bottom || elFuturePos.top + elRegion.height < visibleRect.top;
+}
+function flip(points, reg, map) {
+  var ret = [];
+  utils.each(points, function(p) {
+    ret.push(p.replace(reg, function(m) {
+      return map[m];
+    }));
+  });
+  return ret;
+}
+function flipOffset(offset2, index2) {
+  offset2[index2] = -offset2[index2];
+  return offset2;
+}
+function convertOffset(str, offsetLen) {
+  var n;
+  if (/%$/.test(str)) n = parseInt(str.substring(0, str.length - 1), 10) / 100 * offsetLen;
+  else n = parseInt(str, 10);
+  return n || 0;
+}
+function normalizeOffset(offset2, el) {
+  offset2[0] = convertOffset(offset2[0], el.width);
+  offset2[1] = convertOffset(offset2[1], el.height);
+}
+function doAlign(el, tgtRegion, align, isTgtRegionVisible) {
+  var points = align.points;
+  var offset2 = align.offset || [0, 0];
+  var targetOffset = align.targetOffset || [0, 0];
+  var overflow = align.overflow;
+  var source = align.source || el;
+  offset2 = [].concat(offset2);
+  targetOffset = [].concat(targetOffset);
+  overflow = overflow || {};
+  var newOverflowCfg = {};
+  var fail = 0;
+  var visibleRect = getVisibleRectForElement(source, !!(overflow && overflow.alwaysByViewport));
+  var elRegion = getRegion(source);
+  normalizeOffset(offset2, elRegion);
+  normalizeOffset(targetOffset, tgtRegion);
+  var elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset2, targetOffset);
+  var newElRegion = utils.merge(elRegion, elFuturePos);
+  if (visibleRect && (overflow.adjustX || overflow.adjustY) && isTgtRegionVisible) {
+    if (overflow.adjustX) {
+      if (isFailX(elFuturePos, elRegion, visibleRect)) {
+        var newPoints = flip(points, /[lr]/gi, {
+          l: "r",
+          r: "l"
+        });
+        var newOffset = flipOffset(offset2, 0);
+        var newTargetOffset = flipOffset(targetOffset, 0);
+        if (!isCompleteFailX(getElFuturePos(elRegion, tgtRegion, newPoints, newOffset, newTargetOffset), elRegion, visibleRect)) {
+          fail = 1;
+          points = newPoints;
+          offset2 = newOffset;
+          targetOffset = newTargetOffset;
+        }
+      }
+    }
+    if (overflow.adjustY) {
+      if (isFailY(elFuturePos, elRegion, visibleRect)) {
+        var _newPoints = flip(points, /[tb]/gi, {
+          t: "b",
+          b: "t"
+        });
+        var _newOffset = flipOffset(offset2, 1);
+        var _newTargetOffset = flipOffset(targetOffset, 1);
+        if (!isCompleteFailY(getElFuturePos(elRegion, tgtRegion, _newPoints, _newOffset, _newTargetOffset), elRegion, visibleRect)) {
+          fail = 1;
+          points = _newPoints;
+          offset2 = _newOffset;
+          targetOffset = _newTargetOffset;
+        }
+      }
+    }
+    if (fail) {
+      elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset2, targetOffset);
+      utils.mix(newElRegion, elFuturePos);
+    }
+    var isStillFailX = isFailX(elFuturePos, elRegion, visibleRect);
+    var isStillFailY = isFailY(elFuturePos, elRegion, visibleRect);
+    if (isStillFailX || isStillFailY) {
+      var _newPoints2 = points;
+      if (isStillFailX) _newPoints2 = flip(points, /[lr]/gi, {
+        l: "r",
+        r: "l"
+      });
+      if (isStillFailY) _newPoints2 = flip(points, /[tb]/gi, {
+        t: "b",
+        b: "t"
+      });
+      points = _newPoints2;
+      offset2 = align.offset || [0, 0];
+      targetOffset = align.targetOffset || [0, 0];
+    }
+    newOverflowCfg.adjustX = overflow.adjustX && isStillFailX;
+    newOverflowCfg.adjustY = overflow.adjustY && isStillFailY;
+    if (newOverflowCfg.adjustX || newOverflowCfg.adjustY) newElRegion = adjustForViewport(elFuturePos, elRegion, visibleRect, newOverflowCfg);
+  }
+  if (newElRegion.width !== elRegion.width) utils.css(source, "width", utils.width(source) + newElRegion.width - elRegion.width);
+  if (newElRegion.height !== elRegion.height) utils.css(source, "height", utils.height(source) + newElRegion.height - elRegion.height);
+  utils.offset(source, {
+    left: newElRegion.left,
+    top: newElRegion.top
+  }, {
+    useCssRight: align.useCssRight,
+    useCssBottom: align.useCssBottom,
+    useCssTransform: align.useCssTransform,
+    ignoreShake: align.ignoreShake
+  });
+  return {
+    points,
+    offset: offset2,
+    targetOffset,
+    overflow: newOverflowCfg
+  };
+}
+function isOutOfVisibleRect(target, alwaysByViewport) {
+  var visibleRect = getVisibleRectForElement(target, alwaysByViewport);
+  var targetRegion = getRegion(target);
+  return !visibleRect || targetRegion.left + targetRegion.width <= visibleRect.left || targetRegion.top + targetRegion.height <= visibleRect.top || targetRegion.left >= visibleRect.right || targetRegion.top >= visibleRect.bottom;
+}
+function alignElement(el, refNode, align) {
+  var target = align.target || refNode;
+  return doAlign(el, getRegion(target), align, !isOutOfVisibleRect(target, align.overflow && align.overflow.alwaysByViewport));
+}
+alignElement.__getOffsetParent = getOffsetParent;
+alignElement.__getVisibleRectForElement = getVisibleRectForElement;
+function alignPoint(el, tgtPoint, align) {
+  var pageX;
+  var pageY;
+  var doc = utils.getDocument(el);
+  var win = doc.defaultView || doc.parentWindow;
+  var scrollX = utils.getWindowScrollLeft(win);
+  var scrollY = utils.getWindowScrollTop(win);
+  var viewportWidth = utils.viewportWidth(win);
+  var viewportHeight = utils.viewportHeight(win);
+  if ("pageX" in tgtPoint) pageX = tgtPoint.pageX;
+  else pageX = scrollX + tgtPoint.clientX;
+  if ("pageY" in tgtPoint) pageY = tgtPoint.pageY;
+  else pageY = scrollY + tgtPoint.clientY;
+  var tgtRegion = {
+    left: pageX,
+    top: pageY,
+    width: 0,
+    height: 0
+  };
+  var pointInView = pageX >= 0 && pageX <= scrollX + viewportWidth && pageY >= 0 && pageY <= scrollY + viewportHeight;
+  var points = [align.points[0], "cc"];
+  return doAlign(el, tgtRegion, _objectSpread2(_objectSpread2({}, align), {}, { points }), pointInView);
+}
+var isVisible_default = ((element) => {
+  if (!element) return false;
+  if (element.offsetParent) return true;
+  if (element.getBBox) {
+    const box = element.getBBox();
+    if (box.width || box.height) return true;
+  }
+  if (element.getBoundingClientRect) {
+    const box = element.getBoundingClientRect();
+    if (box.width || box.height) return true;
+  }
+  return false;
+});
+function restoreFocus(activeElement, container) {
+  if (activeElement !== (void 0).activeElement && contains(container, activeElement) && typeof activeElement.focus === "function") activeElement.focus();
+}
+var useBuffer_default = ((callback, buffer) => {
+  let called = false;
+  let timeout = null;
+  function cancelTrigger() {
+    clearTimeout(timeout);
+  }
+  function trigger(force) {
+    if (!called || force === true) {
+      if (callback() === false) return;
+      called = true;
+      cancelTrigger();
+      timeout = setTimeout(() => {
+        called = false;
+      }, buffer.value);
+    } else {
+      cancelTrigger();
+      timeout = setTimeout(() => {
+        called = false;
+        trigger();
+      }, buffer.value);
+    }
+  }
+  return [trigger, () => {
+    called = false;
+    cancelTrigger();
+  }];
+});
+var alignProps = {
+  align: Object,
+  target: [Object, Function],
+  onAlign: Function,
+  monitorBufferTime: Number,
+  monitorWindowResize: Boolean,
+  disabled: Boolean
+};
+function getElement(func) {
+  if (typeof func !== "function") return null;
+  return func();
+}
+function getPoint(point) {
+  if (typeof point !== "object" || !point) return null;
+  return point;
+}
+var Align_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "Align",
+  props: alignProps,
+  emits: ["align"],
+  setup(props, _ref) {
+    let { expose, slots } = _ref;
+    const cacheRef = ref({});
+    const nodeRef = ref();
+    const [forceAlign, cancelForceAlign] = useBuffer_default(() => {
+      const { disabled: latestDisabled, target: latestTarget, align: latestAlign, onAlign: latestOnAlign } = props;
+      if (!latestDisabled && latestTarget && nodeRef.value) {
+        const source = nodeRef.value;
+        let result;
+        const element = getElement(latestTarget);
+        const point = getPoint(latestTarget);
+        cacheRef.value.element = element;
+        cacheRef.value.point = point;
+        cacheRef.value.align = latestAlign;
+        const { activeElement } = void 0;
+        if (element && isVisible_default(element)) result = alignElement(source, element, latestAlign);
+        else if (point) result = alignPoint(source, point, latestAlign);
+        restoreFocus(activeElement, source);
+        if (latestOnAlign && result) latestOnAlign(source, result);
+        return true;
+      }
+      return false;
+    }, computed(() => props.monitorBufferTime));
+    ref({ cancel: () => {
+    } });
+    ref({ cancel: () => {
+    } });
+    watch(() => props.disabled, (disabled) => {
+      if (!disabled) forceAlign();
+      else cancelForceAlign();
+    }, {
+      immediate: true,
+      flush: "post"
+    });
+    const winResizeRef = ref(null);
+    watch(() => props.monitorWindowResize, (monitorWindowResize) => {
+      if (monitorWindowResize) {
+        if (!winResizeRef.value) winResizeRef.value = addEventListenerWrap(void 0, "resize", forceAlign);
+      } else if (winResizeRef.value) {
+        winResizeRef.value.remove();
+        winResizeRef.value = null;
+      }
+    }, { flush: "post" });
+    expose({ forceAlign: () => forceAlign(true) });
+    return () => {
+      const child = slots === null || slots === void 0 ? void 0 : slots.default();
+      if (child) return cloneElement(child[0], { ref: nodeRef }, true, true);
+      return null;
+    };
+  }
+});
+var PopupInner_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "PopupInner",
+  inheritAttrs: false,
+  props: innerProps,
+  emits: [
+    "mouseenter",
+    "mouseleave",
+    "mousedown",
+    "touchstart",
+    "align"
+  ],
+  setup(props, _ref) {
+    let { expose, attrs, slots } = _ref;
+    const alignRef = shallowRef();
+    const elementRef = shallowRef();
+    const alignedClassName = shallowRef();
+    const [stretchStyle] = useStretchStyle_default(toRef(props, "stretch"));
+    const visible = shallowRef(false);
+    let timeoutId;
+    watch(() => props.visible, (val) => {
+      clearTimeout(timeoutId);
+      if (val) timeoutId = setTimeout(() => {
+        visible.value = props.visible;
+      });
+      else visible.value = false;
+    }, { immediate: true });
+    const [status, goNextStatus] = useVisibleStatus_default(visible);
+    const prepareResolveRef = shallowRef();
+    const getAlignTarget = () => {
+      if (props.point) return props.point;
+      return props.getRootDomNode;
+    };
+    const forceAlign = () => {
+      var _a;
+      (_a = alignRef.value) === null || _a === void 0 || _a.forceAlign();
+    };
+    const onInternalAlign = (popupDomNode, matchAlign) => {
+      var _a;
+      const nextAlignedClassName = props.getClassNameFromAlign(matchAlign);
+      const preAlignedClassName = alignedClassName.value;
+      if (alignedClassName.value !== nextAlignedClassName) alignedClassName.value = nextAlignedClassName;
+      if (status.value === "align") {
+        if (preAlignedClassName !== nextAlignedClassName) Promise.resolve().then(() => {
+          forceAlign();
+        });
+        else goNextStatus(() => {
+          var _a2;
+          (_a2 = prepareResolveRef.value) === null || _a2 === void 0 || _a2.call(prepareResolveRef);
+        });
+        (_a = props.onAlign) === null || _a === void 0 || _a.call(props, popupDomNode, matchAlign);
+      }
+    };
+    const motion = computed(() => {
+      const m = typeof props.animation === "object" ? props.animation : getMotion(props);
+      ["onAfterEnter", "onAfterLeave"].forEach((eventName) => {
+        const originFn = m[eventName];
+        m[eventName] = (node) => {
+          goNextStatus();
+          status.value = "stable";
+          originFn === null || originFn === void 0 || originFn(node);
+        };
+      });
+      return m;
+    });
+    const onShowPrepare = () => {
+      return new Promise((resolve) => {
+        prepareResolveRef.value = resolve;
+      });
+    };
+    watch([motion, status], () => {
+      if (!motion.value && status.value === "motion") goNextStatus();
+    }, { immediate: true });
+    expose({
+      forceAlign,
+      getElement: () => {
+        return elementRef.value.$el || elementRef.value;
+      }
+    });
+    const alignDisabled = computed(() => {
+      var _a;
+      if (((_a = props.align) === null || _a === void 0 ? void 0 : _a.points) && (status.value === "align" || status.value === "stable")) return false;
+      return true;
+    });
+    return () => {
+      var _a;
+      const { zIndex, align, prefixCls, destroyPopupOnHide, onMouseenter, onMouseleave, onTouchstart = () => {
+      }, onMousedown } = props;
+      const statusValue = status.value;
+      const mergedStyle = [_extends(_extends({}, stretchStyle.value), {
+        zIndex,
+        opacity: statusValue === "motion" || statusValue === "stable" || !visible.value ? null : 0,
+        pointerEvents: !visible.value && statusValue !== "stable" ? "none" : null
+      }), attrs.style];
+      let childNode = flattenChildren((_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots, { visible: props.visible }));
+      if (childNode.length > 1) {
+        childNode = createVNode("div", { "class": `${prefixCls}-content` }, [childNode]);
+      }
+      const mergedClassName = classNames(prefixCls, attrs.class, alignedClassName.value, !props.arrow && `${prefixCls}-arrow-hidden`);
+      const transitionProps = visible.value || !props.visible ? getTransitionProps(motion.value.name, motion.value) : {};
+      return createVNode(Transition, _objectSpread2$1(_objectSpread2$1({ "ref": elementRef }, transitionProps), {}, { "onBeforeEnter": onShowPrepare }), { default: () => {
+        return !destroyPopupOnHide || props.visible ? withDirectives(createVNode(Align_default, {
+          "target": getAlignTarget(),
+          "key": "popup",
+          "ref": alignRef,
+          "monitorWindowResize": true,
+          "disabled": alignDisabled.value,
+          "align": align,
+          "onAlign": onInternalAlign
+        }, { default: () => createVNode("div", {
+          "class": mergedClassName,
+          "onMouseenter": onMouseenter,
+          "onMouseleave": onMouseleave,
+          "onMousedown": withModifiers(onMousedown, ["capture"]),
+          [supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"]: withModifiers(onTouchstart, ["capture"]),
+          "style": mergedStyle
+        }, [childNode]) }), [[vShow, visible.value]]) : null;
+      } });
+    };
+  }
+});
+var Popup_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "Popup",
+  inheritAttrs: false,
+  props: popupProps,
+  setup(props, _ref) {
+    let { attrs, slots, expose } = _ref;
+    const innerVisible = shallowRef(false);
+    const inMobile = shallowRef(false);
+    const popupRef = shallowRef();
+    const rootRef = shallowRef();
+    watch([() => props.visible, () => props.mobile], () => {
+      innerVisible.value = props.visible;
+      if (props.visible && props.mobile) inMobile.value = true;
+    }, {
+      immediate: true,
+      flush: "post"
+    });
+    expose({
+      forceAlign: () => {
+        var _a;
+        (_a = popupRef.value) === null || _a === void 0 || _a.forceAlign();
+      },
+      getElement: () => {
+        var _a;
+        return (_a = popupRef.value) === null || _a === void 0 ? void 0 : _a.getElement();
+      }
+    });
+    return () => {
+      const cloneProps = _extends(_extends(_extends({}, props), attrs), { visible: innerVisible.value });
+      const popupNode = inMobile.value ? createVNode(MobilePopupInner_default, _objectSpread2$1(_objectSpread2$1({}, cloneProps), {}, {
+        "mobile": props.mobile,
+        "ref": popupRef
+      }), { default: slots.default }) : createVNode(PopupInner_default, _objectSpread2$1(_objectSpread2$1({}, cloneProps), {}, { "ref": popupRef }), { default: slots.default });
+      return createVNode("div", { "ref": rootRef }, [createVNode(Mask, cloneProps, null), popupNode]);
+    };
+  }
+});
+function isPointsEq(a1, a2, isAlignPoint) {
+  if (isAlignPoint) return a1[0] === a2[0];
+  return a1[0] === a2[0] && a1[1] === a2[1];
+}
+function getAlignFromPlacement(builtinPlacements, placementStr, align) {
+  const baseAlign = builtinPlacements[placementStr] || {};
+  return _extends(_extends({}, baseAlign), align);
+}
+function getAlignPopupClassName(builtinPlacements, prefixCls, align, isAlignPoint) {
+  const { points } = align;
+  const placements = Object.keys(builtinPlacements);
+  for (let i = 0; i < placements.length; i += 1) {
+    const placement = placements[i];
+    if (isPointsEq(builtinPlacements[placement].points, points, isAlignPoint)) return `${prefixCls}-placement-${placement}`;
+  }
+  return "";
+}
+var BaseMixin_default = { methods: {
+  setState() {
+    let state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    let callback = arguments.length > 1 ? arguments[1] : void 0;
+    let newState = typeof state === "function" ? state(this.$data, this.$props) : state;
+    if (this.getDerivedStateFromProps) {
+      const s = this.getDerivedStateFromProps(getOptionProps(this), _extends(_extends({}, this.$data), newState));
+      if (s === null) return;
+      else newState = _extends(_extends({}, newState), s || {});
+    }
+    _extends(this.$data, newState);
+    if (this._.isMounted) this.$forceUpdate();
+    nextTick(() => {
+      callback && callback();
+    });
+  },
+  __emit() {
+    const args = [].slice.call(arguments, 0);
+    let eventName = args[0];
+    eventName = `on${eventName[0].toUpperCase()}${eventName.substring(1)}`;
+    const event = this.$props[eventName] || this.$attrs[eventName];
+    if (args.length && event) {
+      if (Array.isArray(event)) for (let i = 0, l = event.length; i < l; i++) event[i](...args.slice(1));
+      else event(...args.slice(1));
+    }
+  }
+} };
+var ALL_HANDLERS = [
+  "onClick",
+  "onMousedown",
+  "onTouchstart",
+  "onMouseenter",
+  "onMouseleave",
+  "onFocus",
+  "onBlur",
+  "onContextmenu"
+];
+var vc_trigger_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "Trigger",
+  mixins: [BaseMixin_default],
+  inheritAttrs: false,
+  props: triggerProps(),
+  setup(props) {
+    const align = computed(() => {
+      const { popupPlacement, popupAlign, builtinPlacements } = props;
+      if (popupPlacement && builtinPlacements) return getAlignFromPlacement(builtinPlacements, popupPlacement, popupAlign);
+      return popupAlign;
+    });
+    const popupRef = shallowRef(null);
+    const setPopupRef = (val) => {
+      popupRef.value = val;
+    };
+    return {
+      vcTriggerContext: inject("vcTriggerContext", {}),
+      popupRef,
+      setPopupRef,
+      triggerRef: shallowRef(null),
+      align,
+      focusTime: null,
+      clickOutsideHandler: null,
+      contextmenuOutsideHandler1: null,
+      contextmenuOutsideHandler2: null,
+      touchOutsideHandler: null,
+      attachId: null,
+      delayTimer: null,
+      hasPopupMouseDown: false,
+      preClickTime: null,
+      preTouchTime: null,
+      mouseDownTimeout: null,
+      childOriginEvents: {}
+    };
+  },
+  data() {
+    const props = this.$props;
+    let popupVisible;
+    if (this.popupVisible !== void 0) popupVisible = !!props.popupVisible;
+    else popupVisible = !!props.defaultPopupVisible;
+    ALL_HANDLERS.forEach((h) => {
+      this[`fire${h}`] = (e) => {
+        this.fireEvents(h, e);
+      };
+    });
+    return {
+      prevPopupVisible: popupVisible,
+      sPopupVisible: popupVisible,
+      point: null
+    };
+  },
+  watch: { popupVisible(val) {
+    if (val !== void 0) {
+      this.prevPopupVisible = this.sPopupVisible;
+      this.sPopupVisible = val;
+    }
+  } },
+  created() {
+    provide("vcTriggerContext", {
+      onPopupMouseDown: this.onPopupMouseDown,
+      onPopupMouseenter: this.onPopupMouseenter,
+      onPopupMouseleave: this.onPopupMouseleave
+    });
+    useProvidePortal(this);
+  },
+  deactivated() {
+    this.setPopupVisible(false);
+  },
+  mounted() {
+    this.$nextTick(() => {
+      this.updatedCal();
+    });
+  },
+  updated() {
+    this.$nextTick(() => {
+      this.updatedCal();
+    });
+  },
+  beforeUnmount() {
+    this.clearDelayTimer();
+    this.clearOutsideHandler();
+    clearTimeout(this.mouseDownTimeout);
+    wrapperRaf.cancel(this.attachId);
+  },
+  methods: {
+    updatedCal() {
+      const props = this.$props;
+      if (this.$data.sPopupVisible) {
+        let currentDocument;
+        if (!this.clickOutsideHandler && (this.isClickToHide() || this.isContextmenuToShow())) {
+          currentDocument = props.getDocument(this.getRootDomNode());
+          this.clickOutsideHandler = addEventListenerWrap(currentDocument, "mousedown", this.onDocumentClick);
+        }
+        if (!this.touchOutsideHandler) {
+          currentDocument = currentDocument || props.getDocument(this.getRootDomNode());
+          this.touchOutsideHandler = addEventListenerWrap(currentDocument, "touchstart", this.onDocumentClick, supportsPassive_default ? { passive: false } : false);
+        }
+        if (!this.contextmenuOutsideHandler1 && this.isContextmenuToShow()) {
+          currentDocument = currentDocument || props.getDocument(this.getRootDomNode());
+          this.contextmenuOutsideHandler1 = addEventListenerWrap(currentDocument, "scroll", this.onContextmenuClose);
+        }
+        if (!this.contextmenuOutsideHandler2 && this.isContextmenuToShow()) this.contextmenuOutsideHandler2 = addEventListenerWrap(void 0, "blur", this.onContextmenuClose);
+      } else this.clearOutsideHandler();
+    },
+    onMouseenter(e) {
+      const { mouseEnterDelay } = this.$props;
+      this.fireEvents("onMouseenter", e);
+      this.delaySetPopupVisible(true, mouseEnterDelay, mouseEnterDelay ? null : e);
+    },
+    onMouseMove(e) {
+      this.fireEvents("onMousemove", e);
+      this.setPoint(e);
+    },
+    onMouseleave(e) {
+      this.fireEvents("onMouseleave", e);
+      this.delaySetPopupVisible(false, this.$props.mouseLeaveDelay);
+    },
+    onPopupMouseenter() {
+      const { vcTriggerContext = {} } = this;
+      if (vcTriggerContext.onPopupMouseenter) vcTriggerContext.onPopupMouseenter();
+      this.clearDelayTimer();
+    },
+    onPopupMouseleave(e) {
+      var _a;
+      if (e && e.relatedTarget && !e.relatedTarget.setTimeout && contains((_a = this.popupRef) === null || _a === void 0 ? void 0 : _a.getElement(), e.relatedTarget)) return;
+      if (this.isMouseLeaveToHide()) this.delaySetPopupVisible(false, this.$props.mouseLeaveDelay);
+      const { vcTriggerContext = {} } = this;
+      if (vcTriggerContext.onPopupMouseleave) vcTriggerContext.onPopupMouseleave(e);
+    },
+    onFocus(e) {
+      this.fireEvents("onFocus", e);
+      this.clearDelayTimer();
+      if (this.isFocusToShow()) {
+        this.focusTime = Date.now();
+        this.delaySetPopupVisible(true, this.$props.focusDelay);
+      }
+    },
+    onMousedown(e) {
+      this.fireEvents("onMousedown", e);
+      this.preClickTime = Date.now();
+    },
+    onTouchstart(e) {
+      this.fireEvents("onTouchstart", e);
+      this.preTouchTime = Date.now();
+    },
+    onBlur(e) {
+      if (!contains(e.target, e.relatedTarget || (void 0).activeElement)) {
+        this.fireEvents("onBlur", e);
+        this.clearDelayTimer();
+        if (this.isBlurToHide()) this.delaySetPopupVisible(false, this.$props.blurDelay);
+      }
+    },
+    onContextmenu(e) {
+      e.preventDefault();
+      this.fireEvents("onContextmenu", e);
+      this.setPopupVisible(true, e);
+    },
+    onContextmenuClose() {
+      if (this.isContextmenuToShow()) this.close();
+    },
+    onClick(event) {
+      this.fireEvents("onClick", event);
+      if (this.focusTime) {
+        let preTime;
+        if (this.preClickTime && this.preTouchTime) preTime = Math.min(this.preClickTime, this.preTouchTime);
+        else if (this.preClickTime) preTime = this.preClickTime;
+        else if (this.preTouchTime) preTime = this.preTouchTime;
+        if (Math.abs(preTime - this.focusTime) < 20) return;
+        this.focusTime = 0;
+      }
+      this.preClickTime = 0;
+      this.preTouchTime = 0;
+      if (this.isClickToShow() && (this.isClickToHide() || this.isBlurToHide()) && event && event.preventDefault) event.preventDefault();
+      if (event && event.domEvent) event.domEvent.preventDefault();
+      const nextVisible = !this.$data.sPopupVisible;
+      if (this.isClickToHide() && !nextVisible || nextVisible && this.isClickToShow()) this.setPopupVisible(!this.$data.sPopupVisible, event);
+    },
+    onPopupMouseDown() {
+      const { vcTriggerContext = {} } = this;
+      this.hasPopupMouseDown = true;
+      clearTimeout(this.mouseDownTimeout);
+      this.mouseDownTimeout = setTimeout(() => {
+        this.hasPopupMouseDown = false;
+      }, 0);
+      if (vcTriggerContext.onPopupMouseDown) vcTriggerContext.onPopupMouseDown(...arguments);
+    },
+    onDocumentClick(event) {
+      if (this.$props.mask && !this.$props.maskClosable) return;
+      const target = event.target;
+      const root = this.getRootDomNode();
+      const popupNode = this.getPopupDomNode();
+      if ((!contains(root, target) || this.isContextMenuOnly()) && !contains(popupNode, target) && !this.hasPopupMouseDown) this.delaySetPopupVisible(false, 0.1);
+    },
+    getPopupDomNode() {
+      var _a;
+      return ((_a = this.popupRef) === null || _a === void 0 ? void 0 : _a.getElement()) || null;
+    },
+    getRootDomNode() {
+      var _a, _b, _c, _d;
+      const { getTriggerDOMNode } = this.$props;
+      if (getTriggerDOMNode) {
+        const domNode = ((_b = (_a = this.triggerRef) === null || _a === void 0 ? void 0 : _a.$el) === null || _b === void 0 ? void 0 : _b.nodeName) === "#comment" ? null : findDOMNode(this.triggerRef);
+        return findDOMNode(getTriggerDOMNode(domNode));
+      }
+      try {
+        const domNode = ((_d = (_c = this.triggerRef) === null || _c === void 0 ? void 0 : _c.$el) === null || _d === void 0 ? void 0 : _d.nodeName) === "#comment" ? null : findDOMNode(this.triggerRef);
+        if (domNode) return domNode;
+      } catch (err) {
+      }
+      return findDOMNode(this);
+    },
+    handleGetPopupClassFromAlign(align) {
+      const className = [];
+      const { popupPlacement, builtinPlacements, prefixCls, alignPoint: alignPoint2, getPopupClassNameFromAlign } = this.$props;
+      if (popupPlacement && builtinPlacements) className.push(getAlignPopupClassName(builtinPlacements, prefixCls, align, alignPoint2));
+      if (getPopupClassNameFromAlign) className.push(getPopupClassNameFromAlign(align));
+      return className.join(" ");
+    },
+    getPopupAlign() {
+      const { popupPlacement, popupAlign, builtinPlacements } = this.$props;
+      if (popupPlacement && builtinPlacements) return getAlignFromPlacement(builtinPlacements, popupPlacement, popupAlign);
+      return popupAlign;
+    },
+    getComponent() {
+      const mouseProps = {};
+      if (this.isMouseEnterToShow()) mouseProps.onMouseenter = this.onPopupMouseenter;
+      if (this.isMouseLeaveToHide()) mouseProps.onMouseleave = this.onPopupMouseleave;
+      mouseProps.onMousedown = this.onPopupMouseDown;
+      mouseProps[supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"] = this.onPopupMouseDown;
+      const { handleGetPopupClassFromAlign, getRootDomNode, $attrs } = this;
+      const { prefixCls, destroyPopupOnHide, popupClassName, popupAnimation, popupTransitionName, popupStyle, mask, maskAnimation, maskTransitionName, zIndex, stretch, alignPoint: alignPoint2, mobile, arrow, forceRender } = this.$props;
+      const { sPopupVisible, point } = this.$data;
+      const popupProps2 = _extends(_extends({
+        prefixCls,
+        arrow,
+        destroyPopupOnHide,
+        visible: sPopupVisible,
+        point: alignPoint2 ? point : null,
+        align: this.align,
+        animation: popupAnimation,
+        getClassNameFromAlign: handleGetPopupClassFromAlign,
+        stretch,
+        getRootDomNode,
+        mask,
+        zIndex,
+        transitionName: popupTransitionName,
+        maskAnimation,
+        maskTransitionName,
+        class: popupClassName,
+        style: popupStyle,
+        onAlign: $attrs.onPopupAlign || noop
+      }, mouseProps), {
+        ref: this.setPopupRef,
+        mobile,
+        forceRender
+      });
+      return createVNode(Popup_default, popupProps2, { default: this.$slots.popup || (() => getComponent(this, "popup")) });
+    },
+    attachParent(popupContainer) {
+      wrapperRaf.cancel(this.attachId);
+      const { getPopupContainer, getDocument: getDocument2 } = this.$props;
+      const domNode = this.getRootDomNode();
+      let mountNode;
+      if (!getPopupContainer) mountNode = getDocument2(this.getRootDomNode()).body;
+      else if (domNode || getPopupContainer.length === 0) mountNode = getPopupContainer(domNode);
+      if (mountNode) mountNode.appendChild(popupContainer);
+      else this.attachId = wrapperRaf(() => {
+        this.attachParent(popupContainer);
+      });
+    },
+    getContainer() {
+      const { $props: props } = this;
+      const { getDocument: getDocument2 } = props;
+      const popupContainer = getDocument2(this.getRootDomNode()).createElement("div");
+      popupContainer.style.position = "absolute";
+      popupContainer.style.top = "0";
+      popupContainer.style.left = "0";
+      popupContainer.style.width = "100%";
+      this.attachParent(popupContainer);
+      return popupContainer;
+    },
+    setPopupVisible(sPopupVisible, event) {
+      const { alignPoint: alignPoint2, sPopupVisible: prevPopupVisible, onPopupVisibleChange } = this;
+      this.clearDelayTimer();
+      if (prevPopupVisible !== sPopupVisible) {
+        if (!hasProp(this, "popupVisible")) this.setState({
+          sPopupVisible,
+          prevPopupVisible
+        });
+        onPopupVisibleChange && onPopupVisibleChange(sPopupVisible);
+      }
+      if (alignPoint2 && event && sPopupVisible) this.setPoint(event);
+    },
+    setPoint(point) {
+      const { alignPoint: alignPoint2 } = this.$props;
+      if (!alignPoint2 || !point) return;
+      this.setState({ point: {
+        pageX: point.pageX,
+        pageY: point.pageY
+      } });
+    },
+    handlePortalUpdate() {
+      if (this.prevPopupVisible !== this.sPopupVisible) this.afterPopupVisibleChange(this.sPopupVisible);
+    },
+    delaySetPopupVisible(visible, delayS, event) {
+      const delay = delayS * 1e3;
+      this.clearDelayTimer();
+      if (delay) {
+        const point = event ? {
+          pageX: event.pageX,
+          pageY: event.pageY
+        } : null;
+        this.delayTimer = setTimeout(() => {
+          this.setPopupVisible(visible, point);
+          this.clearDelayTimer();
+        }, delay);
+      } else this.setPopupVisible(visible, event);
+    },
+    clearDelayTimer() {
+      if (this.delayTimer) {
+        clearTimeout(this.delayTimer);
+        this.delayTimer = null;
+      }
+    },
+    clearOutsideHandler() {
+      if (this.clickOutsideHandler) {
+        this.clickOutsideHandler.remove();
+        this.clickOutsideHandler = null;
+      }
+      if (this.contextmenuOutsideHandler1) {
+        this.contextmenuOutsideHandler1.remove();
+        this.contextmenuOutsideHandler1 = null;
+      }
+      if (this.contextmenuOutsideHandler2) {
+        this.contextmenuOutsideHandler2.remove();
+        this.contextmenuOutsideHandler2 = null;
+      }
+      if (this.touchOutsideHandler) {
+        this.touchOutsideHandler.remove();
+        this.touchOutsideHandler = null;
+      }
+    },
+    createTwoChains(event) {
+      let fn = () => {
+      };
+      const events = getEvents(this);
+      if (this.childOriginEvents[event] && events[event]) return this[`fire${event}`];
+      fn = this.childOriginEvents[event] || events[event] || fn;
+      return fn;
+    },
+    isClickToShow() {
+      const { action, showAction } = this.$props;
+      return action.indexOf("click") !== -1 || showAction.indexOf("click") !== -1;
+    },
+    isContextMenuOnly() {
+      const { action } = this.$props;
+      return action === "contextmenu" || action.length === 1 && action[0] === "contextmenu";
+    },
+    isContextmenuToShow() {
+      const { action, showAction } = this.$props;
+      return action.indexOf("contextmenu") !== -1 || showAction.indexOf("contextmenu") !== -1;
+    },
+    isClickToHide() {
+      const { action, hideAction } = this.$props;
+      return action.indexOf("click") !== -1 || hideAction.indexOf("click") !== -1;
+    },
+    isMouseEnterToShow() {
+      const { action, showAction } = this.$props;
+      return action.indexOf("hover") !== -1 || showAction.indexOf("mouseenter") !== -1;
+    },
+    isMouseLeaveToHide() {
+      const { action, hideAction } = this.$props;
+      return action.indexOf("hover") !== -1 || hideAction.indexOf("mouseleave") !== -1;
+    },
+    isFocusToShow() {
+      const { action, showAction } = this.$props;
+      return action.indexOf("focus") !== -1 || showAction.indexOf("focus") !== -1;
+    },
+    isBlurToHide() {
+      const { action, hideAction } = this.$props;
+      return action.indexOf("focus") !== -1 || hideAction.indexOf("blur") !== -1;
+    },
+    forcePopupAlign() {
+      var _a;
+      if (this.$data.sPopupVisible) (_a = this.popupRef) === null || _a === void 0 || _a.forceAlign();
+    },
+    fireEvents(type, e) {
+      if (this.childOriginEvents[type]) this.childOriginEvents[type](e);
+      const event = this.$props[type] || this.$attrs[type];
+      if (event) event(e);
+    },
+    close() {
+      this.setPopupVisible(false);
+    }
+  },
+  render() {
+    const { $attrs } = this;
+    const children = filterEmpty(getSlot(this));
+    const { alignPoint: alignPoint2, getPopupContainer } = this.$props;
+    const child = children[0];
+    this.childOriginEvents = getEvents(child);
+    const newChildProps = { key: "trigger" };
+    if (this.isContextmenuToShow()) newChildProps.onContextmenu = this.onContextmenu;
+    else newChildProps.onContextmenu = this.createTwoChains("onContextmenu");
+    if (this.isClickToHide() || this.isClickToShow()) {
+      newChildProps.onClick = this.onClick;
+      newChildProps.onMousedown = this.onMousedown;
+      newChildProps[supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"] = this.onTouchstart;
+    } else {
+      newChildProps.onClick = this.createTwoChains("onClick");
+      newChildProps.onMousedown = this.createTwoChains("onMousedown");
+      newChildProps[supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"] = this.createTwoChains("onTouchstart");
+    }
+    if (this.isMouseEnterToShow()) {
+      newChildProps.onMouseenter = this.onMouseenter;
+      if (alignPoint2) newChildProps.onMousemove = this.onMouseMove;
+    } else newChildProps.onMouseenter = this.createTwoChains("onMouseenter");
+    if (this.isMouseLeaveToHide()) newChildProps.onMouseleave = this.onMouseleave;
+    else newChildProps.onMouseleave = this.createTwoChains("onMouseleave");
+    if (this.isFocusToShow() || this.isBlurToHide()) {
+      newChildProps.onFocus = this.onFocus;
+      newChildProps.onBlur = this.onBlur;
+    } else {
+      newChildProps.onFocus = this.createTwoChains("onFocus");
+      newChildProps.onBlur = (e) => {
+        if (e && (!e.relatedTarget || !contains(e.target, e.relatedTarget))) this.createTwoChains("onBlur")(e);
+      };
+    }
+    const childrenClassName = classNames(child && child.props && child.props.class, $attrs.class);
+    if (childrenClassName) newChildProps.class = childrenClassName;
+    const trigger = cloneElement(child, _extends(_extends({}, newChildProps), { ref: "triggerRef" }), true, true);
+    const portal = createVNode(PortalWrapper_default, {
+      "key": "portal",
+      "getContainer": getPopupContainer && (() => getPopupContainer(this.getRootDomNode())),
+      "didUpdate": this.handlePortalUpdate,
+      "visible": this.$data.sPopupVisible
+    }, { default: this.getComponent });
+    return createVNode(Fragment, null, [trigger, portal]);
+  }
+});
+function useMergedState(defaultStateValue, option) {
+  const { defaultValue, value = ref() } = option || {};
+  let initValue = typeof defaultStateValue === "function" ? defaultStateValue() : defaultStateValue;
+  if (value.value !== void 0) initValue = unref(value);
+  if (defaultValue !== void 0) initValue = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  const innerValue = ref(initValue);
+  const mergedValue = ref(initValue);
+  watchEffect(() => {
+    let val = value.value !== void 0 ? value.value : innerValue.value;
+    if (option.postState) val = option.postState(val);
+    mergedValue.value = val;
+  });
+  function triggerChange(newValue) {
+    const preVal = mergedValue.value;
+    innerValue.value = newValue;
+    if (toRaw(mergedValue.value) !== newValue && option.onChange) option.onChange(newValue, preVal);
+  }
+  watch(value, () => {
+    innerValue.value = value.value;
+  });
+  return [mergedValue, triggerChange];
+}
+function firstNotUndefined() {
+  let arr = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+  for (let i = 0, len = arr.length; i < len; i++) if (arr[i] !== void 0) return arr[i];
+}
+
+export { BaseMixin_default as B, isVisible_default as a, firstNotUndefined as f, index as i, useMergedState as u, vc_trigger_default as v, wrapperRaf as w };
+//# sourceMappingURL=firstNotUndefined-laiThpLD.mjs.map