5zu-books/admin-frontend/node_modules/element-plus/dist/index.full.js

/*! Element Plus v2.11.7 */

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
  typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ElementPlus = {}, global.Vue));
})(this, (function (exports, vue) { 'use strict';

  const FOCUSABLE_ELEMENT_SELECTORS = `a[href],button:not([disabled]),button:not([hidden]),:not([tabindex="-1"]),input:not([disabled]),input:not([type="hidden"]),select:not([disabled]),textarea:not([disabled])`;
  const isHTMLElement$2 = (e) => {
    if (typeof Element === "undefined")
      return false;
    return e instanceof Element;
  };
  const isVisible = (element) => {
    const computed = getComputedStyle(element);
    return computed.position === "fixed" ? false : element.offsetParent !== null;
  };
  const obtainAllFocusableElements$1 = (element) => {
    return Array.from(element.querySelectorAll(FOCUSABLE_ELEMENT_SELECTORS)).filter((item) => isFocusable(item) && isVisible(item));
  };
  const isFocusable = (element) => {
    if (element.tabIndex > 0 || element.tabIndex === 0 && element.getAttribute("tabIndex") !== null) {
      return true;
    }
    if (element.tabIndex < 0 || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") {
      return false;
    }
    switch (element.nodeName) {
      case "A": {
        return !!element.href && element.rel !== "ignore";
      }
      case "INPUT": {
        return !(element.type === "hidden" || element.type === "file");
      }
      case "BUTTON":
      case "SELECT":
      case "TEXTAREA": {
        return true;
      }
      default: {
        return false;
      }
    }
  };
  const triggerEvent = function(elm, name, ...opts) {
    let eventName;
    if (name.includes("mouse") || name.includes("click")) {
      eventName = "MouseEvents";
    } else if (name.includes("key")) {
      eventName = "KeyboardEvent";
    } else {
      eventName = "HTMLEvents";
    }
    const evt = document.createEvent(eventName);
    evt.initEvent(name, ...opts);
    elm.dispatchEvent(evt);
    return elm;
  };
  const isLeaf = (el) => !el.getAttribute("aria-owns");
  const getSibling = (el, distance, elClass) => {
    const { parentNode } = el;
    if (!parentNode)
      return null;
    const siblings = parentNode.querySelectorAll(elClass);
    const index = Array.prototype.indexOf.call(siblings, el);
    return siblings[index + distance] || null;
  };
  const focusElement = (el, options) => {
    if (!el || !el.focus)
      return;
    let cleanup = false;
    if (isHTMLElement$2(el) && !isFocusable(el) && !el.getAttribute("tabindex")) {
      el.setAttribute("tabindex", "-1");
      cleanup = true;
    }
    el.focus(options);
    if (isHTMLElement$2(el) && cleanup) {
      el.removeAttribute("tabindex");
    }
  };
  const focusNode = (el) => {
    if (!el)
      return;
    focusElement(el);
    !isLeaf(el) && el.click();
  };

  const EVENT_CODE = {
    tab: "Tab",
    enter: "Enter",
    space: "Space",
    left: "ArrowLeft",
    up: "ArrowUp",
    right: "ArrowRight",
    down: "ArrowDown",
    esc: "Escape",
    delete: "Delete",
    backspace: "Backspace",
    numpadEnter: "NumpadEnter",
    pageUp: "PageUp",
    pageDown: "PageDown",
    home: "Home",
    end: "End"
  };

  const datePickTypes = [
    "year",
    "years",
    "month",
    "months",
    "date",
    "dates",
    "week",
    "datetime",
    "datetimerange",
    "daterange",
    "monthrange",
    "yearrange"
  ];
  const WEEK_DAYS = [
    "sun",
    "mon",
    "tue",
    "wed",
    "thu",
    "fri",
    "sat"
  ];

  const UPDATE_MODEL_EVENT = "update:modelValue";
  const CHANGE_EVENT = "change";
  const INPUT_EVENT = "input";

  const INSTALLED_KEY = Symbol("INSTALLED_KEY");

  const componentSizes = ["", "default", "small", "large"];
  const componentSizeMap = {
    large: 40,
    default: 32,
    small: 24
  };

  const columnAlignment = ["left", "center", "right"];

  const MINIMUM_INPUT_WIDTH = 11;
  const BORDER_HORIZONTAL_WIDTH = 2;

  function computedEager(fn, options) {
    var _a;
    const result = vue.shallowRef();
    vue.watchEffect(() => {
      result.value = fn();
    }, {
      ...options,
      flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
    });
    return vue.readonly(result);
  }

  function tryOnScopeDispose(fn) {
    if (vue.getCurrentScope()) {
      vue.onScopeDispose(fn);
      return true;
    }
    return false;
  }

  function toValue(r) {
    return typeof r === "function" ? r() : vue.unref(r);
  }

  function toReactive(objectRef) {
    if (!vue.isRef(objectRef))
      return vue.reactive(objectRef);
    const proxy = new Proxy({}, {
      get(_, p, receiver) {
        return vue.unref(Reflect.get(objectRef.value, p, receiver));
      },
      set(_, p, value) {
        if (vue.isRef(objectRef.value[p]) && !vue.isRef(value))
          objectRef.value[p].value = value;
        else
          objectRef.value[p] = value;
        return true;
      },
      deleteProperty(_, p) {
        return Reflect.deleteProperty(objectRef.value, p);
      },
      has(_, p) {
        return Reflect.has(objectRef.value, p);
      },
      ownKeys() {
        return Object.keys(objectRef.value);
      },
      getOwnPropertyDescriptor() {
        return {
          enumerable: true,
          configurable: true
        };
      }
    });
    return vue.reactive(proxy);
  }

  function reactiveComputed(fn) {
    return toReactive(vue.computed(fn));
  }

  const isClient = typeof window !== "undefined" && typeof document !== "undefined";
  typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
  const isDef = (val) => typeof val !== "undefined";
  const notNullish = (val) => val != null;
  const toString$1 = Object.prototype.toString;
  const isObject$2 = (val) => toString$1.call(val) === "[object Object]";
  const clamp$2 = (n, min, max) => Math.min(max, Math.max(min, n));
  const noop$1 = () => {
  };
  const isIOS = /* @__PURE__ */ getIsIOS();
  function getIsIOS() {
    var _a, _b;
    return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
  }

  function createFilterWrapper(filter, fn) {
    function wrapper(...args) {
      return new Promise((resolve, reject) => {
        Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
      });
    }
    return wrapper;
  }
  function debounceFilter(ms, options = {}) {
    let timer;
    let maxTimer;
    let lastRejector = noop$1;
    const _clearTimeout = (timer2) => {
      clearTimeout(timer2);
      lastRejector();
      lastRejector = noop$1;
    };
    const filter = (invoke) => {
      const duration = toValue(ms);
      const maxDuration = toValue(options.maxWait);
      if (timer)
        _clearTimeout(timer);
      if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
        if (maxTimer) {
          _clearTimeout(maxTimer);
          maxTimer = null;
        }
        return Promise.resolve(invoke());
      }
      return new Promise((resolve, reject) => {
        lastRejector = options.rejectOnCancel ? reject : resolve;
        if (maxDuration && !maxTimer) {
          maxTimer = setTimeout(() => {
            if (timer)
              _clearTimeout(timer);
            maxTimer = null;
            resolve(invoke());
          }, maxDuration);
        }
        timer = setTimeout(() => {
          if (maxTimer)
            _clearTimeout(maxTimer);
          maxTimer = null;
          resolve(invoke());
        }, duration);
      });
    };
    return filter;
  }
  function throttleFilter(...args) {
    let lastExec = 0;
    let timer;
    let isLeading = true;
    let lastRejector = noop$1;
    let lastValue;
    let ms;
    let trailing;
    let leading;
    let rejectOnCancel;
    if (!vue.isRef(args[0]) && typeof args[0] === "object")
      ({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]);
    else
      [ms, trailing = true, leading = true, rejectOnCancel = false] = args;
    const clear = () => {
      if (timer) {
        clearTimeout(timer);
        timer = void 0;
        lastRejector();
        lastRejector = noop$1;
      }
    };
    const filter = (_invoke) => {
      const duration = toValue(ms);
      const elapsed = Date.now() - lastExec;
      const invoke = () => {
        return lastValue = _invoke();
      };
      clear();
      if (duration <= 0) {
        lastExec = Date.now();
        return invoke();
      }
      if (elapsed > duration && (leading || !isLeading)) {
        lastExec = Date.now();
        invoke();
      } else if (trailing) {
        lastValue = new Promise((resolve, reject) => {
          lastRejector = rejectOnCancel ? reject : resolve;
          timer = setTimeout(() => {
            lastExec = Date.now();
            isLeading = true;
            resolve(invoke());
            clear();
          }, Math.max(0, duration - elapsed));
        });
      }
      if (!leading && !timer)
        timer = setTimeout(() => isLeading = true, duration);
      isLeading = false;
      return lastValue;
    };
    return filter;
  }
  function getLifeCycleTarget(target) {
    return target || vue.getCurrentInstance();
  }

  function useDebounceFn(fn, ms = 200, options = {}) {
    return createFilterWrapper(
      debounceFilter(ms, options),
      fn
    );
  }

  function refDebounced(value, ms = 200, options = {}) {
    const debounced = vue.ref(value.value);
    const updater = useDebounceFn(() => {
      debounced.value = value.value;
    }, ms, options);
    vue.watch(value, () => updater());
    return debounced;
  }

  function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
    return createFilterWrapper(
      throttleFilter(ms, trailing, leading, rejectOnCancel),
      fn
    );
  }

  function tryOnMounted(fn, sync = true, target) {
    const instance = getLifeCycleTarget();
    if (instance)
      vue.onMounted(fn, target);
    else if (sync)
      fn();
    else
      vue.nextTick(fn);
  }

  function useTimeoutFn(cb, interval, options = {}) {
    const {
      immediate = true
    } = options;
    const isPending = vue.ref(false);
    let timer = null;
    function clear() {
      if (timer) {
        clearTimeout(timer);
        timer = null;
      }
    }
    function stop() {
      isPending.value = false;
      clear();
    }
    function start(...args) {
      clear();
      isPending.value = true;
      timer = setTimeout(() => {
        isPending.value = false;
        timer = null;
        cb(...args);
      }, toValue(interval));
    }
    if (immediate) {
      isPending.value = true;
      if (isClient)
        start();
    }
    tryOnScopeDispose(stop);
    return {
      isPending: vue.readonly(isPending),
      start,
      stop
    };
  }

  function unrefElement(elRef) {
    var _a;
    const plain = toValue(elRef);
    return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
  }

  const defaultWindow = isClient ? window : void 0;
  const defaultDocument = isClient ? window.document : void 0;

  function useEventListener(...args) {
    let target;
    let events;
    let listeners;
    let options;
    if (typeof args[0] === "string" || Array.isArray(args[0])) {
      [events, listeners, options] = args;
      target = defaultWindow;
    } else {
      [target, events, listeners, options] = args;
    }
    if (!target)
      return noop$1;
    if (!Array.isArray(events))
      events = [events];
    if (!Array.isArray(listeners))
      listeners = [listeners];
    const cleanups = [];
    const cleanup = () => {
      cleanups.forEach((fn) => fn());
      cleanups.length = 0;
    };
    const register = (el, event, listener, options2) => {
      el.addEventListener(event, listener, options2);
      return () => el.removeEventListener(event, listener, options2);
    };
    const stopWatch = vue.watch(
      () => [unrefElement(target), toValue(options)],
      ([el, options2]) => {
        cleanup();
        if (!el)
          return;
        const optionsClone = isObject$2(options2) ? { ...options2 } : options2;
        cleanups.push(
          ...events.flatMap((event) => {
            return listeners.map((listener) => register(el, event, listener, optionsClone));
          })
        );
      },
      { immediate: true, flush: "post" }
    );
    const stop = () => {
      stopWatch();
      cleanup();
    };
    tryOnScopeDispose(stop);
    return stop;
  }

  let _iOSWorkaround = false;
  function onClickOutside(target, handler, options = {}) {
    const { window = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
    if (!window)
      return noop$1;
    if (isIOS && !_iOSWorkaround) {
      _iOSWorkaround = true;
      Array.from(window.document.body.children).forEach((el) => el.addEventListener("click", noop$1));
      window.document.documentElement.addEventListener("click", noop$1);
    }
    let shouldListen = true;
    const shouldIgnore = (event) => {
      return ignore.some((target2) => {
        if (typeof target2 === "string") {
          return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
        } else {
          const el = unrefElement(target2);
          return el && (event.target === el || event.composedPath().includes(el));
        }
      });
    };
    const listener = (event) => {
      const el = unrefElement(target);
      if (!el || el === event.target || event.composedPath().includes(el))
        return;
      if (event.detail === 0)
        shouldListen = !shouldIgnore(event);
      if (!shouldListen) {
        shouldListen = true;
        return;
      }
      handler(event);
    };
    const cleanup = [
      useEventListener(window, "click", listener, { passive: true, capture }),
      useEventListener(window, "pointerdown", (e) => {
        const el = unrefElement(target);
        shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
      }, { passive: true }),
      detectIframe && useEventListener(window, "blur", (event) => {
        setTimeout(() => {
          var _a;
          const el = unrefElement(target);
          if (((_a = window.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window.document.activeElement))) {
            handler(event);
          }
        }, 0);
      })
    ].filter(Boolean);
    const stop = () => cleanup.forEach((fn) => fn());
    return stop;
  }

  function useMounted() {
    const isMounted = vue.ref(false);
    const instance = vue.getCurrentInstance();
    if (instance) {
      vue.onMounted(() => {
        isMounted.value = true;
      }, instance);
    }
    return isMounted;
  }

  function useSupported(callback) {
    const isMounted = useMounted();
    return vue.computed(() => {
      isMounted.value;
      return Boolean(callback());
    });
  }

  function useMutationObserver(target, callback, options = {}) {
    const { window = defaultWindow, ...mutationOptions } = options;
    let observer;
    const isSupported = useSupported(() => window && "MutationObserver" in window);
    const cleanup = () => {
      if (observer) {
        observer.disconnect();
        observer = void 0;
      }
    };
    const targets = vue.computed(() => {
      const value = toValue(target);
      const items = (Array.isArray(value) ? value : [value]).map(unrefElement).filter(notNullish);
      return new Set(items);
    });
    const stopWatch = vue.watch(
      () => targets.value,
      (targets2) => {
        cleanup();
        if (isSupported.value && targets2.size) {
          observer = new MutationObserver(callback);
          targets2.forEach((el) => observer.observe(el, mutationOptions));
        }
      },
      { immediate: true, flush: "post" }
    );
    const takeRecords = () => {
      return observer == null ? void 0 : observer.takeRecords();
    };
    const stop = () => {
      cleanup();
      stopWatch();
    };
    tryOnScopeDispose(stop);
    return {
      isSupported,
      stop,
      takeRecords
    };
  }

  function useActiveElement(options = {}) {
    var _a;
    const {
      window = defaultWindow,
      deep = true,
      triggerOnRemoval = false
    } = options;
    const document = (_a = options.document) != null ? _a : window == null ? void 0 : window.document;
    const getDeepActiveElement = () => {
      var _a2;
      let element = document == null ? void 0 : document.activeElement;
      if (deep) {
        while (element == null ? void 0 : element.shadowRoot)
          element = (_a2 = element == null ? void 0 : element.shadowRoot) == null ? void 0 : _a2.activeElement;
      }
      return element;
    };
    const activeElement = vue.ref();
    const trigger = () => {
      activeElement.value = getDeepActiveElement();
    };
    if (window) {
      useEventListener(window, "blur", (event) => {
        if (event.relatedTarget !== null)
          return;
        trigger();
      }, true);
      useEventListener(window, "focus", trigger, true);
    }
    if (triggerOnRemoval) {
      useMutationObserver(document, (mutations) => {
        mutations.filter((m) => m.removedNodes.length).map((n) => Array.from(n.removedNodes)).flat().forEach((node) => {
          if (node === activeElement.value)
            trigger();
        });
      }, {
        childList: true,
        subtree: true
      });
    }
    trigger();
    return activeElement;
  }

  function useMediaQuery(query, options = {}) {
    const { window = defaultWindow } = options;
    const isSupported = useSupported(() => window && "matchMedia" in window && typeof window.matchMedia === "function");
    let mediaQuery;
    const matches = vue.ref(false);
    const handler = (event) => {
      matches.value = event.matches;
    };
    const cleanup = () => {
      if (!mediaQuery)
        return;
      if ("removeEventListener" in mediaQuery)
        mediaQuery.removeEventListener("change", handler);
      else
        mediaQuery.removeListener(handler);
    };
    const stopWatch = vue.watchEffect(() => {
      if (!isSupported.value)
        return;
      cleanup();
      mediaQuery = window.matchMedia(toValue(query));
      if ("addEventListener" in mediaQuery)
        mediaQuery.addEventListener("change", handler);
      else
        mediaQuery.addListener(handler);
      matches.value = mediaQuery.matches;
    });
    tryOnScopeDispose(() => {
      stopWatch();
      cleanup();
      mediaQuery = void 0;
    });
    return matches;
  }

  function cloneFnJSON(source) {
    return JSON.parse(JSON.stringify(source));
  }

  function useCssVar(prop, target, options = {}) {
    const { window = defaultWindow, initialValue = "", observe = false } = options;
    const variable = vue.ref(initialValue);
    const elRef = vue.computed(() => {
      var _a;
      return unrefElement(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);
    });
    function updateCssVar() {
      var _a;
      const key = toValue(prop);
      const el = toValue(elRef);
      if (el && window) {
        const value = (_a = window.getComputedStyle(el).getPropertyValue(key)) == null ? void 0 : _a.trim();
        variable.value = value || initialValue;
      }
    }
    if (observe) {
      useMutationObserver(elRef, updateCssVar, {
        attributeFilter: ["style", "class"],
        window
      });
    }
    vue.watch(
      [elRef, () => toValue(prop)],
      updateCssVar,
      { immediate: true }
    );
    vue.watch(
      variable,
      (val) => {
        var _a;
        if ((_a = elRef.value) == null ? void 0 : _a.style)
          elRef.value.style.setProperty(toValue(prop), val);
      }
    );
    return variable;
  }

  function useDocumentVisibility(options = {}) {
    const { document = defaultDocument } = options;
    if (!document)
      return vue.ref("visible");
    const visibility = vue.ref(document.visibilityState);
    useEventListener(document, "visibilitychange", () => {
      visibility.value = document.visibilityState;
    });
    return visibility;
  }

  function useResizeObserver(target, callback, options = {}) {
    const { window = defaultWindow, ...observerOptions } = options;
    let observer;
    const isSupported = useSupported(() => window && "ResizeObserver" in window);
    const cleanup = () => {
      if (observer) {
        observer.disconnect();
        observer = void 0;
      }
    };
    const targets = vue.computed(() => Array.isArray(target) ? target.map((el) => unrefElement(el)) : [unrefElement(target)]);
    const stopWatch = vue.watch(
      targets,
      (els) => {
        cleanup();
        if (isSupported.value && window) {
          observer = new ResizeObserver(callback);
          for (const _el of els)
            _el && observer.observe(_el, observerOptions);
        }
      },
      { immediate: true, flush: "post" }
    );
    const stop = () => {
      cleanup();
      stopWatch();
    };
    tryOnScopeDispose(stop);
    return {
      isSupported,
      stop
    };
  }

  function useElementBounding(target, options = {}) {
    const {
      reset = true,
      windowResize = true,
      windowScroll = true,
      immediate = true
    } = options;
    const height = vue.ref(0);
    const bottom = vue.ref(0);
    const left = vue.ref(0);
    const right = vue.ref(0);
    const top = vue.ref(0);
    const width = vue.ref(0);
    const x = vue.ref(0);
    const y = vue.ref(0);
    function update() {
      const el = unrefElement(target);
      if (!el) {
        if (reset) {
          height.value = 0;
          bottom.value = 0;
          left.value = 0;
          right.value = 0;
          top.value = 0;
          width.value = 0;
          x.value = 0;
          y.value = 0;
        }
        return;
      }
      const rect = el.getBoundingClientRect();
      height.value = rect.height;
      bottom.value = rect.bottom;
      left.value = rect.left;
      right.value = rect.right;
      top.value = rect.top;
      width.value = rect.width;
      x.value = rect.x;
      y.value = rect.y;
    }
    useResizeObserver(target, update);
    vue.watch(() => unrefElement(target), (ele) => !ele && update());
    useMutationObserver(target, update, {
      attributeFilter: ["style", "class"]
    });
    if (windowScroll)
      useEventListener("scroll", update, { capture: true, passive: true });
    if (windowResize)
      useEventListener("resize", update, { passive: true });
    tryOnMounted(() => {
      if (immediate)
        update();
    });
    return {
      height,
      bottom,
      left,
      right,
      top,
      width,
      x,
      y,
      update
    };
  }

  function useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) {
    const { window = defaultWindow, box = "content-box" } = options;
    const isSVG = vue.computed(() => {
      var _a, _b;
      return (_b = (_a = unrefElement(target)) == null ? void 0 : _a.namespaceURI) == null ? void 0 : _b.includes("svg");
    });
    const width = vue.ref(initialSize.width);
    const height = vue.ref(initialSize.height);
    const { stop: stop1 } = useResizeObserver(
      target,
      ([entry]) => {
        const boxSize = box === "border-box" ? entry.borderBoxSize : box === "content-box" ? entry.contentBoxSize : entry.devicePixelContentBoxSize;
        if (window && isSVG.value) {
          const $elem = unrefElement(target);
          if ($elem) {
            const rect = $elem.getBoundingClientRect();
            width.value = rect.width;
            height.value = rect.height;
          }
        } else {
          if (boxSize) {
            const formatBoxSize = Array.isArray(boxSize) ? boxSize : [boxSize];
            width.value = formatBoxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0);
            height.value = formatBoxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);
          } else {
            width.value = entry.contentRect.width;
            height.value = entry.contentRect.height;
          }
        }
      },
      options
    );
    tryOnMounted(() => {
      const ele = unrefElement(target);
      if (ele) {
        width.value = "offsetWidth" in ele ? ele.offsetWidth : initialSize.width;
        height.value = "offsetHeight" in ele ? ele.offsetHeight : initialSize.height;
      }
    });
    const stop2 = vue.watch(
      () => unrefElement(target),
      (ele) => {
        width.value = ele ? initialSize.width : 0;
        height.value = ele ? initialSize.height : 0;
      }
    );
    function stop() {
      stop1();
      stop2();
    }
    return {
      width,
      height,
      stop
    };
  }

  function useIntersectionObserver(target, callback, options = {}) {
    const {
      root,
      rootMargin = "0px",
      threshold = 0.1,
      window = defaultWindow,
      immediate = true
    } = options;
    const isSupported = useSupported(() => window && "IntersectionObserver" in window);
    const targets = vue.computed(() => {
      const _target = toValue(target);
      return (Array.isArray(_target) ? _target : [_target]).map(unrefElement).filter(notNullish);
    });
    let cleanup = noop$1;
    const isActive = vue.ref(immediate);
    const stopWatch = isSupported.value ? vue.watch(
      () => [targets.value, unrefElement(root), isActive.value],
      ([targets2, root2]) => {
        cleanup();
        if (!isActive.value)
          return;
        if (!targets2.length)
          return;
        const observer = new IntersectionObserver(
          callback,
          {
            root: unrefElement(root2),
            rootMargin,
            threshold
          }
        );
        targets2.forEach((el) => el && observer.observe(el));
        cleanup = () => {
          observer.disconnect();
          cleanup = noop$1;
        };
      },
      { immediate, flush: "post" }
    ) : noop$1;
    const stop = () => {
      cleanup();
      stopWatch();
      isActive.value = false;
    };
    tryOnScopeDispose(stop);
    return {
      isSupported,
      isActive,
      pause() {
        cleanup();
        isActive.value = false;
      },
      resume() {
        isActive.value = true;
      },
      stop
    };
  }

  function useVModel(props, key, emit, options = {}) {
    var _a, _b, _c;
    const {
      clone = false,
      passive = false,
      eventName,
      deep = false,
      defaultValue,
      shouldEmit
    } = options;
    const vm = vue.getCurrentInstance();
    const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
    let event = eventName;
    if (!key) {
      {
        key = "modelValue";
      }
    }
    event = event || `update:${key.toString()}`;
    const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val);
    const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
    const triggerEmit = (value) => {
      if (shouldEmit) {
        if (shouldEmit(value))
          _emit(event, value);
      } else {
        _emit(event, value);
      }
    };
    if (passive) {
      const initialValue = getValue();
      const proxy = vue.ref(initialValue);
      let isUpdating = false;
      vue.watch(
        () => props[key],
        (v) => {
          if (!isUpdating) {
            isUpdating = true;
            proxy.value = cloneFn(v);
            vue.nextTick(() => isUpdating = false);
          }
        }
      );
      vue.watch(
        proxy,
        (v) => {
          if (!isUpdating && (v !== props[key] || deep))
            triggerEmit(v);
        },
        { deep }
      );
      return proxy;
    } else {
      return vue.computed({
        get() {
          return getValue();
        },
        set(value) {
          triggerEmit(value);
        }
      });
    }
  }

  function useWindowFocus(options = {}) {
    const { window = defaultWindow } = options;
    if (!window)
      return vue.ref(false);
    const focused = vue.ref(window.document.hasFocus());
    useEventListener(window, "blur", () => {
      focused.value = false;
    });
    useEventListener(window, "focus", () => {
      focused.value = true;
    });
    return focused;
  }

  function useWindowSize(options = {}) {
    const {
      window = defaultWindow,
      initialWidth = Number.POSITIVE_INFINITY,
      initialHeight = Number.POSITIVE_INFINITY,
      listenOrientation = true,
      includeScrollbar = true
    } = options;
    const width = vue.ref(initialWidth);
    const height = vue.ref(initialHeight);
    const update = () => {
      if (window) {
        if (includeScrollbar) {
          width.value = window.innerWidth;
          height.value = window.innerHeight;
        } else {
          width.value = window.document.documentElement.clientWidth;
          height.value = window.document.documentElement.clientHeight;
        }
      }
    };
    update();
    tryOnMounted(update);
    useEventListener("resize", update, { passive: true });
    if (listenOrientation) {
      const matches = useMediaQuery("(orientation: portrait)");
      vue.watch(matches, () => update());
    }
    return { width, height };
  }

  const isFirefox = () => isClient && /firefox/i.test(window.navigator.userAgent);
  const isAndroid = () => isClient && /android/i.test(window.navigator.userAgent);

  const composeEventHandlers = (theirsHandler, oursHandler, { checkForDefaultPrevented = true } = {}) => {
    const handleEvent = (event) => {
      const shouldPrevent = theirsHandler == null ? void 0 : theirsHandler(event);
      if (checkForDefaultPrevented === false || !shouldPrevent) {
        return oursHandler == null ? void 0 : oursHandler(event);
      }
    };
    return handleEvent;
  };
  const whenMouse = (handler) => {
    return (e) => e.pointerType === "mouse" ? handler(e) : void 0;
  };
  const getEventCode = (event) => {
    if (event.code && event.code !== "Unidentified")
      return event.code;
    const key = getEventKey(event);
    if (key) {
      if (Object.values(EVENT_CODE).includes(key))
        return key;
      switch (key) {
        case " ":
          return EVENT_CODE.space;
        default:
          return "";
      }
    }
    return "";
  };
  const getEventKey = (event) => {
    let key = event.key && event.key !== "Unidentified" ? event.key : "";
    if (!key && event.type === "keyup" && isAndroid()) {
      const target = event.target;
      key = target.value.charAt(target.selectionStart - 1);
    }
    return key;
  };

  const getOffsetTop = (el) => {
    let offset = 0;
    let parent = el;
    while (parent) {
      offset += parent.offsetTop;
      parent = parent.offsetParent;
    }
    return offset;
  };
  const getOffsetTopDistance = (el, containerEl) => {
    return Math.abs(getOffsetTop(el) - getOffsetTop(containerEl));
  };
  const getClientXY = (event) => {
    let clientX;
    let clientY;
    if (event.type === "touchend") {
      clientY = event.changedTouches[0].clientY;
      clientX = event.changedTouches[0].clientX;
    } else if (event.type.startsWith("touch")) {
      clientY = event.touches[0].clientY;
      clientX = event.touches[0].clientX;
    } else {
      clientY = event.clientY;
      clientX = event.clientX;
    }
    return {
      clientX,
      clientY
    };
  };

  function easeInOutCubic(t, b, c, d) {
    const cc = c - b;
    t /= d / 2;
    if (t < 1) {
      return cc / 2 * t * t * t + b;
    }
    return cc / 2 * ((t -= 2) * t * t + 2) + b;
  }

  const NOOP = () => {
  };
  const hasOwnProperty$p = Object.prototype.hasOwnProperty;
  const hasOwn = (val, key) => hasOwnProperty$p.call(val, key);
  const isArray$1 = Array.isArray;
  const isDate$1 = (val) => toTypeString(val) === "[object Date]";
  const isFunction$1 = (val) => typeof val === "function";
  const isString$1 = (val) => typeof val === "string";
  const isObject$1 = (val) => val !== null && typeof val === "object";
  const isPromise = (val) => {
    return isObject$1(val) && isFunction$1(val.then) && isFunction$1(val.catch);
  };
  const objectToString$1 = Object.prototype.toString;
  const toTypeString = (value) => objectToString$1.call(value);
  const isPlainObject$1 = (val) => toTypeString(val) === "[object Object]";
  const cacheStringFunction = (fn) => {
    const cache = /* @__PURE__ */ Object.create(null);
    return (str) => {
      const hit = cache[str];
      return hit || (cache[str] = fn(str));
    };
  };
  const camelizeRE = /-(\w)/g;
  const camelize = cacheStringFunction((str) => {
    return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
  });
  const hyphenateRE = /\B([A-Z])/g;
  const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
  const capitalize$2 = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));

  var freeGlobal = typeof global == "object" && global && global.Object === Object && global;

  var freeSelf = typeof self == "object" && self && self.Object === Object && self;
  var root = freeGlobal || freeSelf || Function("return this")();

  var Symbol$1 = root.Symbol;

  var objectProto$s = Object.prototype;
  var hasOwnProperty$o = objectProto$s.hasOwnProperty;
  var nativeObjectToString$3 = objectProto$s.toString;
  var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
  function getRawTag(value) {
    var isOwn = hasOwnProperty$o.call(value, symToStringTag$1), tag = value[symToStringTag$1];
    try {
      value[symToStringTag$1] = void 0;
      var unmasked = true;
    } catch (e) {
    }
    var result = nativeObjectToString$3.call(value);
    if (unmasked) {
      if (isOwn) {
        value[symToStringTag$1] = tag;
      } else {
        delete value[symToStringTag$1];
      }
    }
    return result;
  }

  var objectProto$r = Object.prototype;
  var nativeObjectToString$2 = objectProto$r.toString;
  function objectToString(value) {
    return nativeObjectToString$2.call(value);
  }

  var nullTag = "[object Null]";
  var undefinedTag = "[object Undefined]";
  var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
  function baseGetTag(value) {
    if (value == null) {
      return value === void 0 ? undefinedTag : nullTag;
    }
    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
  }

  function isObjectLike(value) {
    return value != null && typeof value == "object";
  }

  var symbolTag$3 = "[object Symbol]";
  function isSymbol(value) {
    return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$3;
  }

  var NAN$2 = 0 / 0;
  function baseToNumber(value) {
    if (typeof value == "number") {
      return value;
    }
    if (isSymbol(value)) {
      return NAN$2;
    }
    return +value;
  }

  function arrayMap(array, iteratee) {
    var index = -1, length = array == null ? 0 : array.length, result = Array(length);
    while (++index < length) {
      result[index] = iteratee(array[index], index, array);
    }
    return result;
  }

  var isArray = Array.isArray;

  var INFINITY$5 = 1 / 0;
  var symbolProto$2 = Symbol$1 ? Symbol$1.prototype : void 0;
  var symbolToString = symbolProto$2 ? symbolProto$2.toString : void 0;
  function baseToString(value) {
    if (typeof value == "string") {
      return value;
    }
    if (isArray(value)) {
      return arrayMap(value, baseToString) + "";
    }
    if (isSymbol(value)) {
      return symbolToString ? symbolToString.call(value) : "";
    }
    var result = value + "";
    return result == "0" && 1 / value == -INFINITY$5 ? "-0" : result;
  }

  function createMathOperation(operator, defaultValue) {
    return function(value, other) {
      var result;
      if (value === void 0 && other === void 0) {
        return defaultValue;
      }
      if (value !== void 0) {
        result = value;
      }
      if (other !== void 0) {
        if (result === void 0) {
          return other;
        }
        if (typeof value == "string" || typeof other == "string") {
          value = baseToString(value);
          other = baseToString(other);
        } else {
          value = baseToNumber(value);
          other = baseToNumber(other);
        }
        result = operator(value, other);
      }
      return result;
    };
  }

  var add = createMathOperation(function(augend, addend) {
    return augend + addend;
  }, 0);

  var reWhitespace = /\s/;
  function trimmedEndIndex(string) {
    var index = string.length;
    while (index-- && reWhitespace.test(string.charAt(index))) {
    }
    return index;
  }

  var reTrimStart$2 = /^\s+/;
  function baseTrim(string) {
    return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart$2, "") : string;
  }

  function isObject(value) {
    var type = typeof value;
    return value != null && (type == "object" || type == "function");
  }

  var NAN$1 = 0 / 0;
  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
  var reIsBinary = /^0b[01]+$/i;
  var reIsOctal = /^0o[0-7]+$/i;
  var freeParseInt = parseInt;
  function toNumber(value) {
    if (typeof value == "number") {
      return value;
    }
    if (isSymbol(value)) {
      return NAN$1;
    }
    if (isObject(value)) {
      var other = typeof value.valueOf == "function" ? value.valueOf() : value;
      value = isObject(other) ? other + "" : other;
    }
    if (typeof value != "string") {
      return value === 0 ? value : +value;
    }
    value = baseTrim(value);
    var isBinary = reIsBinary.test(value);
    return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN$1 : +value;
  }

  var INFINITY$4 = 1 / 0;
  var MAX_INTEGER = 17976931348623157e292;
  function toFinite(value) {
    if (!value) {
      return value === 0 ? value : 0;
    }
    value = toNumber(value);
    if (value === INFINITY$4 || value === -INFINITY$4) {
      var sign = value < 0 ? -1 : 1;
      return sign * MAX_INTEGER;
    }
    return value === value ? value : 0;
  }

  function toInteger(value) {
    var result = toFinite(value), remainder = result % 1;
    return result === result ? remainder ? result - remainder : result : 0;
  }

  var FUNC_ERROR_TEXT$b = "Expected a function";
  function after(n, func) {
    if (typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$b);
    }
    n = toInteger(n);
    return function() {
      if (--n < 1) {
        return func.apply(this, arguments);
      }
    };
  }

  function identity(value) {
    return value;
  }

  var asyncTag = "[object AsyncFunction]";
  var funcTag$2 = "[object Function]";
  var genTag$1 = "[object GeneratorFunction]";
  var proxyTag = "[object Proxy]";
  function isFunction(value) {
    if (!isObject(value)) {
      return false;
    }
    var tag = baseGetTag(value);
    return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
  }

  var coreJsData = root["__core-js_shared__"];

  var maskSrcKey = function() {
    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
    return uid ? "Symbol(src)_1." + uid : "";
  }();
  function isMasked(func) {
    return !!maskSrcKey && maskSrcKey in func;
  }

  var funcProto$2 = Function.prototype;
  var funcToString$2 = funcProto$2.toString;
  function toSource(func) {
    if (func != null) {
      try {
        return funcToString$2.call(func);
      } catch (e) {
      }
      try {
        return func + "";
      } catch (e) {
      }
    }
    return "";
  }

  var reRegExpChar$1 = /[\\^$.*+?()[\]{}|]/g;
  var reIsHostCtor = /^\[object .+?Constructor\]$/;
  var funcProto$1 = Function.prototype;
  var objectProto$q = Object.prototype;
  var funcToString$1 = funcProto$1.toString;
  var hasOwnProperty$n = objectProto$q.hasOwnProperty;
  var reIsNative = RegExp("^" + funcToString$1.call(hasOwnProperty$n).replace(reRegExpChar$1, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
  function baseIsNative(value) {
    if (!isObject(value) || isMasked(value)) {
      return false;
    }
    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
    return pattern.test(toSource(value));
  }

  function getValue$1(object, key) {
    return object == null ? void 0 : object[key];
  }

  function getNative(object, key) {
    var value = getValue$1(object, key);
    return baseIsNative(value) ? value : void 0;
  }

  var WeakMap$1 = getNative(root, "WeakMap");

  var metaMap = WeakMap$1 && new WeakMap$1();

  var baseSetData = !metaMap ? identity : function(func, data) {
    metaMap.set(func, data);
    return func;
  };

  var objectCreate = Object.create;
  var baseCreate = function() {
    function object() {
    }
    return function(proto) {
      if (!isObject(proto)) {
        return {};
      }
      if (objectCreate) {
        return objectCreate(proto);
      }
      object.prototype = proto;
      var result = new object();
      object.prototype = void 0;
      return result;
    };
  }();

  function createCtor(Ctor) {
    return function() {
      var args = arguments;
      switch (args.length) {
        case 0:
          return new Ctor();
        case 1:
          return new Ctor(args[0]);
        case 2:
          return new Ctor(args[0], args[1]);
        case 3:
          return new Ctor(args[0], args[1], args[2]);
        case 4:
          return new Ctor(args[0], args[1], args[2], args[3]);
        case 5:
          return new Ctor(args[0], args[1], args[2], args[3], args[4]);
        case 6:
          return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
        case 7:
          return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
      }
      var thisBinding = baseCreate(Ctor.prototype), result = Ctor.apply(thisBinding, args);
      return isObject(result) ? result : thisBinding;
    };
  }

  var WRAP_BIND_FLAG$8 = 1;
  function createBind(func, bitmask, thisArg) {
    var isBind = bitmask & WRAP_BIND_FLAG$8, Ctor = createCtor(func);
    function wrapper() {
      var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
      return fn.apply(isBind ? thisArg : this, arguments);
    }
    return wrapper;
  }

  function apply(func, thisArg, args) {
    switch (args.length) {
      case 0:
        return func.call(thisArg);
      case 1:
        return func.call(thisArg, args[0]);
      case 2:
        return func.call(thisArg, args[0], args[1]);
      case 3:
        return func.call(thisArg, args[0], args[1], args[2]);
    }
    return func.apply(thisArg, args);
  }

  var nativeMax$g = Math.max;
  function composeArgs(args, partials, holders, isCurried) {
    var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax$g(argsLength - holdersLength, 0), result = Array(leftLength + rangeLength), isUncurried = !isCurried;
    while (++leftIndex < leftLength) {
      result[leftIndex] = partials[leftIndex];
    }
    while (++argsIndex < holdersLength) {
      if (isUncurried || argsIndex < argsLength) {
        result[holders[argsIndex]] = args[argsIndex];
      }
    }
    while (rangeLength--) {
      result[leftIndex++] = args[argsIndex++];
    }
    return result;
  }

  var nativeMax$f = Math.max;
  function composeArgsRight(args, partials, holders, isCurried) {
    var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax$f(argsLength - holdersLength, 0), result = Array(rangeLength + rightLength), isUncurried = !isCurried;
    while (++argsIndex < rangeLength) {
      result[argsIndex] = args[argsIndex];
    }
    var offset = argsIndex;
    while (++rightIndex < rightLength) {
      result[offset + rightIndex] = partials[rightIndex];
    }
    while (++holdersIndex < holdersLength) {
      if (isUncurried || argsIndex < argsLength) {
        result[offset + holders[holdersIndex]] = args[argsIndex++];
      }
    }
    return result;
  }

  function countHolders(array, placeholder) {
    var length = array.length, result = 0;
    while (length--) {
      if (array[length] === placeholder) {
        ++result;
      }
    }
    return result;
  }

  function baseLodash() {
  }

  var MAX_ARRAY_LENGTH$6 = 4294967295;
  function LazyWrapper(value) {
    this.__wrapped__ = value;
    this.__actions__ = [];
    this.__dir__ = 1;
    this.__filtered__ = false;
    this.__iteratees__ = [];
    this.__takeCount__ = MAX_ARRAY_LENGTH$6;
    this.__views__ = [];
  }
  LazyWrapper.prototype = baseCreate(baseLodash.prototype);
  LazyWrapper.prototype.constructor = LazyWrapper;

  function noop() {
  }

  var getData = !metaMap ? noop : function(func) {
    return metaMap.get(func);
  };

  var realNames = {};

  var objectProto$p = Object.prototype;
  var hasOwnProperty$m = objectProto$p.hasOwnProperty;
  function getFuncName(func) {
    var result = func.name + "", array = realNames[result], length = hasOwnProperty$m.call(realNames, result) ? array.length : 0;
    while (length--) {
      var data = array[length], otherFunc = data.func;
      if (otherFunc == null || otherFunc == func) {
        return data.name;
      }
    }
    return result;
  }

  function LodashWrapper(value, chainAll) {
    this.__wrapped__ = value;
    this.__actions__ = [];
    this.__chain__ = !!chainAll;
    this.__index__ = 0;
    this.__values__ = void 0;
  }
  LodashWrapper.prototype = baseCreate(baseLodash.prototype);
  LodashWrapper.prototype.constructor = LodashWrapper;

  function copyArray(source, array) {
    var index = -1, length = source.length;
    array || (array = Array(length));
    while (++index < length) {
      array[index] = source[index];
    }
    return array;
  }

  function wrapperClone(wrapper) {
    if (wrapper instanceof LazyWrapper) {
      return wrapper.clone();
    }
    var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
    result.__actions__ = copyArray(wrapper.__actions__);
    result.__index__ = wrapper.__index__;
    result.__values__ = wrapper.__values__;
    return result;
  }

  var objectProto$o = Object.prototype;
  var hasOwnProperty$l = objectProto$o.hasOwnProperty;
  function lodash(value) {
    if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
      if (value instanceof LodashWrapper) {
        return value;
      }
      if (hasOwnProperty$l.call(value, "__wrapped__")) {
        return wrapperClone(value);
      }
    }
    return new LodashWrapper(value);
  }
  lodash.prototype = baseLodash.prototype;
  lodash.prototype.constructor = lodash;

  function isLaziable(func) {
    var funcName = getFuncName(func), other = lodash[funcName];
    if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
      return false;
    }
    if (func === other) {
      return true;
    }
    var data = getData(other);
    return !!data && func === data[0];
  }

  var HOT_COUNT = 800;
  var HOT_SPAN = 16;
  var nativeNow = Date.now;
  function shortOut(func) {
    var count = 0, lastCalled = 0;
    return function() {
      var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
      lastCalled = stamp;
      if (remaining > 0) {
        if (++count >= HOT_COUNT) {
          return arguments[0];
        }
      } else {
        count = 0;
      }
      return func.apply(void 0, arguments);
    };
  }

  var setData = shortOut(baseSetData);

  var reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/;
  var reSplitDetails = /,? & /;
  function getWrapDetails(source) {
    var match = source.match(reWrapDetails);
    return match ? match[1].split(reSplitDetails) : [];
  }

  var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/;
  function insertWrapDetails(source, details) {
    var length = details.length;
    if (!length) {
      return source;
    }
    var lastIndex = length - 1;
    details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
    details = details.join(length > 2 ? ", " : " ");
    return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
  }

  function constant(value) {
    return function() {
      return value;
    };
  }

  var defineProperty = function() {
    try {
      var func = getNative(Object, "defineProperty");
      func({}, "", {});
      return func;
    } catch (e) {
    }
  }();

  var baseSetToString = !defineProperty ? identity : function(func, string) {
    return defineProperty(func, "toString", {
      "configurable": true,
      "enumerable": false,
      "value": constant(string),
      "writable": true
    });
  };

  var setToString = shortOut(baseSetToString);

  function arrayEach(array, iteratee) {
    var index = -1, length = array == null ? 0 : array.length;
    while (++index < length) {
      if (iteratee(array[index], index, array) === false) {
        break;
      }
    }
    return array;
  }

  function baseFindIndex(array, predicate, fromIndex, fromRight) {
    var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
    while (fromRight ? index-- : ++index < length) {
      if (predicate(array[index], index, array)) {
        return index;
      }
    }
    return -1;
  }

  function baseIsNaN(value) {
    return value !== value;
  }

  function strictIndexOf(array, value, fromIndex) {
    var index = fromIndex - 1, length = array.length;
    while (++index < length) {
      if (array[index] === value) {
        return index;
      }
    }
    return -1;
  }

  function baseIndexOf(array, value, fromIndex) {
    return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
  }

  function arrayIncludes(array, value) {
    var length = array == null ? 0 : array.length;
    return !!length && baseIndexOf(array, value, 0) > -1;
  }

  var WRAP_BIND_FLAG$7 = 1;
  var WRAP_BIND_KEY_FLAG$6 = 2;
  var WRAP_CURRY_FLAG$6 = 8;
  var WRAP_CURRY_RIGHT_FLAG$3 = 16;
  var WRAP_PARTIAL_FLAG$6 = 32;
  var WRAP_PARTIAL_RIGHT_FLAG$3 = 64;
  var WRAP_ARY_FLAG$4 = 128;
  var WRAP_REARG_FLAG$3 = 256;
  var WRAP_FLIP_FLAG$2 = 512;
  var wrapFlags = [
    ["ary", WRAP_ARY_FLAG$4],
    ["bind", WRAP_BIND_FLAG$7],
    ["bindKey", WRAP_BIND_KEY_FLAG$6],
    ["curry", WRAP_CURRY_FLAG$6],
    ["curryRight", WRAP_CURRY_RIGHT_FLAG$3],
    ["flip", WRAP_FLIP_FLAG$2],
    ["partial", WRAP_PARTIAL_FLAG$6],
    ["partialRight", WRAP_PARTIAL_RIGHT_FLAG$3],
    ["rearg", WRAP_REARG_FLAG$3]
  ];
  function updateWrapDetails(details, bitmask) {
    arrayEach(wrapFlags, function(pair) {
      var value = "_." + pair[0];
      if (bitmask & pair[1] && !arrayIncludes(details, value)) {
        details.push(value);
      }
    });
    return details.sort();
  }

  function setWrapToString(wrapper, reference, bitmask) {
    var source = reference + "";
    return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
  }

  var WRAP_BIND_FLAG$6 = 1;
  var WRAP_BIND_KEY_FLAG$5 = 2;
  var WRAP_CURRY_BOUND_FLAG$1 = 4;
  var WRAP_CURRY_FLAG$5 = 8;
  var WRAP_PARTIAL_FLAG$5 = 32;
  var WRAP_PARTIAL_RIGHT_FLAG$2 = 64;
  function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
    var isCurry = bitmask & WRAP_CURRY_FLAG$5, newHolders = isCurry ? holders : void 0, newHoldersRight = isCurry ? void 0 : holders, newPartials = isCurry ? partials : void 0, newPartialsRight = isCurry ? void 0 : partials;
    bitmask |= isCurry ? WRAP_PARTIAL_FLAG$5 : WRAP_PARTIAL_RIGHT_FLAG$2;
    bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG$2 : WRAP_PARTIAL_FLAG$5);
    if (!(bitmask & WRAP_CURRY_BOUND_FLAG$1)) {
      bitmask &= ~(WRAP_BIND_FLAG$6 | WRAP_BIND_KEY_FLAG$5);
    }
    var newData = [
      func,
      bitmask,
      thisArg,
      newPartials,
      newHolders,
      newPartialsRight,
      newHoldersRight,
      argPos,
      ary,
      arity
    ];
    var result = wrapFunc.apply(void 0, newData);
    if (isLaziable(func)) {
      setData(result, newData);
    }
    result.placeholder = placeholder;
    return setWrapToString(result, func, bitmask);
  }

  function getHolder(func) {
    var object = func;
    return object.placeholder;
  }

  var MAX_SAFE_INTEGER$5 = 9007199254740991;
  var reIsUint = /^(?:0|[1-9]\d*)$/;
  function isIndex(value, length) {
    var type = typeof value;
    length = length == null ? MAX_SAFE_INTEGER$5 : length;
    return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
  }

  var nativeMin$e = Math.min;
  function reorder(array, indexes) {
    var arrLength = array.length, length = nativeMin$e(indexes.length, arrLength), oldArray = copyArray(array);
    while (length--) {
      var index = indexes[length];
      array[length] = isIndex(index, arrLength) ? oldArray[index] : void 0;
    }
    return array;
  }

  var PLACEHOLDER$1 = "__lodash_placeholder__";
  function replaceHolders(array, placeholder) {
    var index = -1, length = array.length, resIndex = 0, result = [];
    while (++index < length) {
      var value = array[index];
      if (value === placeholder || value === PLACEHOLDER$1) {
        array[index] = PLACEHOLDER$1;
        result[resIndex++] = index;
      }
    }
    return result;
  }

  var WRAP_BIND_FLAG$5 = 1;
  var WRAP_BIND_KEY_FLAG$4 = 2;
  var WRAP_CURRY_FLAG$4 = 8;
  var WRAP_CURRY_RIGHT_FLAG$2 = 16;
  var WRAP_ARY_FLAG$3 = 128;
  var WRAP_FLIP_FLAG$1 = 512;
  function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
    var isAry = bitmask & WRAP_ARY_FLAG$3, isBind = bitmask & WRAP_BIND_FLAG$5, isBindKey = bitmask & WRAP_BIND_KEY_FLAG$4, isCurried = bitmask & (WRAP_CURRY_FLAG$4 | WRAP_CURRY_RIGHT_FLAG$2), isFlip = bitmask & WRAP_FLIP_FLAG$1, Ctor = isBindKey ? void 0 : createCtor(func);
    function wrapper() {
      var length = arguments.length, args = Array(length), index = length;
      while (index--) {
        args[index] = arguments[index];
      }
      if (isCurried) {
        var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);
      }
      if (partials) {
        args = composeArgs(args, partials, holders, isCurried);
      }
      if (partialsRight) {
        args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
      }
      length -= holdersCount;
      if (isCurried && length < arity) {
        var newHolders = replaceHolders(args, placeholder);
        return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, thisArg, args, newHolders, argPos, ary, arity - length);
      }
      var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func;
      length = args.length;
      if (argPos) {
        args = reorder(args, argPos);
      } else if (isFlip && length > 1) {
        args.reverse();
      }
      if (isAry && ary < length) {
        args.length = ary;
      }
      if (this && this !== root && this instanceof wrapper) {
        fn = Ctor || createCtor(fn);
      }
      return fn.apply(thisBinding, args);
    }
    return wrapper;
  }

  function createCurry(func, bitmask, arity) {
    var Ctor = createCtor(func);
    function wrapper() {
      var length = arguments.length, args = Array(length), index = length, placeholder = getHolder(wrapper);
      while (index--) {
        args[index] = arguments[index];
      }
      var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);
      length -= holders.length;
      if (length < arity) {
        return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, void 0, args, holders, void 0, void 0, arity - length);
      }
      var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
      return apply(fn, this, args);
    }
    return wrapper;
  }

  var WRAP_BIND_FLAG$4 = 1;
  function createPartial(func, bitmask, thisArg, partials) {
    var isBind = bitmask & WRAP_BIND_FLAG$4, Ctor = createCtor(func);
    function wrapper() {
      var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func;
      while (++leftIndex < leftLength) {
        args[leftIndex] = partials[leftIndex];
      }
      while (argsLength--) {
        args[leftIndex++] = arguments[++argsIndex];
      }
      return apply(fn, isBind ? thisArg : this, args);
    }
    return wrapper;
  }

  var PLACEHOLDER = "__lodash_placeholder__";
  var WRAP_BIND_FLAG$3 = 1;
  var WRAP_BIND_KEY_FLAG$3 = 2;
  var WRAP_CURRY_BOUND_FLAG = 4;
  var WRAP_CURRY_FLAG$3 = 8;
  var WRAP_ARY_FLAG$2 = 128;
  var WRAP_REARG_FLAG$2 = 256;
  var nativeMin$d = Math.min;
  function mergeData(data, source) {
    var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG$3 | WRAP_BIND_KEY_FLAG$3 | WRAP_ARY_FLAG$2);
    var isCombo = srcBitmask == WRAP_ARY_FLAG$2 && bitmask == WRAP_CURRY_FLAG$3 || srcBitmask == WRAP_ARY_FLAG$2 && bitmask == WRAP_REARG_FLAG$2 && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG$2 | WRAP_REARG_FLAG$2) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG$3;
    if (!(isCommon || isCombo)) {
      return data;
    }
    if (srcBitmask & WRAP_BIND_FLAG$3) {
      data[2] = source[2];
      newBitmask |= bitmask & WRAP_BIND_FLAG$3 ? 0 : WRAP_CURRY_BOUND_FLAG;
    }
    var value = source[3];
    if (value) {
      var partials = data[3];
      data[3] = partials ? composeArgs(partials, value, source[4]) : value;
      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
    }
    value = source[5];
    if (value) {
      partials = data[5];
      data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
    }
    value = source[7];
    if (value) {
      data[7] = value;
    }
    if (srcBitmask & WRAP_ARY_FLAG$2) {
      data[8] = data[8] == null ? source[8] : nativeMin$d(data[8], source[8]);
    }
    if (data[9] == null) {
      data[9] = source[9];
    }
    data[0] = source[0];
    data[1] = newBitmask;
    return data;
  }

  var FUNC_ERROR_TEXT$a = "Expected a function";
  var WRAP_BIND_FLAG$2 = 1;
  var WRAP_BIND_KEY_FLAG$2 = 2;
  var WRAP_CURRY_FLAG$2 = 8;
  var WRAP_CURRY_RIGHT_FLAG$1 = 16;
  var WRAP_PARTIAL_FLAG$4 = 32;
  var WRAP_PARTIAL_RIGHT_FLAG$1 = 64;
  var nativeMax$e = Math.max;
  function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
    var isBindKey = bitmask & WRAP_BIND_KEY_FLAG$2;
    if (!isBindKey && typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$a);
    }
    var length = partials ? partials.length : 0;
    if (!length) {
      bitmask &= ~(WRAP_PARTIAL_FLAG$4 | WRAP_PARTIAL_RIGHT_FLAG$1);
      partials = holders = void 0;
    }
    ary = ary === void 0 ? ary : nativeMax$e(toInteger(ary), 0);
    arity = arity === void 0 ? arity : toInteger(arity);
    length -= holders ? holders.length : 0;
    if (bitmask & WRAP_PARTIAL_RIGHT_FLAG$1) {
      var partialsRight = partials, holdersRight = holders;
      partials = holders = void 0;
    }
    var data = isBindKey ? void 0 : getData(func);
    var newData = [
      func,
      bitmask,
      thisArg,
      partials,
      holders,
      partialsRight,
      holdersRight,
      argPos,
      ary,
      arity
    ];
    if (data) {
      mergeData(newData, data);
    }
    func = newData[0];
    bitmask = newData[1];
    thisArg = newData[2];
    partials = newData[3];
    holders = newData[4];
    arity = newData[9] = newData[9] === void 0 ? isBindKey ? 0 : func.length : nativeMax$e(newData[9] - length, 0);
    if (!arity && bitmask & (WRAP_CURRY_FLAG$2 | WRAP_CURRY_RIGHT_FLAG$1)) {
      bitmask &= ~(WRAP_CURRY_FLAG$2 | WRAP_CURRY_RIGHT_FLAG$1);
    }
    if (!bitmask || bitmask == WRAP_BIND_FLAG$2) {
      var result = createBind(func, bitmask, thisArg);
    } else if (bitmask == WRAP_CURRY_FLAG$2 || bitmask == WRAP_CURRY_RIGHT_FLAG$1) {
      result = createCurry(func, bitmask, arity);
    } else if ((bitmask == WRAP_PARTIAL_FLAG$4 || bitmask == (WRAP_BIND_FLAG$2 | WRAP_PARTIAL_FLAG$4)) && !holders.length) {
      result = createPartial(func, bitmask, thisArg, partials);
    } else {
      result = createHybrid.apply(void 0, newData);
    }
    var setter = data ? baseSetData : setData;
    return setWrapToString(setter(result, newData), func, bitmask);
  }

  var WRAP_ARY_FLAG$1 = 128;
  function ary(func, n, guard) {
    n = guard ? void 0 : n;
    n = func && n == null ? func.length : n;
    return createWrap(func, WRAP_ARY_FLAG$1, void 0, void 0, void 0, void 0, n);
  }

  function baseAssignValue(object, key, value) {
    if (key == "__proto__" && defineProperty) {
      defineProperty(object, key, {
        "configurable": true,
        "enumerable": true,
        "value": value,
        "writable": true
      });
    } else {
      object[key] = value;
    }
  }

  function eq(value, other) {
    return value === other || value !== value && other !== other;
  }

  var objectProto$n = Object.prototype;
  var hasOwnProperty$k = objectProto$n.hasOwnProperty;
  function assignValue(object, key, value) {
    var objValue = object[key];
    if (!(hasOwnProperty$k.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
      baseAssignValue(object, key, value);
    }
  }

  function copyObject(source, props, object, customizer) {
    var isNew = !object;
    object || (object = {});
    var index = -1, length = props.length;
    while (++index < length) {
      var key = props[index];
      var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
      if (newValue === void 0) {
        newValue = source[key];
      }
      if (isNew) {
        baseAssignValue(object, key, newValue);
      } else {
        assignValue(object, key, newValue);
      }
    }
    return object;
  }

  var nativeMax$d = Math.max;
  function overRest(func, start, transform) {
    start = nativeMax$d(start === void 0 ? func.length - 1 : start, 0);
    return function() {
      var args = arguments, index = -1, length = nativeMax$d(args.length - start, 0), array = Array(length);
      while (++index < length) {
        array[index] = args[start + index];
      }
      index = -1;
      var otherArgs = Array(start + 1);
      while (++index < start) {
        otherArgs[index] = args[index];
      }
      otherArgs[start] = transform(array);
      return apply(func, this, otherArgs);
    };
  }

  function baseRest(func, start) {
    return setToString(overRest(func, start, identity), func + "");
  }

  var MAX_SAFE_INTEGER$4 = 9007199254740991;
  function isLength(value) {
    return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$4;
  }

  function isArrayLike(value) {
    return value != null && isLength(value.length) && !isFunction(value);
  }

  function isIterateeCall(value, index, object) {
    if (!isObject(object)) {
      return false;
    }
    var type = typeof index;
    if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
      return eq(object[index], value);
    }
    return false;
  }

  function createAssigner(assigner) {
    return baseRest(function(object, sources) {
      var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
      customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
        customizer = length < 3 ? void 0 : customizer;
        length = 1;
      }
      object = Object(object);
      while (++index < length) {
        var source = sources[index];
        if (source) {
          assigner(object, source, index, customizer);
        }
      }
      return object;
    });
  }

  var objectProto$m = Object.prototype;
  function isPrototype(value) {
    var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$m;
    return value === proto;
  }

  function baseTimes(n, iteratee) {
    var index = -1, result = Array(n);
    while (++index < n) {
      result[index] = iteratee(index);
    }
    return result;
  }

  var argsTag$3 = "[object Arguments]";
  function baseIsArguments(value) {
    return isObjectLike(value) && baseGetTag(value) == argsTag$3;
  }

  var objectProto$l = Object.prototype;
  var hasOwnProperty$j = objectProto$l.hasOwnProperty;
  var propertyIsEnumerable$1 = objectProto$l.propertyIsEnumerable;
  var isArguments = baseIsArguments(function() {
    return arguments;
  }()) ? baseIsArguments : function(value) {
    return isObjectLike(value) && hasOwnProperty$j.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
  };

  function stubFalse() {
    return false;
  }

  var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
  var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
  var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
  var Buffer$1 = moduleExports$2 ? root.Buffer : void 0;
  var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
  var isBuffer = nativeIsBuffer || stubFalse;

  var argsTag$2 = "[object Arguments]";
  var arrayTag$2 = "[object Array]";
  var boolTag$4 = "[object Boolean]";
  var dateTag$4 = "[object Date]";
  var errorTag$3 = "[object Error]";
  var funcTag$1 = "[object Function]";
  var mapTag$9 = "[object Map]";
  var numberTag$4 = "[object Number]";
  var objectTag$4 = "[object Object]";
  var regexpTag$4 = "[object RegExp]";
  var setTag$9 = "[object Set]";
  var stringTag$4 = "[object String]";
  var weakMapTag$3 = "[object WeakMap]";
  var arrayBufferTag$4 = "[object ArrayBuffer]";
  var dataViewTag$4 = "[object DataView]";
  var float32Tag$2 = "[object Float32Array]";
  var float64Tag$2 = "[object Float64Array]";
  var int8Tag$2 = "[object Int8Array]";
  var int16Tag$2 = "[object Int16Array]";
  var int32Tag$2 = "[object Int32Array]";
  var uint8Tag$2 = "[object Uint8Array]";
  var uint8ClampedTag$2 = "[object Uint8ClampedArray]";
  var uint16Tag$2 = "[object Uint16Array]";
  var uint32Tag$2 = "[object Uint32Array]";
  var typedArrayTags = {};
  typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
  typedArrayTags[argsTag$2] = typedArrayTags[arrayTag$2] = typedArrayTags[arrayBufferTag$4] = typedArrayTags[boolTag$4] = typedArrayTags[dataViewTag$4] = typedArrayTags[dateTag$4] = typedArrayTags[errorTag$3] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$9] = typedArrayTags[numberTag$4] = typedArrayTags[objectTag$4] = typedArrayTags[regexpTag$4] = typedArrayTags[setTag$9] = typedArrayTags[stringTag$4] = typedArrayTags[weakMapTag$3] = false;
  function baseIsTypedArray(value) {
    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
  }

  function baseUnary(func) {
    return function(value) {
      return func(value);
    };
  }

  var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
  var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
  var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
  var freeProcess = moduleExports$1 && freeGlobal.process;
  var nodeUtil = function() {
    try {
      var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
      if (types) {
        return types;
      }
      return freeProcess && freeProcess.binding && freeProcess.binding("util");
    } catch (e) {
    }
  }();

  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

  var objectProto$k = Object.prototype;
  var hasOwnProperty$i = objectProto$k.hasOwnProperty;
  function arrayLikeKeys(value, inherited) {
    var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
    for (var key in value) {
      if ((inherited || hasOwnProperty$i.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
        result.push(key);
      }
    }
    return result;
  }

  function overArg(func, transform) {
    return function(arg) {
      return func(transform(arg));
    };
  }

  var nativeKeys = overArg(Object.keys, Object);

  var objectProto$j = Object.prototype;
  var hasOwnProperty$h = objectProto$j.hasOwnProperty;
  function baseKeys(object) {
    if (!isPrototype(object)) {
      return nativeKeys(object);
    }
    var result = [];
    for (var key in Object(object)) {
      if (hasOwnProperty$h.call(object, key) && key != "constructor") {
        result.push(key);
      }
    }
    return result;
  }

  function keys(object) {
    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
  }

  var objectProto$i = Object.prototype;
  var hasOwnProperty$g = objectProto$i.hasOwnProperty;
  var assign = createAssigner(function(object, source) {
    if (isPrototype(source) || isArrayLike(source)) {
      copyObject(source, keys(source), object);
      return;
    }
    for (var key in source) {
      if (hasOwnProperty$g.call(source, key)) {
        assignValue(object, key, source[key]);
      }
    }
  });

  function nativeKeysIn(object) {
    var result = [];
    if (object != null) {
      for (var key in Object(object)) {
        result.push(key);
      }
    }
    return result;
  }

  var objectProto$h = Object.prototype;
  var hasOwnProperty$f = objectProto$h.hasOwnProperty;
  function baseKeysIn(object) {
    if (!isObject(object)) {
      return nativeKeysIn(object);
    }
    var isProto = isPrototype(object), result = [];
    for (var key in object) {
      if (!(key == "constructor" && (isProto || !hasOwnProperty$f.call(object, key)))) {
        result.push(key);
      }
    }
    return result;
  }

  function keysIn(object) {
    return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
  }

  var assignIn = createAssigner(function(object, source) {
    copyObject(source, keysIn(source), object);
  });

  var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
    copyObject(source, keysIn(source), object, customizer);
  });

  var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
    copyObject(source, keys(source), object, customizer);
  });

  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
  var reIsPlainProp = /^\w*$/;
  function isKey(value, object) {
    if (isArray(value)) {
      return false;
    }
    var type = typeof value;
    if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
      return true;
    }
    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
  }

  var nativeCreate = getNative(Object, "create");

  function hashClear() {
    this.__data__ = nativeCreate ? nativeCreate(null) : {};
    this.size = 0;
  }

  function hashDelete(key) {
    var result = this.has(key) && delete this.__data__[key];
    this.size -= result ? 1 : 0;
    return result;
  }

  var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
  var objectProto$g = Object.prototype;
  var hasOwnProperty$e = objectProto$g.hasOwnProperty;
  function hashGet(key) {
    var data = this.__data__;
    if (nativeCreate) {
      var result = data[key];
      return result === HASH_UNDEFINED$2 ? void 0 : result;
    }
    return hasOwnProperty$e.call(data, key) ? data[key] : void 0;
  }

  var objectProto$f = Object.prototype;
  var hasOwnProperty$d = objectProto$f.hasOwnProperty;
  function hashHas(key) {
    var data = this.__data__;
    return nativeCreate ? data[key] !== void 0 : hasOwnProperty$d.call(data, key);
  }

  var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
  function hashSet(key, value) {
    var data = this.__data__;
    this.size += this.has(key) ? 0 : 1;
    data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
    return this;
  }

  function Hash(entries) {
    var index = -1, length = entries == null ? 0 : entries.length;
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  Hash.prototype.clear = hashClear;
  Hash.prototype["delete"] = hashDelete;
  Hash.prototype.get = hashGet;
  Hash.prototype.has = hashHas;
  Hash.prototype.set = hashSet;

  function listCacheClear() {
    this.__data__ = [];
    this.size = 0;
  }

  function assocIndexOf(array, key) {
    var length = array.length;
    while (length--) {
      if (eq(array[length][0], key)) {
        return length;
      }
    }
    return -1;
  }

  var arrayProto$5 = Array.prototype;
  var splice$2 = arrayProto$5.splice;
  function listCacheDelete(key) {
    var data = this.__data__, index = assocIndexOf(data, key);
    if (index < 0) {
      return false;
    }
    var lastIndex = data.length - 1;
    if (index == lastIndex) {
      data.pop();
    } else {
      splice$2.call(data, index, 1);
    }
    --this.size;
    return true;
  }

  function listCacheGet(key) {
    var data = this.__data__, index = assocIndexOf(data, key);
    return index < 0 ? void 0 : data[index][1];
  }

  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }

  function listCacheSet(key, value) {
    var data = this.__data__, index = assocIndexOf(data, key);
    if (index < 0) {
      ++this.size;
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }
    return this;
  }

  function ListCache(entries) {
    var index = -1, length = entries == null ? 0 : entries.length;
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  ListCache.prototype.clear = listCacheClear;
  ListCache.prototype["delete"] = listCacheDelete;
  ListCache.prototype.get = listCacheGet;
  ListCache.prototype.has = listCacheHas;
  ListCache.prototype.set = listCacheSet;

  var Map$1 = getNative(root, "Map");

  function mapCacheClear() {
    this.size = 0;
    this.__data__ = {
      "hash": new Hash(),
      "map": new (Map$1 || ListCache)(),
      "string": new Hash()
    };
  }

  function isKeyable(value) {
    var type = typeof value;
    return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
  }

  function getMapData(map, key) {
    var data = map.__data__;
    return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
  }

  function mapCacheDelete(key) {
    var result = getMapData(this, key)["delete"](key);
    this.size -= result ? 1 : 0;
    return result;
  }

  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }

  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }

  function mapCacheSet(key, value) {
    var data = getMapData(this, key), size = data.size;
    data.set(key, value);
    this.size += data.size == size ? 0 : 1;
    return this;
  }

  function MapCache(entries) {
    var index = -1, length = entries == null ? 0 : entries.length;
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  MapCache.prototype.clear = mapCacheClear;
  MapCache.prototype["delete"] = mapCacheDelete;
  MapCache.prototype.get = mapCacheGet;
  MapCache.prototype.has = mapCacheHas;
  MapCache.prototype.set = mapCacheSet;

  var FUNC_ERROR_TEXT$9 = "Expected a function";
  function memoize(func, resolver) {
    if (typeof func != "function" || resolver != null && typeof resolver != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$9);
    }
    var memoized = function() {
      var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
      if (cache.has(key)) {
        return cache.get(key);
      }
      var result = func.apply(this, args);
      memoized.cache = cache.set(key, result) || cache;
      return result;
    };
    memoized.cache = new (memoize.Cache || MapCache)();
    return memoized;
  }
  memoize.Cache = MapCache;

  var MAX_MEMOIZE_SIZE = 500;
  function memoizeCapped(func) {
    var result = memoize(func, function(key) {
      if (cache.size === MAX_MEMOIZE_SIZE) {
        cache.clear();
      }
      return key;
    });
    var cache = result.cache;
    return result;
  }

  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
  var reEscapeChar = /\\(\\)?/g;
  var stringToPath = memoizeCapped(function(string) {
    var result = [];
    if (string.charCodeAt(0) === 46) {
      result.push("");
    }
    string.replace(rePropName, function(match, number, quote, subString) {
      result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
    });
    return result;
  });

  function toString(value) {
    return value == null ? "" : baseToString(value);
  }

  function castPath(value, object) {
    if (isArray(value)) {
      return value;
    }
    return isKey(value, object) ? [value] : stringToPath(toString(value));
  }

  var INFINITY$3 = 1 / 0;
  function toKey(value) {
    if (typeof value == "string" || isSymbol(value)) {
      return value;
    }
    var result = value + "";
    return result == "0" && 1 / value == -INFINITY$3 ? "-0" : result;
  }

  function baseGet(object, path) {
    path = castPath(path, object);
    var index = 0, length = path.length;
    while (object != null && index < length) {
      object = object[toKey(path[index++])];
    }
    return index && index == length ? object : void 0;
  }

  function get(object, path, defaultValue) {
    var result = object == null ? void 0 : baseGet(object, path);
    return result === void 0 ? defaultValue : result;
  }

  function baseAt(object, paths) {
    var index = -1, length = paths.length, result = Array(length), skip = object == null;
    while (++index < length) {
      result[index] = skip ? void 0 : get(object, paths[index]);
    }
    return result;
  }

  function arrayPush(array, values) {
    var index = -1, length = values.length, offset = array.length;
    while (++index < length) {
      array[offset + index] = values[index];
    }
    return array;
  }

  var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
  function isFlattenable(value) {
    return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
  }

  function baseFlatten(array, depth, predicate, isStrict, result) {
    var index = -1, length = array.length;
    predicate || (predicate = isFlattenable);
    result || (result = []);
    while (++index < length) {
      var value = array[index];
      if (depth > 0 && predicate(value)) {
        if (depth > 1) {
          baseFlatten(value, depth - 1, predicate, isStrict, result);
        } else {
          arrayPush(result, value);
        }
      } else if (!isStrict) {
        result[result.length] = value;
      }
    }
    return result;
  }

  function flatten(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseFlatten(array, 1) : [];
  }

  function flatRest(func) {
    return setToString(overRest(func, void 0, flatten), func + "");
  }

  var at$1 = flatRest(baseAt);

  var getPrototype = overArg(Object.getPrototypeOf, Object);

  var objectTag$3 = "[object Object]";
  var funcProto = Function.prototype;
  var objectProto$e = Object.prototype;
  var funcToString = funcProto.toString;
  var hasOwnProperty$c = objectProto$e.hasOwnProperty;
  var objectCtorString = funcToString.call(Object);
  function isPlainObject(value) {
    if (!isObjectLike(value) || baseGetTag(value) != objectTag$3) {
      return false;
    }
    var proto = getPrototype(value);
    if (proto === null) {
      return true;
    }
    var Ctor = hasOwnProperty$c.call(proto, "constructor") && proto.constructor;
    return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
  }

  var domExcTag = "[object DOMException]";
  var errorTag$2 = "[object Error]";
  function isError(value) {
    if (!isObjectLike(value)) {
      return false;
    }
    var tag = baseGetTag(value);
    return tag == errorTag$2 || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value);
  }

  var attempt = baseRest(function(func, args) {
    try {
      return apply(func, void 0, args);
    } catch (e) {
      return isError(e) ? e : new Error(e);
    }
  });

  var FUNC_ERROR_TEXT$8 = "Expected a function";
  function before(n, func) {
    var result;
    if (typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$8);
    }
    n = toInteger(n);
    return function() {
      if (--n > 0) {
        result = func.apply(this, arguments);
      }
      if (n <= 1) {
        func = void 0;
      }
      return result;
    };
  }

  var WRAP_BIND_FLAG$1 = 1;
  var WRAP_PARTIAL_FLAG$3 = 32;
  var bind = baseRest(function(func, thisArg, partials) {
    var bitmask = WRAP_BIND_FLAG$1;
    if (partials.length) {
      var holders = replaceHolders(partials, getHolder(bind));
      bitmask |= WRAP_PARTIAL_FLAG$3;
    }
    return createWrap(func, bitmask, thisArg, partials, holders);
  });
  bind.placeholder = {};

  var bindAll = flatRest(function(object, methodNames) {
    arrayEach(methodNames, function(key) {
      key = toKey(key);
      baseAssignValue(object, key, bind(object[key], object));
    });
    return object;
  });

  var WRAP_BIND_FLAG = 1;
  var WRAP_BIND_KEY_FLAG$1 = 2;
  var WRAP_PARTIAL_FLAG$2 = 32;
  var bindKey = baseRest(function(object, key, partials) {
    var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG$1;
    if (partials.length) {
      var holders = replaceHolders(partials, getHolder(bindKey));
      bitmask |= WRAP_PARTIAL_FLAG$2;
    }
    return createWrap(key, bitmask, object, partials, holders);
  });
  bindKey.placeholder = {};

  function baseSlice(array, start, end) {
    var index = -1, length = array.length;
    if (start < 0) {
      start = -start > length ? 0 : length + start;
    }
    end = end > length ? length : end;
    if (end < 0) {
      end += length;
    }
    length = start > end ? 0 : end - start >>> 0;
    start >>>= 0;
    var result = Array(length);
    while (++index < length) {
      result[index] = array[index + start];
    }
    return result;
  }

  function castSlice(array, start, end) {
    var length = array.length;
    end = end === void 0 ? length : end;
    return !start && end >= length ? array : baseSlice(array, start, end);
  }

  var rsAstralRange$3 = "\\ud800-\\udfff";
  var rsComboMarksRange$4 = "\\u0300-\\u036f";
  var reComboHalfMarksRange$4 = "\\ufe20-\\ufe2f";
  var rsComboSymbolsRange$4 = "\\u20d0-\\u20ff";
  var rsComboRange$4 = rsComboMarksRange$4 + reComboHalfMarksRange$4 + rsComboSymbolsRange$4;
  var rsVarRange$3 = "\\ufe0e\\ufe0f";
  var rsZWJ$3 = "\\u200d";
  var reHasUnicode = RegExp("[" + rsZWJ$3 + rsAstralRange$3 + rsComboRange$4 + rsVarRange$3 + "]");
  function hasUnicode(string) {
    return reHasUnicode.test(string);
  }

  function asciiToArray(string) {
    return string.split("");
  }

  var rsAstralRange$2 = "\\ud800-\\udfff";
  var rsComboMarksRange$3 = "\\u0300-\\u036f";
  var reComboHalfMarksRange$3 = "\\ufe20-\\ufe2f";
  var rsComboSymbolsRange$3 = "\\u20d0-\\u20ff";
  var rsComboRange$3 = rsComboMarksRange$3 + reComboHalfMarksRange$3 + rsComboSymbolsRange$3;
  var rsVarRange$2 = "\\ufe0e\\ufe0f";
  var rsAstral$1 = "[" + rsAstralRange$2 + "]";
  var rsCombo$3 = "[" + rsComboRange$3 + "]";
  var rsFitz$2 = "\\ud83c[\\udffb-\\udfff]";
  var rsModifier$2 = "(?:" + rsCombo$3 + "|" + rsFitz$2 + ")";
  var rsNonAstral$2 = "[^" + rsAstralRange$2 + "]";
  var rsRegional$2 = "(?:\\ud83c[\\udde6-\\uddff]){2}";
  var rsSurrPair$2 = "[\\ud800-\\udbff][\\udc00-\\udfff]";
  var rsZWJ$2 = "\\u200d";
  var reOptMod$2 = rsModifier$2 + "?";
  var rsOptVar$2 = "[" + rsVarRange$2 + "]?";
  var rsOptJoin$2 = "(?:" + rsZWJ$2 + "(?:" + [rsNonAstral$2, rsRegional$2, rsSurrPair$2].join("|") + ")" + rsOptVar$2 + reOptMod$2 + ")*";
  var rsSeq$2 = rsOptVar$2 + reOptMod$2 + rsOptJoin$2;
  var rsSymbol$1 = "(?:" + [rsNonAstral$2 + rsCombo$3 + "?", rsCombo$3, rsRegional$2, rsSurrPair$2, rsAstral$1].join("|") + ")";
  var reUnicode$1 = RegExp(rsFitz$2 + "(?=" + rsFitz$2 + ")|" + rsSymbol$1 + rsSeq$2, "g");
  function unicodeToArray(string) {
    return string.match(reUnicode$1) || [];
  }

  function stringToArray(string) {
    return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
  }

  function createCaseFirst(methodName) {
    return function(string) {
      string = toString(string);
      var strSymbols = hasUnicode(string) ? stringToArray(string) : void 0;
      var chr = strSymbols ? strSymbols[0] : string.charAt(0);
      var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
      return chr[methodName]() + trailing;
    };
  }

  var upperFirst = createCaseFirst("toUpperCase");

  function capitalize$1(string) {
    return upperFirst(toString(string).toLowerCase());
  }

  function arrayReduce(array, iteratee, accumulator, initAccum) {
    var index = -1, length = array == null ? 0 : array.length;
    if (initAccum && length) {
      accumulator = array[++index];
    }
    while (++index < length) {
      accumulator = iteratee(accumulator, array[index], index, array);
    }
    return accumulator;
  }

  function basePropertyOf(object) {
    return function(key) {
      return object == null ? void 0 : object[key];
    };
  }

  var deburredLetters = {
    "\xC0": "A",
    "\xC1": "A",
    "\xC2": "A",
    "\xC3": "A",
    "\xC4": "A",
    "\xC5": "A",
    "\xE0": "a",
    "\xE1": "a",
    "\xE2": "a",
    "\xE3": "a",
    "\xE4": "a",
    "\xE5": "a",
    "\xC7": "C",
    "\xE7": "c",
    "\xD0": "D",
    "\xF0": "d",
    "\xC8": "E",
    "\xC9": "E",
    "\xCA": "E",
    "\xCB": "E",
    "\xE8": "e",
    "\xE9": "e",
    "\xEA": "e",
    "\xEB": "e",
    "\xCC": "I",
    "\xCD": "I",
    "\xCE": "I",
    "\xCF": "I",
    "\xEC": "i",
    "\xED": "i",
    "\xEE": "i",
    "\xEF": "i",
    "\xD1": "N",
    "\xF1": "n",
    "\xD2": "O",
    "\xD3": "O",
    "\xD4": "O",
    "\xD5": "O",
    "\xD6": "O",
    "\xD8": "O",
    "\xF2": "o",
    "\xF3": "o",
    "\xF4": "o",
    "\xF5": "o",
    "\xF6": "o",
    "\xF8": "o",
    "\xD9": "U",
    "\xDA": "U",
    "\xDB": "U",
    "\xDC": "U",
    "\xF9": "u",
    "\xFA": "u",
    "\xFB": "u",
    "\xFC": "u",
    "\xDD": "Y",
    "\xFD": "y",
    "\xFF": "y",
    "\xC6": "Ae",
    "\xE6": "ae",
    "\xDE": "Th",
    "\xFE": "th",
    "\xDF": "ss",
    "\u0100": "A",
    "\u0102": "A",
    "\u0104": "A",
    "\u0101": "a",
    "\u0103": "a",
    "\u0105": "a",
    "\u0106": "C",
    "\u0108": "C",
    "\u010A": "C",
    "\u010C": "C",
    "\u0107": "c",
    "\u0109": "c",
    "\u010B": "c",
    "\u010D": "c",
    "\u010E": "D",
    "\u0110": "D",
    "\u010F": "d",
    "\u0111": "d",
    "\u0112": "E",
    "\u0114": "E",
    "\u0116": "E",
    "\u0118": "E",
    "\u011A": "E",
    "\u0113": "e",
    "\u0115": "e",
    "\u0117": "e",
    "\u0119": "e",
    "\u011B": "e",
    "\u011C": "G",
    "\u011E": "G",
    "\u0120": "G",
    "\u0122": "G",
    "\u011D": "g",
    "\u011F": "g",
    "\u0121": "g",
    "\u0123": "g",
    "\u0124": "H",
    "\u0126": "H",
    "\u0125": "h",
    "\u0127": "h",
    "\u0128": "I",
    "\u012A": "I",
    "\u012C": "I",
    "\u012E": "I",
    "\u0130": "I",
    "\u0129": "i",
    "\u012B": "i",
    "\u012D": "i",
    "\u012F": "i",
    "\u0131": "i",
    "\u0134": "J",
    "\u0135": "j",
    "\u0136": "K",
    "\u0137": "k",
    "\u0138": "k",
    "\u0139": "L",
    "\u013B": "L",
    "\u013D": "L",
    "\u013F": "L",
    "\u0141": "L",
    "\u013A": "l",
    "\u013C": "l",
    "\u013E": "l",
    "\u0140": "l",
    "\u0142": "l",
    "\u0143": "N",
    "\u0145": "N",
    "\u0147": "N",
    "\u014A": "N",
    "\u0144": "n",
    "\u0146": "n",
    "\u0148": "n",
    "\u014B": "n",
    "\u014C": "O",
    "\u014E": "O",
    "\u0150": "O",
    "\u014D": "o",
    "\u014F": "o",
    "\u0151": "o",
    "\u0154": "R",
    "\u0156": "R",
    "\u0158": "R",
    "\u0155": "r",
    "\u0157": "r",
    "\u0159": "r",
    "\u015A": "S",
    "\u015C": "S",
    "\u015E": "S",
    "\u0160": "S",
    "\u015B": "s",
    "\u015D": "s",
    "\u015F": "s",
    "\u0161": "s",
    "\u0162": "T",
    "\u0164": "T",
    "\u0166": "T",
    "\u0163": "t",
    "\u0165": "t",
    "\u0167": "t",
    "\u0168": "U",
    "\u016A": "U",
    "\u016C": "U",
    "\u016E": "U",
    "\u0170": "U",
    "\u0172": "U",
    "\u0169": "u",
    "\u016B": "u",
    "\u016D": "u",
    "\u016F": "u",
    "\u0171": "u",
    "\u0173": "u",
    "\u0174": "W",
    "\u0175": "w",
    "\u0176": "Y",
    "\u0177": "y",
    "\u0178": "Y",
    "\u0179": "Z",
    "\u017B": "Z",
    "\u017D": "Z",
    "\u017A": "z",
    "\u017C": "z",
    "\u017E": "z",
    "\u0132": "IJ",
    "\u0133": "ij",
    "\u0152": "Oe",
    "\u0153": "oe",
    "\u0149": "'n",
    "\u017F": "s"
  };
  var deburrLetter = basePropertyOf(deburredLetters);

  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
  var rsComboMarksRange$2 = "\\u0300-\\u036f";
  var reComboHalfMarksRange$2 = "\\ufe20-\\ufe2f";
  var rsComboSymbolsRange$2 = "\\u20d0-\\u20ff";
  var rsComboRange$2 = rsComboMarksRange$2 + reComboHalfMarksRange$2 + rsComboSymbolsRange$2;
  var rsCombo$2 = "[" + rsComboRange$2 + "]";
  var reComboMark = RegExp(rsCombo$2, "g");
  function deburr(string) {
    string = toString(string);
    return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
  }

  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
  function asciiWords(string) {
    return string.match(reAsciiWord) || [];
  }

  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
  function hasUnicodeWord(string) {
    return reHasUnicodeWord.test(string);
  }

  var rsAstralRange$1 = "\\ud800-\\udfff";
  var rsComboMarksRange$1 = "\\u0300-\\u036f";
  var reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f";
  var rsComboSymbolsRange$1 = "\\u20d0-\\u20ff";
  var rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1;
  var rsDingbatRange = "\\u2700-\\u27bf";
  var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
  var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
  var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
  var rsPunctuationRange = "\\u2000-\\u206f";
  var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
  var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
  var rsVarRange$1 = "\\ufe0e\\ufe0f";
  var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
  var rsApos$1 = "['\u2019]";
  var rsBreak = "[" + rsBreakRange + "]";
  var rsCombo$1 = "[" + rsComboRange$1 + "]";
  var rsDigits = "\\d+";
  var rsDingbat = "[" + rsDingbatRange + "]";
  var rsLower = "[" + rsLowerRange + "]";
  var rsMisc = "[^" + rsAstralRange$1 + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
  var rsFitz$1 = "\\ud83c[\\udffb-\\udfff]";
  var rsModifier$1 = "(?:" + rsCombo$1 + "|" + rsFitz$1 + ")";
  var rsNonAstral$1 = "[^" + rsAstralRange$1 + "]";
  var rsRegional$1 = "(?:\\ud83c[\\udde6-\\uddff]){2}";
  var rsSurrPair$1 = "[\\ud800-\\udbff][\\udc00-\\udfff]";
  var rsUpper = "[" + rsUpperRange + "]";
  var rsZWJ$1 = "\\u200d";
  var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")";
  var rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")";
  var rsOptContrLower = "(?:" + rsApos$1 + "(?:d|ll|m|re|s|t|ve))?";
  var rsOptContrUpper = "(?:" + rsApos$1 + "(?:D|LL|M|RE|S|T|VE))?";
  var reOptMod$1 = rsModifier$1 + "?";
  var rsOptVar$1 = "[" + rsVarRange$1 + "]?";
  var rsOptJoin$1 = "(?:" + rsZWJ$1 + "(?:" + [rsNonAstral$1, rsRegional$1, rsSurrPair$1].join("|") + ")" + rsOptVar$1 + reOptMod$1 + ")*";
  var rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])";
  var rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])";
  var rsSeq$1 = rsOptVar$1 + reOptMod$1 + rsOptJoin$1;
  var rsEmoji = "(?:" + [rsDingbat, rsRegional$1, rsSurrPair$1].join("|") + ")" + rsSeq$1;
  var reUnicodeWord = RegExp([
    rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
    rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
    rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
    rsUpper + "+" + rsOptContrUpper,
    rsOrdUpper,
    rsOrdLower,
    rsDigits,
    rsEmoji
  ].join("|"), "g");
  function unicodeWords(string) {
    return string.match(reUnicodeWord) || [];
  }

  function words(string, pattern, guard) {
    string = toString(string);
    pattern = guard ? void 0 : pattern;
    if (pattern === void 0) {
      return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
    }
    return string.match(pattern) || [];
  }

  var rsApos = "['\u2019]";
  var reApos = RegExp(rsApos, "g");
  function createCompounder(callback) {
    return function(string) {
      return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
    };
  }

  var camelCase = createCompounder(function(result, word, index) {
    word = word.toLowerCase();
    return result + (index ? capitalize$1(word) : word);
  });

  function castArray$1() {
    if (!arguments.length) {
      return [];
    }
    var value = arguments[0];
    return isArray(value) ? value : [value];
  }

  var nativeIsFinite$1 = root.isFinite;
  var nativeMin$c = Math.min;
  function createRound(methodName) {
    var func = Math[methodName];
    return function(number, precision) {
      number = toNumber(number);
      precision = precision == null ? 0 : nativeMin$c(toInteger(precision), 292);
      if (precision && nativeIsFinite$1(number)) {
        var pair = (toString(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
        pair = (toString(value) + "e").split("e");
        return +(pair[0] + "e" + (+pair[1] - precision));
      }
      return func(number);
    };
  }

  var ceil = createRound("ceil");

  function chain(value) {
    var result = lodash(value);
    result.__chain__ = true;
    return result;
  }

  var nativeCeil$3 = Math.ceil;
  var nativeMax$c = Math.max;
  function chunk(array, size, guard) {
    if (guard ? isIterateeCall(array, size, guard) : size === void 0) {
      size = 1;
    } else {
      size = nativeMax$c(toInteger(size), 0);
    }
    var length = array == null ? 0 : array.length;
    if (!length || size < 1) {
      return [];
    }
    var index = 0, resIndex = 0, result = Array(nativeCeil$3(length / size));
    while (index < length) {
      result[resIndex++] = baseSlice(array, index, index += size);
    }
    return result;
  }

  function baseClamp(number, lower, upper) {
    if (number === number) {
      if (upper !== void 0) {
        number = number <= upper ? number : upper;
      }
      if (lower !== void 0) {
        number = number >= lower ? number : lower;
      }
    }
    return number;
  }

  function clamp$1(number, lower, upper) {
    if (upper === void 0) {
      upper = lower;
      lower = void 0;
    }
    if (upper !== void 0) {
      upper = toNumber(upper);
      upper = upper === upper ? upper : 0;
    }
    if (lower !== void 0) {
      lower = toNumber(lower);
      lower = lower === lower ? lower : 0;
    }
    return baseClamp(toNumber(number), lower, upper);
  }

  function stackClear() {
    this.__data__ = new ListCache();
    this.size = 0;
  }

  function stackDelete(key) {
    var data = this.__data__, result = data["delete"](key);
    this.size = data.size;
    return result;
  }

  function stackGet(key) {
    return this.__data__.get(key);
  }

  function stackHas(key) {
    return this.__data__.has(key);
  }

  var LARGE_ARRAY_SIZE$2 = 200;
  function stackSet(key, value) {
    var data = this.__data__;
    if (data instanceof ListCache) {
      var pairs = data.__data__;
      if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE$2 - 1) {
        pairs.push([key, value]);
        this.size = ++data.size;
        return this;
      }
      data = this.__data__ = new MapCache(pairs);
    }
    data.set(key, value);
    this.size = data.size;
    return this;
  }

  function Stack(entries) {
    var data = this.__data__ = new ListCache(entries);
    this.size = data.size;
  }
  Stack.prototype.clear = stackClear;
  Stack.prototype["delete"] = stackDelete;
  Stack.prototype.get = stackGet;
  Stack.prototype.has = stackHas;
  Stack.prototype.set = stackSet;

  function baseAssign(object, source) {
    return object && copyObject(source, keys(source), object);
  }

  function baseAssignIn(object, source) {
    return object && copyObject(source, keysIn(source), object);
  }

  var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
  var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
  var moduleExports = freeModule && freeModule.exports === freeExports;
  var Buffer = moduleExports ? root.Buffer : void 0;
  var allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
  function cloneBuffer(buffer, isDeep) {
    if (isDeep) {
      return buffer.slice();
    }
    var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
    buffer.copy(result);
    return result;
  }

  function arrayFilter(array, predicate) {
    var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
    while (++index < length) {
      var value = array[index];
      if (predicate(value, index, array)) {
        result[resIndex++] = value;
      }
    }
    return result;
  }

  function stubArray() {
    return [];
  }

  var objectProto$d = Object.prototype;
  var propertyIsEnumerable = objectProto$d.propertyIsEnumerable;
  var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
  var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object) {
    if (object == null) {
      return [];
    }
    object = Object(object);
    return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
      return propertyIsEnumerable.call(object, symbol);
    });
  };

  function copySymbols(source, object) {
    return copyObject(source, getSymbols(source), object);
  }

  var nativeGetSymbols = Object.getOwnPropertySymbols;
  var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
    var result = [];
    while (object) {
      arrayPush(result, getSymbols(object));
      object = getPrototype(object);
    }
    return result;
  };

  function copySymbolsIn(source, object) {
    return copyObject(source, getSymbolsIn(source), object);
  }

  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
    var result = keysFunc(object);
    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
  }

  function getAllKeys(object) {
    return baseGetAllKeys(object, keys, getSymbols);
  }

  function getAllKeysIn(object) {
    return baseGetAllKeys(object, keysIn, getSymbolsIn);
  }

  var DataView = getNative(root, "DataView");

  var Promise$1 = getNative(root, "Promise");

  var Set$1 = getNative(root, "Set");

  var mapTag$8 = "[object Map]";
  var objectTag$2 = "[object Object]";
  var promiseTag = "[object Promise]";
  var setTag$8 = "[object Set]";
  var weakMapTag$2 = "[object WeakMap]";
  var dataViewTag$3 = "[object DataView]";
  var dataViewCtorString = toSource(DataView);
  var mapCtorString = toSource(Map$1);
  var promiseCtorString = toSource(Promise$1);
  var setCtorString = toSource(Set$1);
  var weakMapCtorString = toSource(WeakMap$1);
  var getTag = baseGetTag;
  if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$3 || Map$1 && getTag(new Map$1()) != mapTag$8 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$8 || WeakMap$1 && getTag(new WeakMap$1()) != weakMapTag$2) {
    getTag = function(value) {
      var result = baseGetTag(value), Ctor = result == objectTag$2 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
      if (ctorString) {
        switch (ctorString) {
          case dataViewCtorString:
            return dataViewTag$3;
          case mapCtorString:
            return mapTag$8;
          case promiseCtorString:
            return promiseTag;
          case setCtorString:
            return setTag$8;
          case weakMapCtorString:
            return weakMapTag$2;
        }
      }
      return result;
    };
  }
  var getTag$1 = getTag;

  var objectProto$c = Object.prototype;
  var hasOwnProperty$b = objectProto$c.hasOwnProperty;
  function initCloneArray(array) {
    var length = array.length, result = new array.constructor(length);
    if (length && typeof array[0] == "string" && hasOwnProperty$b.call(array, "index")) {
      result.index = array.index;
      result.input = array.input;
    }
    return result;
  }

  var Uint8Array = root.Uint8Array;

  function cloneArrayBuffer(arrayBuffer) {
    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
    return result;
  }

  function cloneDataView(dataView, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
  }

  var reFlags$1 = /\w*$/;
  function cloneRegExp(regexp) {
    var result = new regexp.constructor(regexp.source, reFlags$1.exec(regexp));
    result.lastIndex = regexp.lastIndex;
    return result;
  }

  var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0;
  var symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : void 0;
  function cloneSymbol(symbol) {
    return symbolValueOf$1 ? Object(symbolValueOf$1.call(symbol)) : {};
  }

  function cloneTypedArray(typedArray, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
  }

  var boolTag$3 = "[object Boolean]";
  var dateTag$3 = "[object Date]";
  var mapTag$7 = "[object Map]";
  var numberTag$3 = "[object Number]";
  var regexpTag$3 = "[object RegExp]";
  var setTag$7 = "[object Set]";
  var stringTag$3 = "[object String]";
  var symbolTag$2 = "[object Symbol]";
  var arrayBufferTag$3 = "[object ArrayBuffer]";
  var dataViewTag$2 = "[object DataView]";
  var float32Tag$1 = "[object Float32Array]";
  var float64Tag$1 = "[object Float64Array]";
  var int8Tag$1 = "[object Int8Array]";
  var int16Tag$1 = "[object Int16Array]";
  var int32Tag$1 = "[object Int32Array]";
  var uint8Tag$1 = "[object Uint8Array]";
  var uint8ClampedTag$1 = "[object Uint8ClampedArray]";
  var uint16Tag$1 = "[object Uint16Array]";
  var uint32Tag$1 = "[object Uint32Array]";
  function initCloneByTag(object, tag, isDeep) {
    var Ctor = object.constructor;
    switch (tag) {
      case arrayBufferTag$3:
        return cloneArrayBuffer(object);
      case boolTag$3:
      case dateTag$3:
        return new Ctor(+object);
      case dataViewTag$2:
        return cloneDataView(object, isDeep);
      case float32Tag$1:
      case float64Tag$1:
      case int8Tag$1:
      case int16Tag$1:
      case int32Tag$1:
      case uint8Tag$1:
      case uint8ClampedTag$1:
      case uint16Tag$1:
      case uint32Tag$1:
        return cloneTypedArray(object, isDeep);
      case mapTag$7:
        return new Ctor();
      case numberTag$3:
      case stringTag$3:
        return new Ctor(object);
      case regexpTag$3:
        return cloneRegExp(object);
      case setTag$7:
        return new Ctor();
      case symbolTag$2:
        return cloneSymbol(object);
    }
  }

  function initCloneObject(object) {
    return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
  }

  var mapTag$6 = "[object Map]";
  function baseIsMap(value) {
    return isObjectLike(value) && getTag$1(value) == mapTag$6;
  }

  var nodeIsMap = nodeUtil && nodeUtil.isMap;
  var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

  var setTag$6 = "[object Set]";
  function baseIsSet(value) {
    return isObjectLike(value) && getTag$1(value) == setTag$6;
  }

  var nodeIsSet = nodeUtil && nodeUtil.isSet;
  var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

  var CLONE_DEEP_FLAG$7 = 1;
  var CLONE_FLAT_FLAG$1 = 2;
  var CLONE_SYMBOLS_FLAG$5 = 4;
  var argsTag$1 = "[object Arguments]";
  var arrayTag$1 = "[object Array]";
  var boolTag$2 = "[object Boolean]";
  var dateTag$2 = "[object Date]";
  var errorTag$1 = "[object Error]";
  var funcTag = "[object Function]";
  var genTag = "[object GeneratorFunction]";
  var mapTag$5 = "[object Map]";
  var numberTag$2 = "[object Number]";
  var objectTag$1 = "[object Object]";
  var regexpTag$2 = "[object RegExp]";
  var setTag$5 = "[object Set]";
  var stringTag$2 = "[object String]";
  var symbolTag$1 = "[object Symbol]";
  var weakMapTag$1 = "[object WeakMap]";
  var arrayBufferTag$2 = "[object ArrayBuffer]";
  var dataViewTag$1 = "[object DataView]";
  var float32Tag = "[object Float32Array]";
  var float64Tag = "[object Float64Array]";
  var int8Tag = "[object Int8Array]";
  var int16Tag = "[object Int16Array]";
  var int32Tag = "[object Int32Array]";
  var uint8Tag = "[object Uint8Array]";
  var uint8ClampedTag = "[object Uint8ClampedArray]";
  var uint16Tag = "[object Uint16Array]";
  var uint32Tag = "[object Uint32Array]";
  var cloneableTags = {};
  cloneableTags[argsTag$1] = cloneableTags[arrayTag$1] = cloneableTags[arrayBufferTag$2] = cloneableTags[dataViewTag$1] = cloneableTags[boolTag$2] = cloneableTags[dateTag$2] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$5] = cloneableTags[numberTag$2] = cloneableTags[objectTag$1] = cloneableTags[regexpTag$2] = cloneableTags[setTag$5] = cloneableTags[stringTag$2] = cloneableTags[symbolTag$1] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
  cloneableTags[errorTag$1] = cloneableTags[funcTag] = cloneableTags[weakMapTag$1] = false;
  function baseClone(value, bitmask, customizer, key, object, stack) {
    var result, isDeep = bitmask & CLONE_DEEP_FLAG$7, isFlat = bitmask & CLONE_FLAT_FLAG$1, isFull = bitmask & CLONE_SYMBOLS_FLAG$5;
    if (customizer) {
      result = object ? customizer(value, key, object, stack) : customizer(value);
    }
    if (result !== void 0) {
      return result;
    }
    if (!isObject(value)) {
      return value;
    }
    var isArr = isArray(value);
    if (isArr) {
      result = initCloneArray(value);
      if (!isDeep) {
        return copyArray(value, result);
      }
    } else {
      var tag = getTag$1(value), isFunc = tag == funcTag || tag == genTag;
      if (isBuffer(value)) {
        return cloneBuffer(value, isDeep);
      }
      if (tag == objectTag$1 || tag == argsTag$1 || isFunc && !object) {
        result = isFlat || isFunc ? {} : initCloneObject(value);
        if (!isDeep) {
          return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
        }
      } else {
        if (!cloneableTags[tag]) {
          return object ? value : {};
        }
        result = initCloneByTag(value, tag, isDeep);
      }
    }
    stack || (stack = new Stack());
    var stacked = stack.get(value);
    if (stacked) {
      return stacked;
    }
    stack.set(value, result);
    if (isSet(value)) {
      value.forEach(function(subValue) {
        result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
      });
    } else if (isMap(value)) {
      value.forEach(function(subValue, key2) {
        result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
      });
    }
    var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
    var props = isArr ? void 0 : keysFunc(value);
    arrayEach(props || value, function(subValue, key2) {
      if (props) {
        key2 = subValue;
        subValue = value[key2];
      }
      assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
    });
    return result;
  }

  var CLONE_SYMBOLS_FLAG$4 = 4;
  function clone(value) {
    return baseClone(value, CLONE_SYMBOLS_FLAG$4);
  }

  var CLONE_DEEP_FLAG$6 = 1;
  var CLONE_SYMBOLS_FLAG$3 = 4;
  function cloneDeep(value) {
    return baseClone(value, CLONE_DEEP_FLAG$6 | CLONE_SYMBOLS_FLAG$3);
  }

  var CLONE_DEEP_FLAG$5 = 1;
  var CLONE_SYMBOLS_FLAG$2 = 4;
  function cloneDeepWith(value, customizer) {
    customizer = typeof customizer == "function" ? customizer : void 0;
    return baseClone(value, CLONE_DEEP_FLAG$5 | CLONE_SYMBOLS_FLAG$2, customizer);
  }

  var CLONE_SYMBOLS_FLAG$1 = 4;
  function cloneWith(value, customizer) {
    customizer = typeof customizer == "function" ? customizer : void 0;
    return baseClone(value, CLONE_SYMBOLS_FLAG$1, customizer);
  }

  function wrapperCommit() {
    return new LodashWrapper(this.value(), this.__chain__);
  }

  function compact(array) {
    var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
    while (++index < length) {
      var value = array[index];
      if (value) {
        result[resIndex++] = value;
      }
    }
    return result;
  }

  function concat() {
    var length = arguments.length;
    if (!length) {
      return [];
    }
    var args = Array(length - 1), array = arguments[0], index = length;
    while (index--) {
      args[index - 1] = arguments[index];
    }
    return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
  }

  var HASH_UNDEFINED = "__lodash_hash_undefined__";
  function setCacheAdd(value) {
    this.__data__.set(value, HASH_UNDEFINED);
    return this;
  }

  function setCacheHas(value) {
    return this.__data__.has(value);
  }

  function SetCache(values) {
    var index = -1, length = values == null ? 0 : values.length;
    this.__data__ = new MapCache();
    while (++index < length) {
      this.add(values[index]);
    }
  }
  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
  SetCache.prototype.has = setCacheHas;

  function arraySome(array, predicate) {
    var index = -1, length = array == null ? 0 : array.length;
    while (++index < length) {
      if (predicate(array[index], index, array)) {
        return true;
      }
    }
    return false;
  }

  function cacheHas(cache, key) {
    return cache.has(key);
  }

  var COMPARE_PARTIAL_FLAG$5 = 1;
  var COMPARE_UNORDERED_FLAG$3 = 2;
  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
      return false;
    }
    var arrStacked = stack.get(array);
    var othStacked = stack.get(other);
    if (arrStacked && othStacked) {
      return arrStacked == other && othStacked == array;
    }
    var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
    stack.set(array, other);
    stack.set(other, array);
    while (++index < arrLength) {
      var arrValue = array[index], othValue = other[index];
      if (customizer) {
        var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
      }
      if (compared !== void 0) {
        if (compared) {
          continue;
        }
        result = false;
        break;
      }
      if (seen) {
        if (!arraySome(other, function(othValue2, othIndex) {
          if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
            return seen.push(othIndex);
          }
        })) {
          result = false;
          break;
        }
      } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
        result = false;
        break;
      }
    }
    stack["delete"](array);
    stack["delete"](other);
    return result;
  }

  function mapToArray(map) {
    var index = -1, result = Array(map.size);
    map.forEach(function(value, key) {
      result[++index] = [key, value];
    });
    return result;
  }

  function setToArray(set) {
    var index = -1, result = Array(set.size);
    set.forEach(function(value) {
      result[++index] = value;
    });
    return result;
  }

  var COMPARE_PARTIAL_FLAG$4 = 1;
  var COMPARE_UNORDERED_FLAG$2 = 2;
  var boolTag$1 = "[object Boolean]";
  var dateTag$1 = "[object Date]";
  var errorTag = "[object Error]";
  var mapTag$4 = "[object Map]";
  var numberTag$1 = "[object Number]";
  var regexpTag$1 = "[object RegExp]";
  var setTag$4 = "[object Set]";
  var stringTag$1 = "[object String]";
  var symbolTag = "[object Symbol]";
  var arrayBufferTag$1 = "[object ArrayBuffer]";
  var dataViewTag = "[object DataView]";
  var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0;
  var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
    switch (tag) {
      case dataViewTag:
        if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
          return false;
        }
        object = object.buffer;
        other = other.buffer;
      case arrayBufferTag$1:
        if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
          return false;
        }
        return true;
      case boolTag$1:
      case dateTag$1:
      case numberTag$1:
        return eq(+object, +other);
      case errorTag:
        return object.name == other.name && object.message == other.message;
      case regexpTag$1:
      case stringTag$1:
        return object == other + "";
      case mapTag$4:
        var convert = mapToArray;
      case setTag$4:
        var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
        convert || (convert = setToArray);
        if (object.size != other.size && !isPartial) {
          return false;
        }
        var stacked = stack.get(object);
        if (stacked) {
          return stacked == other;
        }
        bitmask |= COMPARE_UNORDERED_FLAG$2;
        stack.set(object, other);
        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
        stack["delete"](object);
        return result;
      case symbolTag:
        if (symbolValueOf) {
          return symbolValueOf.call(object) == symbolValueOf.call(other);
        }
    }
    return false;
  }

  var COMPARE_PARTIAL_FLAG$3 = 1;
  var objectProto$b = Object.prototype;
  var hasOwnProperty$a = objectProto$b.hasOwnProperty;
  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
    if (objLength != othLength && !isPartial) {
      return false;
    }
    var index = objLength;
    while (index--) {
      var key = objProps[index];
      if (!(isPartial ? key in other : hasOwnProperty$a.call(other, key))) {
        return false;
      }
    }
    var objStacked = stack.get(object);
    var othStacked = stack.get(other);
    if (objStacked && othStacked) {
      return objStacked == other && othStacked == object;
    }
    var result = true;
    stack.set(object, other);
    stack.set(other, object);
    var skipCtor = isPartial;
    while (++index < objLength) {
      key = objProps[index];
      var objValue = object[key], othValue = other[key];
      if (customizer) {
        var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
      }
      if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
        result = false;
        break;
      }
      skipCtor || (skipCtor = key == "constructor");
    }
    if (result && !skipCtor) {
      var objCtor = object.constructor, othCtor = other.constructor;
      if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
        result = false;
      }
    }
    stack["delete"](object);
    stack["delete"](other);
    return result;
  }

  var COMPARE_PARTIAL_FLAG$2 = 1;
  var argsTag = "[object Arguments]";
  var arrayTag = "[object Array]";
  var objectTag = "[object Object]";
  var objectProto$a = Object.prototype;
  var hasOwnProperty$9 = objectProto$a.hasOwnProperty;
  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
    var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag$1(object), othTag = othIsArr ? arrayTag : getTag$1(other);
    objTag = objTag == argsTag ? objectTag : objTag;
    othTag = othTag == argsTag ? objectTag : othTag;
    var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
    if (isSameTag && isBuffer(object)) {
      if (!isBuffer(other)) {
        return false;
      }
      objIsArr = true;
      objIsObj = false;
    }
    if (isSameTag && !objIsObj) {
      stack || (stack = new Stack());
      return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
    }
    if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
      var objIsWrapped = objIsObj && hasOwnProperty$9.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$9.call(other, "__wrapped__");
      if (objIsWrapped || othIsWrapped) {
        var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
        stack || (stack = new Stack());
        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
      }
    }
    if (!isSameTag) {
      return false;
    }
    stack || (stack = new Stack());
    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
  }

  function baseIsEqual(value, other, bitmask, customizer, stack) {
    if (value === other) {
      return true;
    }
    if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
      return value !== value && other !== other;
    }
    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
  }

  var COMPARE_PARTIAL_FLAG$1 = 1;
  var COMPARE_UNORDERED_FLAG$1 = 2;
  function baseIsMatch(object, source, matchData, customizer) {
    var index = matchData.length, length = index, noCustomizer = !customizer;
    if (object == null) {
      return !length;
    }
    object = Object(object);
    while (index--) {
      var data = matchData[index];
      if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
        return false;
      }
    }
    while (++index < length) {
      data = matchData[index];
      var key = data[0], objValue = object[key], srcValue = data[1];
      if (noCustomizer && data[2]) {
        if (objValue === void 0 && !(key in object)) {
          return false;
        }
      } else {
        var stack = new Stack();
        if (customizer) {
          var result = customizer(objValue, srcValue, key, object, source, stack);
        }
        if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
          return false;
        }
      }
    }
    return true;
  }

  function isStrictComparable(value) {
    return value === value && !isObject(value);
  }

  function getMatchData(object) {
    var result = keys(object), length = result.length;
    while (length--) {
      var key = result[length], value = object[key];
      result[length] = [key, value, isStrictComparable(value)];
    }
    return result;
  }

  function matchesStrictComparable(key, srcValue) {
    return function(object) {
      if (object == null) {
        return false;
      }
      return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
    };
  }

  function baseMatches(source) {
    var matchData = getMatchData(source);
    if (matchData.length == 1 && matchData[0][2]) {
      return matchesStrictComparable(matchData[0][0], matchData[0][1]);
    }
    return function(object) {
      return object === source || baseIsMatch(object, source, matchData);
    };
  }

  function baseHasIn(object, key) {
    return object != null && key in Object(object);
  }

  function hasPath(object, path, hasFunc) {
    path = castPath(path, object);
    var index = -1, length = path.length, result = false;
    while (++index < length) {
      var key = toKey(path[index]);
      if (!(result = object != null && hasFunc(object, key))) {
        break;
      }
      object = object[key];
    }
    if (result || ++index != length) {
      return result;
    }
    length = object == null ? 0 : object.length;
    return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
  }

  function hasIn(object, path) {
    return object != null && hasPath(object, path, baseHasIn);
  }

  var COMPARE_PARTIAL_FLAG = 1;
  var COMPARE_UNORDERED_FLAG = 2;
  function baseMatchesProperty(path, srcValue) {
    if (isKey(path) && isStrictComparable(srcValue)) {
      return matchesStrictComparable(toKey(path), srcValue);
    }
    return function(object) {
      var objValue = get(object, path);
      return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
    };
  }

  function baseProperty(key) {
    return function(object) {
      return object == null ? void 0 : object[key];
    };
  }

  function basePropertyDeep(path) {
    return function(object) {
      return baseGet(object, path);
    };
  }

  function property(path) {
    return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
  }

  function baseIteratee(value) {
    if (typeof value == "function") {
      return value;
    }
    if (value == null) {
      return identity;
    }
    if (typeof value == "object") {
      return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
    }
    return property(value);
  }

  var FUNC_ERROR_TEXT$7 = "Expected a function";
  function cond(pairs) {
    var length = pairs == null ? 0 : pairs.length, toIteratee = baseIteratee;
    pairs = !length ? [] : arrayMap(pairs, function(pair) {
      if (typeof pair[1] != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$7);
      }
      return [toIteratee(pair[0]), pair[1]];
    });
    return baseRest(function(args) {
      var index = -1;
      while (++index < length) {
        var pair = pairs[index];
        if (apply(pair[0], this, args)) {
          return apply(pair[1], this, args);
        }
      }
    });
  }

  function baseConformsTo(object, source, props) {
    var length = props.length;
    if (object == null) {
      return !length;
    }
    object = Object(object);
    while (length--) {
      var key = props[length], predicate = source[key], value = object[key];
      if (value === void 0 && !(key in object) || !predicate(value)) {
        return false;
      }
    }
    return true;
  }

  function baseConforms(source) {
    var props = keys(source);
    return function(object) {
      return baseConformsTo(object, source, props);
    };
  }

  var CLONE_DEEP_FLAG$4 = 1;
  function conforms(source) {
    return baseConforms(baseClone(source, CLONE_DEEP_FLAG$4));
  }

  function conformsTo(object, source) {
    return source == null || baseConformsTo(object, source, keys(source));
  }

  function arrayAggregator(array, setter, iteratee, accumulator) {
    var index = -1, length = array == null ? 0 : array.length;
    while (++index < length) {
      var value = array[index];
      setter(accumulator, value, iteratee(value), array);
    }
    return accumulator;
  }

  function createBaseFor(fromRight) {
    return function(object, iteratee, keysFunc) {
      var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
      while (length--) {
        var key = props[fromRight ? length : ++index];
        if (iteratee(iterable[key], key, iterable) === false) {
          break;
        }
      }
      return object;
    };
  }

  var baseFor = createBaseFor();

  function baseForOwn(object, iteratee) {
    return object && baseFor(object, iteratee, keys);
  }

  function createBaseEach(eachFunc, fromRight) {
    return function(collection, iteratee) {
      if (collection == null) {
        return collection;
      }
      if (!isArrayLike(collection)) {
        return eachFunc(collection, iteratee);
      }
      var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
      while (fromRight ? index-- : ++index < length) {
        if (iteratee(iterable[index], index, iterable) === false) {
          break;
        }
      }
      return collection;
    };
  }

  var baseEach = createBaseEach(baseForOwn);

  function baseAggregator(collection, setter, iteratee, accumulator) {
    baseEach(collection, function(value, key, collection2) {
      setter(accumulator, value, iteratee(value), collection2);
    });
    return accumulator;
  }

  function createAggregator(setter, initializer) {
    return function(collection, iteratee) {
      var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
      return func(collection, setter, baseIteratee(iteratee), accumulator);
    };
  }

  var objectProto$9 = Object.prototype;
  var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
  var countBy = createAggregator(function(result, value, key) {
    if (hasOwnProperty$8.call(result, key)) {
      ++result[key];
    } else {
      baseAssignValue(result, key, 1);
    }
  });

  function create(prototype, properties) {
    var result = baseCreate(prototype);
    return properties == null ? result : baseAssign(result, properties);
  }

  var WRAP_CURRY_FLAG$1 = 8;
  function curry(func, arity, guard) {
    arity = guard ? void 0 : arity;
    var result = createWrap(func, WRAP_CURRY_FLAG$1, void 0, void 0, void 0, void 0, void 0, arity);
    result.placeholder = curry.placeholder;
    return result;
  }
  curry.placeholder = {};

  var WRAP_CURRY_RIGHT_FLAG = 16;
  function curryRight(func, arity, guard) {
    arity = guard ? void 0 : arity;
    var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, void 0, void 0, void 0, void 0, void 0, arity);
    result.placeholder = curryRight.placeholder;
    return result;
  }
  curryRight.placeholder = {};

  var now = function() {
    return root.Date.now();
  };

  var FUNC_ERROR_TEXT$6 = "Expected a function";
  var nativeMax$b = Math.max;
  var nativeMin$b = Math.min;
  function debounce(func, wait, options) {
    var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
    if (typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$6);
    }
    wait = toNumber(wait) || 0;
    if (isObject(options)) {
      leading = !!options.leading;
      maxing = "maxWait" in options;
      maxWait = maxing ? nativeMax$b(toNumber(options.maxWait) || 0, wait) : maxWait;
      trailing = "trailing" in options ? !!options.trailing : trailing;
    }
    function invokeFunc(time) {
      var args = lastArgs, thisArg = lastThis;
      lastArgs = lastThis = void 0;
      lastInvokeTime = time;
      result = func.apply(thisArg, args);
      return result;
    }
    function leadingEdge(time) {
      lastInvokeTime = time;
      timerId = setTimeout(timerExpired, wait);
      return leading ? invokeFunc(time) : result;
    }
    function remainingWait(time) {
      var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
      return maxing ? nativeMin$b(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
    }
    function shouldInvoke(time) {
      var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
      return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
    }
    function timerExpired() {
      var time = now();
      if (shouldInvoke(time)) {
        return trailingEdge(time);
      }
      timerId = setTimeout(timerExpired, remainingWait(time));
    }
    function trailingEdge(time) {
      timerId = void 0;
      if (trailing && lastArgs) {
        return invokeFunc(time);
      }
      lastArgs = lastThis = void 0;
      return result;
    }
    function cancel() {
      if (timerId !== void 0) {
        clearTimeout(timerId);
      }
      lastInvokeTime = 0;
      lastArgs = lastCallTime = lastThis = timerId = void 0;
    }
    function flush() {
      return timerId === void 0 ? result : trailingEdge(now());
    }
    function debounced() {
      var time = now(), isInvoking = shouldInvoke(time);
      lastArgs = arguments;
      lastThis = this;
      lastCallTime = time;
      if (isInvoking) {
        if (timerId === void 0) {
          return leadingEdge(lastCallTime);
        }
        if (maxing) {
          clearTimeout(timerId);
          timerId = setTimeout(timerExpired, wait);
          return invokeFunc(lastCallTime);
        }
      }
      if (timerId === void 0) {
        timerId = setTimeout(timerExpired, wait);
      }
      return result;
    }
    debounced.cancel = cancel;
    debounced.flush = flush;
    return debounced;
  }

  function defaultTo(value, defaultValue) {
    return value == null || value !== value ? defaultValue : value;
  }

  var objectProto$8 = Object.prototype;
  var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
  var defaults = baseRest(function(object, sources) {
    object = Object(object);
    var index = -1;
    var length = sources.length;
    var guard = length > 2 ? sources[2] : void 0;
    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
      length = 1;
    }
    while (++index < length) {
      var source = sources[index];
      var props = keysIn(source);
      var propsIndex = -1;
      var propsLength = props.length;
      while (++propsIndex < propsLength) {
        var key = props[propsIndex];
        var value = object[key];
        if (value === void 0 || eq(value, objectProto$8[key]) && !hasOwnProperty$7.call(object, key)) {
          object[key] = source[key];
        }
      }
    }
    return object;
  });

  function assignMergeValue(object, key, value) {
    if (value !== void 0 && !eq(object[key], value) || value === void 0 && !(key in object)) {
      baseAssignValue(object, key, value);
    }
  }

  function isArrayLikeObject(value) {
    return isObjectLike(value) && isArrayLike(value);
  }

  function safeGet(object, key) {
    if (key === "constructor" && typeof object[key] === "function") {
      return;
    }
    if (key == "__proto__") {
      return;
    }
    return object[key];
  }

  function toPlainObject(value) {
    return copyObject(value, keysIn(value));
  }

  function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
    var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
    if (stacked) {
      assignMergeValue(object, key, stacked);
      return;
    }
    var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
    var isCommon = newValue === void 0;
    if (isCommon) {
      var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
      newValue = srcValue;
      if (isArr || isBuff || isTyped) {
        if (isArray(objValue)) {
          newValue = objValue;
        } else if (isArrayLikeObject(objValue)) {
          newValue = copyArray(objValue);
        } else if (isBuff) {
          isCommon = false;
          newValue = cloneBuffer(srcValue, true);
        } else if (isTyped) {
          isCommon = false;
          newValue = cloneTypedArray(srcValue, true);
        } else {
          newValue = [];
        }
      } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
        newValue = objValue;
        if (isArguments(objValue)) {
          newValue = toPlainObject(objValue);
        } else if (!isObject(objValue) || isFunction(objValue)) {
          newValue = initCloneObject(srcValue);
        }
      } else {
        isCommon = false;
      }
    }
    if (isCommon) {
      stack.set(srcValue, newValue);
      mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
      stack["delete"](srcValue);
    }
    assignMergeValue(object, key, newValue);
  }

  function baseMerge(object, source, srcIndex, customizer, stack) {
    if (object === source) {
      return;
    }
    baseFor(source, function(srcValue, key) {
      stack || (stack = new Stack());
      if (isObject(srcValue)) {
        baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
      } else {
        var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
        if (newValue === void 0) {
          newValue = srcValue;
        }
        assignMergeValue(object, key, newValue);
      }
    }, keysIn);
  }

  function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
    if (isObject(objValue) && isObject(srcValue)) {
      stack.set(srcValue, objValue);
      baseMerge(objValue, srcValue, void 0, customDefaultsMerge, stack);
      stack["delete"](srcValue);
    }
    return objValue;
  }

  var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
    baseMerge(object, source, srcIndex, customizer);
  });

  var defaultsDeep = baseRest(function(args) {
    args.push(void 0, customDefaultsMerge);
    return apply(mergeWith, void 0, args);
  });

  var FUNC_ERROR_TEXT$5 = "Expected a function";
  function baseDelay(func, wait, args) {
    if (typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$5);
    }
    return setTimeout(function() {
      func.apply(void 0, args);
    }, wait);
  }

  var defer = baseRest(function(func, args) {
    return baseDelay(func, 1, args);
  });

  var delay = baseRest(function(func, wait, args) {
    return baseDelay(func, toNumber(wait) || 0, args);
  });

  function arrayIncludesWith(array, value, comparator) {
    var index = -1, length = array == null ? 0 : array.length;
    while (++index < length) {
      if (comparator(value, array[index])) {
        return true;
      }
    }
    return false;
  }

  var LARGE_ARRAY_SIZE$1 = 200;
  function baseDifference(array, values, iteratee, comparator) {
    var index = -1, includes = arrayIncludes, isCommon = true, length = array.length, result = [], valuesLength = values.length;
    if (!length) {
      return result;
    }
    if (iteratee) {
      values = arrayMap(values, baseUnary(iteratee));
    }
    if (comparator) {
      includes = arrayIncludesWith;
      isCommon = false;
    } else if (values.length >= LARGE_ARRAY_SIZE$1) {
      includes = cacheHas;
      isCommon = false;
      values = new SetCache(values);
    }
    outer:
      while (++index < length) {
        var value = array[index], computed = iteratee == null ? value : iteratee(value);
        value = comparator || value !== 0 ? value : 0;
        if (isCommon && computed === computed) {
          var valuesIndex = valuesLength;
          while (valuesIndex--) {
            if (values[valuesIndex] === computed) {
              continue outer;
            }
          }
          result.push(value);
        } else if (!includes(values, computed, comparator)) {
          result.push(value);
        }
      }
    return result;
  }

  var difference = baseRest(function(array, values) {
    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : [];
  });

  function last(array) {
    var length = array == null ? 0 : array.length;
    return length ? array[length - 1] : void 0;
  }

  var differenceBy = baseRest(function(array, values) {
    var iteratee = last(values);
    if (isArrayLikeObject(iteratee)) {
      iteratee = void 0;
    }
    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), baseIteratee(iteratee)) : [];
  });

  var differenceWith = baseRest(function(array, values) {
    var comparator = last(values);
    if (isArrayLikeObject(comparator)) {
      comparator = void 0;
    }
    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), void 0, comparator) : [];
  });

  var divide = createMathOperation(function(dividend, divisor) {
    return dividend / divisor;
  }, 1);

  function drop(array, n, guard) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    n = guard || n === void 0 ? 1 : toInteger(n);
    return baseSlice(array, n < 0 ? 0 : n, length);
  }

  function dropRight(array, n, guard) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    n = guard || n === void 0 ? 1 : toInteger(n);
    n = length - n;
    return baseSlice(array, 0, n < 0 ? 0 : n);
  }

  function baseWhile(array, predicate, isDrop, fromRight) {
    var length = array.length, index = fromRight ? length : -1;
    while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {
    }
    return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index);
  }

  function dropRightWhile(array, predicate) {
    return array && array.length ? baseWhile(array, baseIteratee(predicate), true, true) : [];
  }

  function dropWhile(array, predicate) {
    return array && array.length ? baseWhile(array, baseIteratee(predicate), true) : [];
  }

  function castFunction(value) {
    return typeof value == "function" ? value : identity;
  }

  function forEach(collection, iteratee) {
    var func = isArray(collection) ? arrayEach : baseEach;
    return func(collection, castFunction(iteratee));
  }

  function arrayEachRight(array, iteratee) {
    var length = array == null ? 0 : array.length;
    while (length--) {
      if (iteratee(array[length], length, array) === false) {
        break;
      }
    }
    return array;
  }

  var baseForRight = createBaseFor(true);

  function baseForOwnRight(object, iteratee) {
    return object && baseForRight(object, iteratee, keys);
  }

  var baseEachRight = createBaseEach(baseForOwnRight, true);

  function forEachRight(collection, iteratee) {
    var func = isArray(collection) ? arrayEachRight : baseEachRight;
    return func(collection, castFunction(iteratee));
  }

  function endsWith(string, target, position) {
    string = toString(string);
    target = baseToString(target);
    var length = string.length;
    position = position === void 0 ? length : baseClamp(toInteger(position), 0, length);
    var end = position;
    position -= target.length;
    return position >= 0 && string.slice(position, end) == target;
  }

  function baseToPairs(object, props) {
    return arrayMap(props, function(key) {
      return [key, object[key]];
    });
  }

  function setToPairs(set) {
    var index = -1, result = Array(set.size);
    set.forEach(function(value) {
      result[++index] = [value, value];
    });
    return result;
  }

  var mapTag$3 = "[object Map]";
  var setTag$3 = "[object Set]";
  function createToPairs(keysFunc) {
    return function(object) {
      var tag = getTag$1(object);
      if (tag == mapTag$3) {
        return mapToArray(object);
      }
      if (tag == setTag$3) {
        return setToPairs(object);
      }
      return baseToPairs(object, keysFunc(object));
    };
  }

  var toPairs = createToPairs(keys);

  var toPairsIn = createToPairs(keysIn);

  var htmlEscapes = {
    "&": "&amp;",
    "<": "&lt;",
    ">": "&gt;",
    '"': "&quot;",
    "'": "&#39;"
  };
  var escapeHtmlChar = basePropertyOf(htmlEscapes);

  var reUnescapedHtml = /[&<>"']/g;
  var reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
  function escape(string) {
    string = toString(string);
    return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
  }

  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
  var reHasRegExpChar = RegExp(reRegExpChar.source);
  function escapeRegExp(string) {
    string = toString(string);
    return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string;
  }

  function arrayEvery(array, predicate) {
    var index = -1, length = array == null ? 0 : array.length;
    while (++index < length) {
      if (!predicate(array[index], index, array)) {
        return false;
      }
    }
    return true;
  }

  function baseEvery(collection, predicate) {
    var result = true;
    baseEach(collection, function(value, index, collection2) {
      result = !!predicate(value, index, collection2);
      return result;
    });
    return result;
  }

  function every(collection, predicate, guard) {
    var func = isArray(collection) ? arrayEvery : baseEvery;
    if (guard && isIterateeCall(collection, predicate, guard)) {
      predicate = void 0;
    }
    return func(collection, baseIteratee(predicate));
  }

  var MAX_ARRAY_LENGTH$5 = 4294967295;
  function toLength(value) {
    return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH$5) : 0;
  }

  function baseFill(array, value, start, end) {
    var length = array.length;
    start = toInteger(start);
    if (start < 0) {
      start = -start > length ? 0 : length + start;
    }
    end = end === void 0 || end > length ? length : toInteger(end);
    if (end < 0) {
      end += length;
    }
    end = start > end ? 0 : toLength(end);
    while (start < end) {
      array[start++] = value;
    }
    return array;
  }

  function fill(array, value, start, end) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    if (start && typeof start != "number" && isIterateeCall(array, value, start)) {
      start = 0;
      end = length;
    }
    return baseFill(array, value, start, end);
  }

  function baseFilter(collection, predicate) {
    var result = [];
    baseEach(collection, function(value, index, collection2) {
      if (predicate(value, index, collection2)) {
        result.push(value);
      }
    });
    return result;
  }

  function filter(collection, predicate) {
    var func = isArray(collection) ? arrayFilter : baseFilter;
    return func(collection, baseIteratee(predicate));
  }

  function createFind(findIndexFunc) {
    return function(collection, predicate, fromIndex) {
      var iterable = Object(collection);
      if (!isArrayLike(collection)) {
        var iteratee = baseIteratee(predicate);
        collection = keys(collection);
        predicate = function(key) {
          return iteratee(iterable[key], key, iterable);
        };
      }
      var index = findIndexFunc(collection, predicate, fromIndex);
      return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0;
    };
  }

  var nativeMax$a = Math.max;
  function findIndex(array, predicate, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = fromIndex == null ? 0 : toInteger(fromIndex);
    if (index < 0) {
      index = nativeMax$a(length + index, 0);
    }
    return baseFindIndex(array, baseIteratee(predicate), index);
  }

  var find = createFind(findIndex);

  function baseFindKey(collection, predicate, eachFunc) {
    var result;
    eachFunc(collection, function(value, key, collection2) {
      if (predicate(value, key, collection2)) {
        result = key;
        return false;
      }
    });
    return result;
  }

  function findKey(object, predicate) {
    return baseFindKey(object, baseIteratee(predicate), baseForOwn);
  }

  var nativeMax$9 = Math.max;
  var nativeMin$a = Math.min;
  function findLastIndex(array, predicate, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = length - 1;
    if (fromIndex !== void 0) {
      index = toInteger(fromIndex);
      index = fromIndex < 0 ? nativeMax$9(length + index, 0) : nativeMin$a(index, length - 1);
    }
    return baseFindIndex(array, baseIteratee(predicate), index, true);
  }

  var findLast = createFind(findLastIndex);

  function findLastKey(object, predicate) {
    return baseFindKey(object, baseIteratee(predicate), baseForOwnRight);
  }

  function head(array) {
    return array && array.length ? array[0] : void 0;
  }

  function baseMap(collection, iteratee) {
    var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
    baseEach(collection, function(value, key, collection2) {
      result[++index] = iteratee(value, key, collection2);
    });
    return result;
  }

  function map(collection, iteratee) {
    var func = isArray(collection) ? arrayMap : baseMap;
    return func(collection, baseIteratee(iteratee));
  }

  function flatMap(collection, iteratee) {
    return baseFlatten(map(collection, iteratee), 1);
  }

  var INFINITY$2 = 1 / 0;
  function flatMapDeep(collection, iteratee) {
    return baseFlatten(map(collection, iteratee), INFINITY$2);
  }

  function flatMapDepth(collection, iteratee, depth) {
    depth = depth === void 0 ? 1 : toInteger(depth);
    return baseFlatten(map(collection, iteratee), depth);
  }

  var INFINITY$1 = 1 / 0;
  function flattenDeep(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseFlatten(array, INFINITY$1) : [];
  }

  function flattenDepth(array, depth) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    depth = depth === void 0 ? 1 : toInteger(depth);
    return baseFlatten(array, depth);
  }

  var WRAP_FLIP_FLAG = 512;
  function flip$2(func) {
    return createWrap(func, WRAP_FLIP_FLAG);
  }

  var floor$1 = createRound("floor");

  var FUNC_ERROR_TEXT$4 = "Expected a function";
  var WRAP_CURRY_FLAG = 8;
  var WRAP_PARTIAL_FLAG$1 = 32;
  var WRAP_ARY_FLAG = 128;
  var WRAP_REARG_FLAG$1 = 256;
  function createFlow(fromRight) {
    return flatRest(function(funcs) {
      var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru;
      if (fromRight) {
        funcs.reverse();
      }
      while (index--) {
        var func = funcs[index];
        if (typeof func != "function") {
          throw new TypeError(FUNC_ERROR_TEXT$4);
        }
        if (prereq && !wrapper && getFuncName(func) == "wrapper") {
          var wrapper = new LodashWrapper([], true);
        }
      }
      index = wrapper ? index : length;
      while (++index < length) {
        func = funcs[index];
        var funcName = getFuncName(func), data = funcName == "wrapper" ? getData(func) : void 0;
        if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG$1 | WRAP_REARG_FLAG$1) && !data[4].length && data[9] == 1) {
          wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
        } else {
          wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);
        }
      }
      return function() {
        var args = arguments, value = args[0];
        if (wrapper && args.length == 1 && isArray(value)) {
          return wrapper.plant(value).value();
        }
        var index2 = 0, result = length ? funcs[index2].apply(this, args) : value;
        while (++index2 < length) {
          result = funcs[index2].call(this, result);
        }
        return result;
      };
    });
  }

  var flow = createFlow();

  var flowRight = createFlow(true);

  function forIn(object, iteratee) {
    return object == null ? object : baseFor(object, castFunction(iteratee), keysIn);
  }

  function forInRight(object, iteratee) {
    return object == null ? object : baseForRight(object, castFunction(iteratee), keysIn);
  }

  function forOwn(object, iteratee) {
    return object && baseForOwn(object, castFunction(iteratee));
  }

  function forOwnRight(object, iteratee) {
    return object && baseForOwnRight(object, castFunction(iteratee));
  }

  function fromPairs(pairs) {
    var index = -1, length = pairs == null ? 0 : pairs.length, result = {};
    while (++index < length) {
      var pair = pairs[index];
      result[pair[0]] = pair[1];
    }
    return result;
  }

  function baseFunctions(object, props) {
    return arrayFilter(props, function(key) {
      return isFunction(object[key]);
    });
  }

  function functions(object) {
    return object == null ? [] : baseFunctions(object, keys(object));
  }

  function functionsIn(object) {
    return object == null ? [] : baseFunctions(object, keysIn(object));
  }

  var objectProto$7 = Object.prototype;
  var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
  var groupBy = createAggregator(function(result, value, key) {
    if (hasOwnProperty$6.call(result, key)) {
      result[key].push(value);
    } else {
      baseAssignValue(result, key, [value]);
    }
  });

  function baseGt(value, other) {
    return value > other;
  }

  function createRelationalOperation(operator) {
    return function(value, other) {
      if (!(typeof value == "string" && typeof other == "string")) {
        value = toNumber(value);
        other = toNumber(other);
      }
      return operator(value, other);
    };
  }

  var gt$1 = createRelationalOperation(baseGt);

  var gte = createRelationalOperation(function(value, other) {
    return value >= other;
  });

  var objectProto$6 = Object.prototype;
  var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
  function baseHas(object, key) {
    return object != null && hasOwnProperty$5.call(object, key);
  }

  function has(object, path) {
    return object != null && hasPath(object, path, baseHas);
  }

  var nativeMax$8 = Math.max;
  var nativeMin$9 = Math.min;
  function baseInRange(number, start, end) {
    return number >= nativeMin$9(start, end) && number < nativeMax$8(start, end);
  }

  function inRange(number, start, end) {
    start = toFinite(start);
    if (end === void 0) {
      end = start;
      start = 0;
    } else {
      end = toFinite(end);
    }
    number = toNumber(number);
    return baseInRange(number, start, end);
  }

  var stringTag = "[object String]";
  function isString(value) {
    return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
  }

  function baseValues(object, props) {
    return arrayMap(props, function(key) {
      return object[key];
    });
  }

  function values(object) {
    return object == null ? [] : baseValues(object, keys(object));
  }

  var nativeMax$7 = Math.max;
  function includes(collection, value, fromIndex, guard) {
    collection = isArrayLike(collection) ? collection : values(collection);
    fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
    var length = collection.length;
    if (fromIndex < 0) {
      fromIndex = nativeMax$7(length + fromIndex, 0);
    }
    return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
  }

  var nativeMax$6 = Math.max;
  function indexOf(array, value, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = fromIndex == null ? 0 : toInteger(fromIndex);
    if (index < 0) {
      index = nativeMax$6(length + index, 0);
    }
    return baseIndexOf(array, value, index);
  }

  function initial$1(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseSlice(array, 0, -1) : [];
  }

  var nativeMin$8 = Math.min;
  function baseIntersection(arrays, iteratee, comparator) {
    var includes = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array(othLength), maxLength = Infinity, result = [];
    while (othIndex--) {
      var array = arrays[othIndex];
      if (othIndex && iteratee) {
        array = arrayMap(array, baseUnary(iteratee));
      }
      maxLength = nativeMin$8(array.length, maxLength);
      caches[othIndex] = !comparator && (iteratee || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : void 0;
    }
    array = arrays[0];
    var index = -1, seen = caches[0];
    outer:
      while (++index < length && result.length < maxLength) {
        var value = array[index], computed = iteratee ? iteratee(value) : value;
        value = comparator || value !== 0 ? value : 0;
        if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) {
          othIndex = othLength;
          while (--othIndex) {
            var cache = caches[othIndex];
            if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator))) {
              continue outer;
            }
          }
          if (seen) {
            seen.push(computed);
          }
          result.push(value);
        }
      }
    return result;
  }

  function castArrayLikeObject(value) {
    return isArrayLikeObject(value) ? value : [];
  }

  var intersection = baseRest(function(arrays) {
    var mapped = arrayMap(arrays, castArrayLikeObject);
    return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
  });

  var intersectionBy = baseRest(function(arrays) {
    var iteratee = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
    if (iteratee === last(mapped)) {
      iteratee = void 0;
    } else {
      mapped.pop();
    }
    return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, baseIteratee(iteratee)) : [];
  });

  var intersectionWith = baseRest(function(arrays) {
    var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
    comparator = typeof comparator == "function" ? comparator : void 0;
    if (comparator) {
      mapped.pop();
    }
    return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, void 0, comparator) : [];
  });

  function baseInverter(object, setter, iteratee, accumulator) {
    baseForOwn(object, function(value, key, object2) {
      setter(accumulator, iteratee(value), key, object2);
    });
    return accumulator;
  }

  function createInverter(setter, toIteratee) {
    return function(object, iteratee) {
      return baseInverter(object, setter, toIteratee(iteratee), {});
    };
  }

  var objectProto$5 = Object.prototype;
  var nativeObjectToString$1 = objectProto$5.toString;
  var invert = createInverter(function(result, value, key) {
    if (value != null && typeof value.toString != "function") {
      value = nativeObjectToString$1.call(value);
    }
    result[value] = key;
  }, constant(identity));

  var objectProto$4 = Object.prototype;
  var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
  var nativeObjectToString = objectProto$4.toString;
  var invertBy = createInverter(function(result, value, key) {
    if (value != null && typeof value.toString != "function") {
      value = nativeObjectToString.call(value);
    }
    if (hasOwnProperty$4.call(result, value)) {
      result[value].push(key);
    } else {
      result[value] = [key];
    }
  }, baseIteratee);

  function parent(object, path) {
    return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
  }

  function baseInvoke(object, path, args) {
    path = castPath(path, object);
    object = parent(object, path);
    var func = object == null ? object : object[toKey(last(path))];
    return func == null ? void 0 : apply(func, object, args);
  }

  var invoke = baseRest(baseInvoke);

  var invokeMap = baseRest(function(collection, path, args) {
    var index = -1, isFunc = typeof path == "function", result = isArrayLike(collection) ? Array(collection.length) : [];
    baseEach(collection, function(value) {
      result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
    });
    return result;
  });

  var arrayBufferTag = "[object ArrayBuffer]";
  function baseIsArrayBuffer(value) {
    return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
  }

  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer;
  var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;

  var boolTag = "[object Boolean]";
  function isBoolean$1(value) {
    return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;
  }

  var dateTag = "[object Date]";
  function baseIsDate(value) {
    return isObjectLike(value) && baseGetTag(value) == dateTag;
  }

  var nodeIsDate = nodeUtil && nodeUtil.isDate;
  var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;

  function isElement$3(value) {
    return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
  }

  var mapTag$2 = "[object Map]";
  var setTag$2 = "[object Set]";
  var objectProto$3 = Object.prototype;
  var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
  function isEmpty$1(value) {
    if (value == null) {
      return true;
    }
    if (isArrayLike(value) && (isArray(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer(value) || isTypedArray(value) || isArguments(value))) {
      return !value.length;
    }
    var tag = getTag$1(value);
    if (tag == mapTag$2 || tag == setTag$2) {
      return !value.size;
    }
    if (isPrototype(value)) {
      return !baseKeys(value).length;
    }
    for (var key in value) {
      if (hasOwnProperty$3.call(value, key)) {
        return false;
      }
    }
    return true;
  }

  function isEqual$1(value, other) {
    return baseIsEqual(value, other);
  }

  function isEqualWith(value, other, customizer) {
    customizer = typeof customizer == "function" ? customizer : void 0;
    var result = customizer ? customizer(value, other) : void 0;
    return result === void 0 ? baseIsEqual(value, other, void 0, customizer) : !!result;
  }

  var nativeIsFinite = root.isFinite;
  function isFinite(value) {
    return typeof value == "number" && nativeIsFinite(value);
  }

  function isInteger(value) {
    return typeof value == "number" && value == toInteger(value);
  }

  function isMatch(object, source) {
    return object === source || baseIsMatch(object, source, getMatchData(source));
  }

  function isMatchWith(object, source, customizer) {
    customizer = typeof customizer == "function" ? customizer : void 0;
    return baseIsMatch(object, source, getMatchData(source), customizer);
  }

  var numberTag = "[object Number]";
  function isNumber$1(value) {
    return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag;
  }

  function isNaN$1(value) {
    return isNumber$1(value) && value != +value;
  }

  var isMaskable = coreJsData ? isFunction : stubFalse;

  var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.";
  function isNative(value) {
    if (isMaskable(value)) {
      throw new Error(CORE_ERROR_TEXT);
    }
    return baseIsNative(value);
  }

  function isNil(value) {
    return value == null;
  }

  function isNull(value) {
    return value === null;
  }

  var regexpTag = "[object RegExp]";
  function baseIsRegExp(value) {
    return isObjectLike(value) && baseGetTag(value) == regexpTag;
  }

  var nodeIsRegExp = nodeUtil && nodeUtil.isRegExp;
  var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;

  var MAX_SAFE_INTEGER$3 = 9007199254740991;
  function isSafeInteger(value) {
    return isInteger(value) && value >= -MAX_SAFE_INTEGER$3 && value <= MAX_SAFE_INTEGER$3;
  }

  function isUndefined$1(value) {
    return value === void 0;
  }

  var weakMapTag = "[object WeakMap]";
  function isWeakMap(value) {
    return isObjectLike(value) && getTag$1(value) == weakMapTag;
  }

  var weakSetTag = "[object WeakSet]";
  function isWeakSet(value) {
    return isObjectLike(value) && baseGetTag(value) == weakSetTag;
  }

  var CLONE_DEEP_FLAG$3 = 1;
  function iteratee(func) {
    return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG$3));
  }

  var arrayProto$4 = Array.prototype;
  var nativeJoin = arrayProto$4.join;
  function join(array, separator) {
    return array == null ? "" : nativeJoin.call(array, separator);
  }

  var kebabCase = createCompounder(function(result, word, index) {
    return result + (index ? "-" : "") + word.toLowerCase();
  });

  var keyBy = createAggregator(function(result, value, key) {
    baseAssignValue(result, key, value);
  });

  function strictLastIndexOf(array, value, fromIndex) {
    var index = fromIndex + 1;
    while (index--) {
      if (array[index] === value) {
        return index;
      }
    }
    return index;
  }

  var nativeMax$5 = Math.max;
  var nativeMin$7 = Math.min;
  function lastIndexOf(array, value, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = length;
    if (fromIndex !== void 0) {
      index = toInteger(fromIndex);
      index = index < 0 ? nativeMax$5(length + index, 0) : nativeMin$7(index, length - 1);
    }
    return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true);
  }

  var lowerCase = createCompounder(function(result, word, index) {
    return result + (index ? " " : "") + word.toLowerCase();
  });

  var lowerFirst = createCaseFirst("toLowerCase");

  function baseLt(value, other) {
    return value < other;
  }

  var lt$1 = createRelationalOperation(baseLt);

  var lte = createRelationalOperation(function(value, other) {
    return value <= other;
  });

  function mapKeys(object, iteratee) {
    var result = {};
    iteratee = baseIteratee(iteratee);
    baseForOwn(object, function(value, key, object2) {
      baseAssignValue(result, iteratee(value, key, object2), value);
    });
    return result;
  }

  function mapValues(object, iteratee) {
    var result = {};
    iteratee = baseIteratee(iteratee);
    baseForOwn(object, function(value, key, object2) {
      baseAssignValue(result, key, iteratee(value, key, object2));
    });
    return result;
  }

  var CLONE_DEEP_FLAG$2 = 1;
  function matches(source) {
    return baseMatches(baseClone(source, CLONE_DEEP_FLAG$2));
  }

  var CLONE_DEEP_FLAG$1 = 1;
  function matchesProperty(path, srcValue) {
    return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG$1));
  }

  function baseExtremum(array, iteratee, comparator) {
    var index = -1, length = array.length;
    while (++index < length) {
      var value = array[index], current = iteratee(value);
      if (current != null && (computed === void 0 ? current === current && !isSymbol(current) : comparator(current, computed))) {
        var computed = current, result = value;
      }
    }
    return result;
  }

  function max$4(array) {
    return array && array.length ? baseExtremum(array, identity, baseGt) : void 0;
  }

  function maxBy(array, iteratee) {
    return array && array.length ? baseExtremum(array, baseIteratee(iteratee), baseGt) : void 0;
  }

  function baseSum(array, iteratee) {
    var result, index = -1, length = array.length;
    while (++index < length) {
      var current = iteratee(array[index]);
      if (current !== void 0) {
        result = result === void 0 ? current : result + current;
      }
    }
    return result;
  }

  var NAN = 0 / 0;
  function baseMean(array, iteratee) {
    var length = array == null ? 0 : array.length;
    return length ? baseSum(array, iteratee) / length : NAN;
  }

  function mean(array) {
    return baseMean(array, identity);
  }

  function meanBy(array, iteratee) {
    return baseMean(array, baseIteratee(iteratee));
  }

  var merge = createAssigner(function(object, source, srcIndex) {
    baseMerge(object, source, srcIndex);
  });

  var method = baseRest(function(path, args) {
    return function(object) {
      return baseInvoke(object, path, args);
    };
  });

  var methodOf = baseRest(function(object, args) {
    return function(path) {
      return baseInvoke(object, path, args);
    };
  });

  function min$4(array) {
    return array && array.length ? baseExtremum(array, identity, baseLt) : void 0;
  }

  function minBy(array, iteratee) {
    return array && array.length ? baseExtremum(array, baseIteratee(iteratee), baseLt) : void 0;
  }

  function mixin$1(object, source, options) {
    var props = keys(source), methodNames = baseFunctions(source, props);
    var chain = !(isObject(options) && "chain" in options) || !!options.chain, isFunc = isFunction(object);
    arrayEach(methodNames, function(methodName) {
      var func = source[methodName];
      object[methodName] = func;
      if (isFunc) {
        object.prototype[methodName] = function() {
          var chainAll = this.__chain__;
          if (chain || chainAll) {
            var result = object(this.__wrapped__), actions = result.__actions__ = copyArray(this.__actions__);
            actions.push({ "func": func, "args": arguments, "thisArg": object });
            result.__chain__ = chainAll;
            return result;
          }
          return func.apply(object, arrayPush([this.value()], arguments));
        };
      }
    });
    return object;
  }

  var multiply = createMathOperation(function(multiplier, multiplicand) {
    return multiplier * multiplicand;
  }, 1);

  var FUNC_ERROR_TEXT$3 = "Expected a function";
  function negate(predicate) {
    if (typeof predicate != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$3);
    }
    return function() {
      var args = arguments;
      switch (args.length) {
        case 0:
          return !predicate.call(this);
        case 1:
          return !predicate.call(this, args[0]);
        case 2:
          return !predicate.call(this, args[0], args[1]);
        case 3:
          return !predicate.call(this, args[0], args[1], args[2]);
      }
      return !predicate.apply(this, args);
    };
  }

  function iteratorToArray(iterator) {
    var data, result = [];
    while (!(data = iterator.next()).done) {
      result.push(data.value);
    }
    return result;
  }

  var mapTag$1 = "[object Map]";
  var setTag$1 = "[object Set]";
  var symIterator$1 = Symbol$1 ? Symbol$1.iterator : void 0;
  function toArray(value) {
    if (!value) {
      return [];
    }
    if (isArrayLike(value)) {
      return isString(value) ? stringToArray(value) : copyArray(value);
    }
    if (symIterator$1 && value[symIterator$1]) {
      return iteratorToArray(value[symIterator$1]());
    }
    var tag = getTag$1(value), func = tag == mapTag$1 ? mapToArray : tag == setTag$1 ? setToArray : values;
    return func(value);
  }

  function wrapperNext() {
    if (this.__values__ === void 0) {
      this.__values__ = toArray(this.value());
    }
    var done = this.__index__ >= this.__values__.length, value = done ? void 0 : this.__values__[this.__index__++];
    return { "done": done, "value": value };
  }

  function baseNth(array, n) {
    var length = array.length;
    if (!length) {
      return;
    }
    n += n < 0 ? length : 0;
    return isIndex(n, length) ? array[n] : void 0;
  }

  function nth(array, n) {
    return array && array.length ? baseNth(array, toInteger(n)) : void 0;
  }

  function nthArg(n) {
    n = toInteger(n);
    return baseRest(function(args) {
      return baseNth(args, n);
    });
  }

  function baseUnset(object, path) {
    path = castPath(path, object);
    object = parent(object, path);
    return object == null || delete object[toKey(last(path))];
  }

  function customOmitClone(value) {
    return isPlainObject(value) ? void 0 : value;
  }

  var CLONE_DEEP_FLAG = 1;
  var CLONE_FLAT_FLAG = 2;
  var CLONE_SYMBOLS_FLAG = 4;
  var omit = flatRest(function(object, paths) {
    var result = {};
    if (object == null) {
      return result;
    }
    var isDeep = false;
    paths = arrayMap(paths, function(path) {
      path = castPath(path, object);
      isDeep || (isDeep = path.length > 1);
      return path;
    });
    copyObject(object, getAllKeysIn(object), result);
    if (isDeep) {
      result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
    }
    var length = paths.length;
    while (length--) {
      baseUnset(result, paths[length]);
    }
    return result;
  });

  function baseSet(object, path, value, customizer) {
    if (!isObject(object)) {
      return object;
    }
    path = castPath(path, object);
    var index = -1, length = path.length, lastIndex = length - 1, nested = object;
    while (nested != null && ++index < length) {
      var key = toKey(path[index]), newValue = value;
      if (key === "__proto__" || key === "constructor" || key === "prototype") {
        return object;
      }
      if (index != lastIndex) {
        var objValue = nested[key];
        newValue = customizer ? customizer(objValue, key, nested) : void 0;
        if (newValue === void 0) {
          newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
        }
      }
      assignValue(nested, key, newValue);
      nested = nested[key];
    }
    return object;
  }

  function basePickBy(object, paths, predicate) {
    var index = -1, length = paths.length, result = {};
    while (++index < length) {
      var path = paths[index], value = baseGet(object, path);
      if (predicate(value, path)) {
        baseSet(result, castPath(path, object), value);
      }
    }
    return result;
  }

  function pickBy(object, predicate) {
    if (object == null) {
      return {};
    }
    var props = arrayMap(getAllKeysIn(object), function(prop) {
      return [prop];
    });
    predicate = baseIteratee(predicate);
    return basePickBy(object, props, function(value, path) {
      return predicate(value, path[0]);
    });
  }

  function omitBy(object, predicate) {
    return pickBy(object, negate(baseIteratee(predicate)));
  }

  function once(func) {
    return before(2, func);
  }

  function baseSortBy(array, comparer) {
    var length = array.length;
    array.sort(comparer);
    while (length--) {
      array[length] = array[length].value;
    }
    return array;
  }

  function compareAscending(value, other) {
    if (value !== other) {
      var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
      var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
      if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
        return 1;
      }
      if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
        return -1;
      }
    }
    return 0;
  }

  function compareMultiple(object, other, orders) {
    var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
    while (++index < length) {
      var result = compareAscending(objCriteria[index], othCriteria[index]);
      if (result) {
        if (index >= ordersLength) {
          return result;
        }
        var order = orders[index];
        return result * (order == "desc" ? -1 : 1);
      }
    }
    return object.index - other.index;
  }

  function baseOrderBy(collection, iteratees, orders) {
    if (iteratees.length) {
      iteratees = arrayMap(iteratees, function(iteratee) {
        if (isArray(iteratee)) {
          return function(value) {
            return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
          };
        }
        return iteratee;
      });
    } else {
      iteratees = [identity];
    }
    var index = -1;
    iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
    var result = baseMap(collection, function(value, key, collection2) {
      var criteria = arrayMap(iteratees, function(iteratee) {
        return iteratee(value);
      });
      return { "criteria": criteria, "index": ++index, "value": value };
    });
    return baseSortBy(result, function(object, other) {
      return compareMultiple(object, other, orders);
    });
  }

  function orderBy$1(collection, iteratees, orders, guard) {
    if (collection == null) {
      return [];
    }
    if (!isArray(iteratees)) {
      iteratees = iteratees == null ? [] : [iteratees];
    }
    orders = guard ? void 0 : orders;
    if (!isArray(orders)) {
      orders = orders == null ? [] : [orders];
    }
    return baseOrderBy(collection, iteratees, orders);
  }

  function createOver(arrayFunc) {
    return flatRest(function(iteratees) {
      iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
      return baseRest(function(args) {
        var thisArg = this;
        return arrayFunc(iteratees, function(iteratee) {
          return apply(iteratee, thisArg, args);
        });
      });
    });
  }

  var over = createOver(arrayMap);

  var castRest = baseRest;

  var nativeMin$6 = Math.min;
  var overArgs = castRest(function(func, transforms) {
    transforms = transforms.length == 1 && isArray(transforms[0]) ? arrayMap(transforms[0], baseUnary(baseIteratee)) : arrayMap(baseFlatten(transforms, 1), baseUnary(baseIteratee));
    var funcsLength = transforms.length;
    return baseRest(function(args) {
      var index = -1, length = nativeMin$6(args.length, funcsLength);
      while (++index < length) {
        args[index] = transforms[index].call(this, args[index]);
      }
      return apply(func, this, args);
    });
  });

  var overEvery = createOver(arrayEvery);

  var overSome = createOver(arraySome);

  var MAX_SAFE_INTEGER$2 = 9007199254740991;
  var nativeFloor$3 = Math.floor;
  function baseRepeat(string, n) {
    var result = "";
    if (!string || n < 1 || n > MAX_SAFE_INTEGER$2) {
      return result;
    }
    do {
      if (n % 2) {
        result += string;
      }
      n = nativeFloor$3(n / 2);
      if (n) {
        string += string;
      }
    } while (n);
    return result;
  }

  var asciiSize = baseProperty("length");

  var rsAstralRange = "\\ud800-\\udfff";
  var rsComboMarksRange = "\\u0300-\\u036f";
  var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
  var rsComboSymbolsRange = "\\u20d0-\\u20ff";
  var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
  var rsVarRange = "\\ufe0e\\ufe0f";
  var rsAstral = "[" + rsAstralRange + "]";
  var rsCombo = "[" + rsComboRange + "]";
  var rsFitz = "\\ud83c[\\udffb-\\udfff]";
  var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
  var rsNonAstral = "[^" + rsAstralRange + "]";
  var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
  var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
  var rsZWJ = "\\u200d";
  var reOptMod = rsModifier + "?";
  var rsOptVar = "[" + rsVarRange + "]?";
  var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
  var rsSeq = rsOptVar + reOptMod + rsOptJoin;
  var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
  var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
  function unicodeSize(string) {
    var result = reUnicode.lastIndex = 0;
    while (reUnicode.test(string)) {
      ++result;
    }
    return result;
  }

  function stringSize(string) {
    return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
  }

  var nativeCeil$2 = Math.ceil;
  function createPadding(length, chars) {
    chars = chars === void 0 ? " " : baseToString(chars);
    var charsLength = chars.length;
    if (charsLength < 2) {
      return charsLength ? baseRepeat(chars, length) : chars;
    }
    var result = baseRepeat(chars, nativeCeil$2(length / stringSize(chars)));
    return hasUnicode(chars) ? castSlice(stringToArray(result), 0, length).join("") : result.slice(0, length);
  }

  var nativeCeil$1 = Math.ceil;
  var nativeFloor$2 = Math.floor;
  function pad(string, length, chars) {
    string = toString(string);
    length = toInteger(length);
    var strLength = length ? stringSize(string) : 0;
    if (!length || strLength >= length) {
      return string;
    }
    var mid = (length - strLength) / 2;
    return createPadding(nativeFloor$2(mid), chars) + string + createPadding(nativeCeil$1(mid), chars);
  }

  function padEnd(string, length, chars) {
    string = toString(string);
    length = toInteger(length);
    var strLength = length ? stringSize(string) : 0;
    return length && strLength < length ? string + createPadding(length - strLength, chars) : string;
  }

  function padStart(string, length, chars) {
    string = toString(string);
    length = toInteger(length);
    var strLength = length ? stringSize(string) : 0;
    return length && strLength < length ? createPadding(length - strLength, chars) + string : string;
  }

  var reTrimStart$1 = /^\s+/;
  var nativeParseInt = root.parseInt;
  function parseInt$1(string, radix, guard) {
    if (guard || radix == null) {
      radix = 0;
    } else if (radix) {
      radix = +radix;
    }
    return nativeParseInt(toString(string).replace(reTrimStart$1, ""), radix || 0);
  }

  var WRAP_PARTIAL_FLAG = 32;
  var partial = baseRest(function(func, partials) {
    var holders = replaceHolders(partials, getHolder(partial));
    return createWrap(func, WRAP_PARTIAL_FLAG, void 0, partials, holders);
  });
  partial.placeholder = {};

  var WRAP_PARTIAL_RIGHT_FLAG = 64;
  var partialRight = baseRest(function(func, partials) {
    var holders = replaceHolders(partials, getHolder(partialRight));
    return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, void 0, partials, holders);
  });
  partialRight.placeholder = {};

  var partition = createAggregator(function(result, value, key) {
    result[key ? 0 : 1].push(value);
  }, function() {
    return [[], []];
  });

  function basePick(object, paths) {
    return basePickBy(object, paths, function(value, path) {
      return hasIn(object, path);
    });
  }

  var pick = flatRest(function(object, paths) {
    return object == null ? {} : basePick(object, paths);
  });

  function wrapperPlant(value) {
    var result, parent = this;
    while (parent instanceof baseLodash) {
      var clone = wrapperClone(parent);
      clone.__index__ = 0;
      clone.__values__ = void 0;
      if (result) {
        previous.__wrapped__ = clone;
      } else {
        result = clone;
      }
      var previous = clone;
      parent = parent.__wrapped__;
    }
    previous.__wrapped__ = value;
    return result;
  }

  function propertyOf(object) {
    return function(path) {
      return object == null ? void 0 : baseGet(object, path);
    };
  }

  function baseIndexOfWith(array, value, fromIndex, comparator) {
    var index = fromIndex - 1, length = array.length;
    while (++index < length) {
      if (comparator(array[index], value)) {
        return index;
      }
    }
    return -1;
  }

  var arrayProto$3 = Array.prototype;
  var splice$1 = arrayProto$3.splice;
  function basePullAll(array, values, iteratee, comparator) {
    var indexOf = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values.length, seen = array;
    if (array === values) {
      values = copyArray(values);
    }
    if (iteratee) {
      seen = arrayMap(array, baseUnary(iteratee));
    }
    while (++index < length) {
      var fromIndex = 0, value = values[index], computed = iteratee ? iteratee(value) : value;
      while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
        if (seen !== array) {
          splice$1.call(seen, fromIndex, 1);
        }
        splice$1.call(array, fromIndex, 1);
      }
    }
    return array;
  }

  function pullAll(array, values) {
    return array && array.length && values && values.length ? basePullAll(array, values) : array;
  }

  var pull = baseRest(pullAll);

  function pullAllBy(array, values, iteratee) {
    return array && array.length && values && values.length ? basePullAll(array, values, baseIteratee(iteratee)) : array;
  }

  function pullAllWith(array, values, comparator) {
    return array && array.length && values && values.length ? basePullAll(array, values, void 0, comparator) : array;
  }

  var arrayProto$2 = Array.prototype;
  var splice = arrayProto$2.splice;
  function basePullAt(array, indexes) {
    var length = array ? indexes.length : 0, lastIndex = length - 1;
    while (length--) {
      var index = indexes[length];
      if (length == lastIndex || index !== previous) {
        var previous = index;
        if (isIndex(index)) {
          splice.call(array, index, 1);
        } else {
          baseUnset(array, index);
        }
      }
    }
    return array;
  }

  var pullAt = flatRest(function(array, indexes) {
    var length = array == null ? 0 : array.length, result = baseAt(array, indexes);
    basePullAt(array, arrayMap(indexes, function(index) {
      return isIndex(index, length) ? +index : index;
    }).sort(compareAscending));
    return result;
  });

  var nativeFloor$1 = Math.floor;
  var nativeRandom$1 = Math.random;
  function baseRandom(lower, upper) {
    return lower + nativeFloor$1(nativeRandom$1() * (upper - lower + 1));
  }

  var freeParseFloat = parseFloat;
  var nativeMin$5 = Math.min;
  var nativeRandom = Math.random;
  function random(lower, upper, floating) {
    if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
      upper = floating = void 0;
    }
    if (floating === void 0) {
      if (typeof upper == "boolean") {
        floating = upper;
        upper = void 0;
      } else if (typeof lower == "boolean") {
        floating = lower;
        lower = void 0;
      }
    }
    if (lower === void 0 && upper === void 0) {
      lower = 0;
      upper = 1;
    } else {
      lower = toFinite(lower);
      if (upper === void 0) {
        upper = lower;
        lower = 0;
      } else {
        upper = toFinite(upper);
      }
    }
    if (lower > upper) {
      var temp = lower;
      lower = upper;
      upper = temp;
    }
    if (floating || lower % 1 || upper % 1) {
      var rand = nativeRandom();
      return nativeMin$5(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
    }
    return baseRandom(lower, upper);
  }

  var nativeCeil = Math.ceil;
  var nativeMax$4 = Math.max;
  function baseRange(start, end, step, fromRight) {
    var index = -1, length = nativeMax$4(nativeCeil((end - start) / (step || 1)), 0), result = Array(length);
    while (length--) {
      result[fromRight ? length : ++index] = start;
      start += step;
    }
    return result;
  }

  function createRange(fromRight) {
    return function(start, end, step) {
      if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
        end = step = void 0;
      }
      start = toFinite(start);
      if (end === void 0) {
        end = start;
        start = 0;
      } else {
        end = toFinite(end);
      }
      step = step === void 0 ? start < end ? 1 : -1 : toFinite(step);
      return baseRange(start, end, step, fromRight);
    };
  }

  var range$1 = createRange();

  var rangeRight = createRange(true);

  var WRAP_REARG_FLAG = 256;
  var rearg = flatRest(function(func, indexes) {
    return createWrap(func, WRAP_REARG_FLAG, void 0, void 0, void 0, indexes);
  });

  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
    eachFunc(collection, function(value, index, collection2) {
      accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);
    });
    return accumulator;
  }

  function reduce(collection, iteratee, accumulator) {
    var func = isArray(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
    return func(collection, baseIteratee(iteratee), accumulator, initAccum, baseEach);
  }

  function arrayReduceRight(array, iteratee, accumulator, initAccum) {
    var length = array == null ? 0 : array.length;
    if (initAccum && length) {
      accumulator = array[--length];
    }
    while (length--) {
      accumulator = iteratee(accumulator, array[length], length, array);
    }
    return accumulator;
  }

  function reduceRight(collection, iteratee, accumulator) {
    var func = isArray(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
    return func(collection, baseIteratee(iteratee), accumulator, initAccum, baseEachRight);
  }

  function reject(collection, predicate) {
    var func = isArray(collection) ? arrayFilter : baseFilter;
    return func(collection, negate(baseIteratee(predicate)));
  }

  function remove(array, predicate) {
    var result = [];
    if (!(array && array.length)) {
      return result;
    }
    var index = -1, indexes = [], length = array.length;
    predicate = baseIteratee(predicate);
    while (++index < length) {
      var value = array[index];
      if (predicate(value, index, array)) {
        result.push(value);
        indexes.push(index);
      }
    }
    basePullAt(array, indexes);
    return result;
  }

  function repeat(string, n, guard) {
    if (guard ? isIterateeCall(string, n, guard) : n === void 0) {
      n = 1;
    } else {
      n = toInteger(n);
    }
    return baseRepeat(toString(string), n);
  }

  function replace() {
    var args = arguments, string = toString(args[0]);
    return args.length < 3 ? string : string.replace(args[1], args[2]);
  }

  var FUNC_ERROR_TEXT$2 = "Expected a function";
  function rest(func, start) {
    if (typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$2);
    }
    start = start === void 0 ? start : toInteger(start);
    return baseRest(func, start);
  }

  function result(object, path, defaultValue) {
    path = castPath(path, object);
    var index = -1, length = path.length;
    if (!length) {
      length = 1;
      object = void 0;
    }
    while (++index < length) {
      var value = object == null ? void 0 : object[toKey(path[index])];
      if (value === void 0) {
        index = length;
        value = defaultValue;
      }
      object = isFunction(value) ? value.call(object) : value;
    }
    return object;
  }

  var arrayProto$1 = Array.prototype;
  var nativeReverse = arrayProto$1.reverse;
  function reverse(array) {
    return array == null ? array : nativeReverse.call(array);
  }

  var round$2 = createRound("round");

  function arraySample(array) {
    var length = array.length;
    return length ? array[baseRandom(0, length - 1)] : void 0;
  }

  function baseSample(collection) {
    return arraySample(values(collection));
  }

  function sample(collection) {
    var func = isArray(collection) ? arraySample : baseSample;
    return func(collection);
  }

  function shuffleSelf(array, size) {
    var index = -1, length = array.length, lastIndex = length - 1;
    size = size === void 0 ? length : size;
    while (++index < size) {
      var rand = baseRandom(index, lastIndex), value = array[rand];
      array[rand] = array[index];
      array[index] = value;
    }
    array.length = size;
    return array;
  }

  function arraySampleSize(array, n) {
    return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
  }

  function baseSampleSize(collection, n) {
    var array = values(collection);
    return shuffleSelf(array, baseClamp(n, 0, array.length));
  }

  function sampleSize(collection, n, guard) {
    if (guard ? isIterateeCall(collection, n, guard) : n === void 0) {
      n = 1;
    } else {
      n = toInteger(n);
    }
    var func = isArray(collection) ? arraySampleSize : baseSampleSize;
    return func(collection, n);
  }

  function set(object, path, value) {
    return object == null ? object : baseSet(object, path, value);
  }

  function setWith(object, path, value, customizer) {
    customizer = typeof customizer == "function" ? customizer : void 0;
    return object == null ? object : baseSet(object, path, value, customizer);
  }

  function arrayShuffle(array) {
    return shuffleSelf(copyArray(array));
  }

  function baseShuffle(collection) {
    return shuffleSelf(values(collection));
  }

  function shuffle(collection) {
    var func = isArray(collection) ? arrayShuffle : baseShuffle;
    return func(collection);
  }

  var mapTag = "[object Map]";
  var setTag = "[object Set]";
  function size$1(collection) {
    if (collection == null) {
      return 0;
    }
    if (isArrayLike(collection)) {
      return isString(collection) ? stringSize(collection) : collection.length;
    }
    var tag = getTag$1(collection);
    if (tag == mapTag || tag == setTag) {
      return collection.size;
    }
    return baseKeys(collection).length;
  }

  function slice(array, start, end) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    if (end && typeof end != "number" && isIterateeCall(array, start, end)) {
      start = 0;
      end = length;
    } else {
      start = start == null ? 0 : toInteger(start);
      end = end === void 0 ? length : toInteger(end);
    }
    return baseSlice(array, start, end);
  }

  var snakeCase = createCompounder(function(result, word, index) {
    return result + (index ? "_" : "") + word.toLowerCase();
  });

  function baseSome(collection, predicate) {
    var result;
    baseEach(collection, function(value, index, collection2) {
      result = predicate(value, index, collection2);
      return !result;
    });
    return !!result;
  }

  function some(collection, predicate, guard) {
    var func = isArray(collection) ? arraySome : baseSome;
    if (guard && isIterateeCall(collection, predicate, guard)) {
      predicate = void 0;
    }
    return func(collection, baseIteratee(predicate));
  }

  var sortBy = baseRest(function(collection, iteratees) {
    if (collection == null) {
      return [];
    }
    var length = iteratees.length;
    if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
      iteratees = [];
    } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
      iteratees = [iteratees[0]];
    }
    return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
  });

  var MAX_ARRAY_LENGTH$4 = 4294967295;
  var MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH$4 - 1;
  var nativeFloor = Math.floor;
  var nativeMin$4 = Math.min;
  function baseSortedIndexBy(array, value, iteratee, retHighest) {
    var low = 0, high = array == null ? 0 : array.length;
    if (high === 0) {
      return 0;
    }
    value = iteratee(value);
    var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === void 0;
    while (low < high) {
      var mid = nativeFloor((low + high) / 2), computed = iteratee(array[mid]), othIsDefined = computed !== void 0, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
      if (valIsNaN) {
        var setLow = retHighest || othIsReflexive;
      } else if (valIsUndefined) {
        setLow = othIsReflexive && (retHighest || othIsDefined);
      } else if (valIsNull) {
        setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
      } else if (valIsSymbol) {
        setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
      } else if (othIsNull || othIsSymbol) {
        setLow = false;
      } else {
        setLow = retHighest ? computed <= value : computed < value;
      }
      if (setLow) {
        low = mid + 1;
      } else {
        high = mid;
      }
    }
    return nativeMin$4(high, MAX_ARRAY_INDEX);
  }

  var MAX_ARRAY_LENGTH$3 = 4294967295;
  var HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH$3 >>> 1;
  function baseSortedIndex(array, value, retHighest) {
    var low = 0, high = array == null ? low : array.length;
    if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
      while (low < high) {
        var mid = low + high >>> 1, computed = array[mid];
        if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) {
          low = mid + 1;
        } else {
          high = mid;
        }
      }
      return high;
    }
    return baseSortedIndexBy(array, value, identity, retHighest);
  }

  function sortedIndex(array, value) {
    return baseSortedIndex(array, value);
  }

  function sortedIndexBy(array, value, iteratee) {
    return baseSortedIndexBy(array, value, baseIteratee(iteratee));
  }

  function sortedIndexOf(array, value) {
    var length = array == null ? 0 : array.length;
    if (length) {
      var index = baseSortedIndex(array, value);
      if (index < length && eq(array[index], value)) {
        return index;
      }
    }
    return -1;
  }

  function sortedLastIndex(array, value) {
    return baseSortedIndex(array, value, true);
  }

  function sortedLastIndexBy(array, value, iteratee) {
    return baseSortedIndexBy(array, value, baseIteratee(iteratee), true);
  }

  function sortedLastIndexOf(array, value) {
    var length = array == null ? 0 : array.length;
    if (length) {
      var index = baseSortedIndex(array, value, true) - 1;
      if (eq(array[index], value)) {
        return index;
      }
    }
    return -1;
  }

  function baseSortedUniq(array, iteratee) {
    var index = -1, length = array.length, resIndex = 0, result = [];
    while (++index < length) {
      var value = array[index], computed = iteratee ? iteratee(value) : value;
      if (!index || !eq(computed, seen)) {
        var seen = computed;
        result[resIndex++] = value === 0 ? 0 : value;
      }
    }
    return result;
  }

  function sortedUniq(array) {
    return array && array.length ? baseSortedUniq(array) : [];
  }

  function sortedUniqBy(array, iteratee) {
    return array && array.length ? baseSortedUniq(array, baseIteratee(iteratee)) : [];
  }

  var MAX_ARRAY_LENGTH$2 = 4294967295;
  function split(string, separator, limit) {
    if (limit && typeof limit != "number" && isIterateeCall(string, separator, limit)) {
      separator = limit = void 0;
    }
    limit = limit === void 0 ? MAX_ARRAY_LENGTH$2 : limit >>> 0;
    if (!limit) {
      return [];
    }
    string = toString(string);
    if (string && (typeof separator == "string" || separator != null && !isRegExp(separator))) {
      separator = baseToString(separator);
      if (!separator && hasUnicode(string)) {
        return castSlice(stringToArray(string), 0, limit);
      }
    }
    return string.split(separator, limit);
  }

  var FUNC_ERROR_TEXT$1 = "Expected a function";
  var nativeMax$3 = Math.max;
  function spread(func, start) {
    if (typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT$1);
    }
    start = start == null ? 0 : nativeMax$3(toInteger(start), 0);
    return baseRest(function(args) {
      var array = args[start], otherArgs = castSlice(args, 0, start);
      if (array) {
        arrayPush(otherArgs, array);
      }
      return apply(func, this, otherArgs);
    });
  }

  var startCase = createCompounder(function(result, word, index) {
    return result + (index ? " " : "") + upperFirst(word);
  });

  function startsWith(string, target, position) {
    string = toString(string);
    position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length);
    target = baseToString(target);
    return string.slice(position, position + target.length) == target;
  }

  function stubObject() {
    return {};
  }

  function stubString() {
    return "";
  }

  function stubTrue() {
    return true;
  }

  var subtract = createMathOperation(function(minuend, subtrahend) {
    return minuend - subtrahend;
  }, 0);

  function sum$1(array) {
    return array && array.length ? baseSum(array, identity) : 0;
  }

  function sumBy(array, iteratee) {
    return array && array.length ? baseSum(array, baseIteratee(iteratee)) : 0;
  }

  function tail(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseSlice(array, 1, length) : [];
  }

  function take(array, n, guard) {
    if (!(array && array.length)) {
      return [];
    }
    n = guard || n === void 0 ? 1 : toInteger(n);
    return baseSlice(array, 0, n < 0 ? 0 : n);
  }

  function takeRight(array, n, guard) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    n = guard || n === void 0 ? 1 : toInteger(n);
    n = length - n;
    return baseSlice(array, n < 0 ? 0 : n, length);
  }

  function takeRightWhile(array, predicate) {
    return array && array.length ? baseWhile(array, baseIteratee(predicate), false, true) : [];
  }

  function takeWhile(array, predicate) {
    return array && array.length ? baseWhile(array, baseIteratee(predicate)) : [];
  }

  function tap(value, interceptor) {
    interceptor(value);
    return value;
  }

  var objectProto$2 = Object.prototype;
  var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
  function customDefaultsAssignIn(objValue, srcValue, key, object) {
    if (objValue === void 0 || eq(objValue, objectProto$2[key]) && !hasOwnProperty$2.call(object, key)) {
      return srcValue;
    }
    return objValue;
  }

  var stringEscapes = {
    "\\": "\\",
    "'": "'",
    "\n": "n",
    "\r": "r",
    "\u2028": "u2028",
    "\u2029": "u2029"
  };
  function escapeStringChar(chr) {
    return "\\" + stringEscapes[chr];
  }

  var reInterpolate = /<%=([\s\S]+?)%>/g;

  var reEscape = /<%-([\s\S]+?)%>/g;

  var reEvaluate = /<%([\s\S]+?)%>/g;

  var templateSettings = {
    "escape": reEscape,
    "evaluate": reEvaluate,
    "interpolate": reInterpolate,
    "variable": "",
    "imports": {
      "_": { "escape": escape }
    }
  };

  var INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
  var reEmptyStringLeading = /\b__p \+= '';/g;
  var reEmptyStringMiddle = /\b(__p \+=) '' \+/g;
  var reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
  var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
  var reNoMatch = /($^)/;
  var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
  var objectProto$1 = Object.prototype;
  var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
  function template(string, options, guard) {
    var settings = templateSettings.imports._.templateSettings || templateSettings;
    if (guard && isIterateeCall(string, options, guard)) {
      options = void 0;
    }
    string = toString(string);
    options = assignInWith({}, options, settings, customDefaultsAssignIn);
    var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
    var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
    var reDelimiters = RegExp((options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$", "g");
    var sourceURL = hasOwnProperty$1.call(options, "sourceURL") ? "//# sourceURL=" + (options.sourceURL + "").replace(/\s/g, " ") + "\n" : "";
    string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
      interpolateValue || (interpolateValue = esTemplateValue);
      source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
      if (escapeValue) {
        isEscaping = true;
        source += "' +\n__e(" + escapeValue + ") +\n'";
      }
      if (evaluateValue) {
        isEvaluating = true;
        source += "';\n" + evaluateValue + ";\n__p += '";
      }
      if (interpolateValue) {
        source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
      }
      index = offset + match.length;
      return match;
    });
    source += "';\n";
    var variable = hasOwnProperty$1.call(options, "variable") && options.variable;
    if (!variable) {
      source = "with (obj) {\n" + source + "\n}\n";
    } else if (reForbiddenIdentifierChars.test(variable)) {
      throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
    }
    source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
    source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
    var result = attempt(function() {
      return Function(importsKeys, sourceURL + "return " + source).apply(void 0, importsValues);
    });
    result.source = source;
    if (isError(result)) {
      throw result;
    }
    return result;
  }

  var FUNC_ERROR_TEXT = "Expected a function";
  function throttle(func, wait, options) {
    var leading = true, trailing = true;
    if (typeof func != "function") {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    if (isObject(options)) {
      leading = "leading" in options ? !!options.leading : leading;
      trailing = "trailing" in options ? !!options.trailing : trailing;
    }
    return debounce(func, wait, {
      "leading": leading,
      "maxWait": wait,
      "trailing": trailing
    });
  }

  function thru(value, interceptor) {
    return interceptor(value);
  }

  var MAX_SAFE_INTEGER$1 = 9007199254740991;
  var MAX_ARRAY_LENGTH$1 = 4294967295;
  var nativeMin$3 = Math.min;
  function times(n, iteratee) {
    n = toInteger(n);
    if (n < 1 || n > MAX_SAFE_INTEGER$1) {
      return [];
    }
    var index = MAX_ARRAY_LENGTH$1, length = nativeMin$3(n, MAX_ARRAY_LENGTH$1);
    iteratee = castFunction(iteratee);
    n -= MAX_ARRAY_LENGTH$1;
    var result = baseTimes(length, iteratee);
    while (++index < n) {
      iteratee(index);
    }
    return result;
  }

  function wrapperToIterator() {
    return this;
  }

  function baseWrapperValue(value, actions) {
    var result = value;
    if (result instanceof LazyWrapper) {
      result = result.value();
    }
    return arrayReduce(actions, function(result2, action) {
      return action.func.apply(action.thisArg, arrayPush([result2], action.args));
    }, result);
  }

  function wrapperValue() {
    return baseWrapperValue(this.__wrapped__, this.__actions__);
  }

  function toLower(value) {
    return toString(value).toLowerCase();
  }

  function toPath(value) {
    if (isArray(value)) {
      return arrayMap(value, toKey);
    }
    return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
  }

  var MAX_SAFE_INTEGER = 9007199254740991;
  function toSafeInteger(value) {
    return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0;
  }

  function toUpper(value) {
    return toString(value).toUpperCase();
  }

  function transform(object, iteratee, accumulator) {
    var isArr = isArray(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object);
    iteratee = baseIteratee(iteratee);
    if (accumulator == null) {
      var Ctor = object && object.constructor;
      if (isArrLike) {
        accumulator = isArr ? new Ctor() : [];
      } else if (isObject(object)) {
        accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
      } else {
        accumulator = {};
      }
    }
    (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) {
      return iteratee(accumulator, value, index, object2);
    });
    return accumulator;
  }

  function charsEndIndex(strSymbols, chrSymbols) {
    var index = strSymbols.length;
    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
    }
    return index;
  }

  function charsStartIndex(strSymbols, chrSymbols) {
    var index = -1, length = strSymbols.length;
    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
    }
    return index;
  }

  function trim(string, chars, guard) {
    string = toString(string);
    if (string && (guard || chars === void 0)) {
      return baseTrim(string);
    }
    if (!string || !(chars = baseToString(chars))) {
      return string;
    }
    var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
    return castSlice(strSymbols, start, end).join("");
  }

  function trimEnd(string, chars, guard) {
    string = toString(string);
    if (string && (guard || chars === void 0)) {
      return string.slice(0, trimmedEndIndex(string) + 1);
    }
    if (!string || !(chars = baseToString(chars))) {
      return string;
    }
    var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
    return castSlice(strSymbols, 0, end).join("");
  }

  var reTrimStart = /^\s+/;
  function trimStart(string, chars, guard) {
    string = toString(string);
    if (string && (guard || chars === void 0)) {
      return string.replace(reTrimStart, "");
    }
    if (!string || !(chars = baseToString(chars))) {
      return string;
    }
    var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars));
    return castSlice(strSymbols, start).join("");
  }

  var DEFAULT_TRUNC_LENGTH = 30;
  var DEFAULT_TRUNC_OMISSION = "...";
  var reFlags = /\w*$/;
  function truncate(string, options) {
    var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
    if (isObject(options)) {
      var separator = "separator" in options ? options.separator : separator;
      length = "length" in options ? toInteger(options.length) : length;
      omission = "omission" in options ? baseToString(options.omission) : omission;
    }
    string = toString(string);
    var strLength = string.length;
    if (hasUnicode(string)) {
      var strSymbols = stringToArray(string);
      strLength = strSymbols.length;
    }
    if (length >= strLength) {
      return string;
    }
    var end = length - stringSize(omission);
    if (end < 1) {
      return omission;
    }
    var result = strSymbols ? castSlice(strSymbols, 0, end).join("") : string.slice(0, end);
    if (separator === void 0) {
      return result + omission;
    }
    if (strSymbols) {
      end += result.length - end;
    }
    if (isRegExp(separator)) {
      if (string.slice(end).search(separator)) {
        var match, substring = result;
        if (!separator.global) {
          separator = RegExp(separator.source, toString(reFlags.exec(separator)) + "g");
        }
        separator.lastIndex = 0;
        while (match = separator.exec(substring)) {
          var newEnd = match.index;
        }
        result = result.slice(0, newEnd === void 0 ? end : newEnd);
      }
    } else if (string.indexOf(baseToString(separator), end) != end) {
      var index = result.lastIndexOf(separator);
      if (index > -1) {
        result = result.slice(0, index);
      }
    }
    return result + omission;
  }

  function unary(func) {
    return ary(func, 1);
  }

  var htmlUnescapes = {
    "&amp;": "&",
    "&lt;": "<",
    "&gt;": ">",
    "&quot;": '"',
    "&#39;": "'"
  };
  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);

  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g;
  var reHasEscapedHtml = RegExp(reEscapedHtml.source);
  function unescape(string) {
    string = toString(string);
    return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;
  }

  var INFINITY = 1 / 0;
  var createSet = !(Set$1 && 1 / setToArray(new Set$1([, -0]))[1] == INFINITY) ? noop : function(values) {
    return new Set$1(values);
  };

  var LARGE_ARRAY_SIZE = 200;
  function baseUniq(array, iteratee, comparator) {
    var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
    if (comparator) {
      isCommon = false;
      includes = arrayIncludesWith;
    } else if (length >= LARGE_ARRAY_SIZE) {
      var set = iteratee ? null : createSet(array);
      if (set) {
        return setToArray(set);
      }
      isCommon = false;
      includes = cacheHas;
      seen = new SetCache();
    } else {
      seen = iteratee ? [] : result;
    }
    outer:
      while (++index < length) {
        var value = array[index], computed = iteratee ? iteratee(value) : value;
        value = comparator || value !== 0 ? value : 0;
        if (isCommon && computed === computed) {
          var seenIndex = seen.length;
          while (seenIndex--) {
            if (seen[seenIndex] === computed) {
              continue outer;
            }
          }
          if (iteratee) {
            seen.push(computed);
          }
          result.push(value);
        } else if (!includes(seen, computed, comparator)) {
          if (seen !== result) {
            seen.push(computed);
          }
          result.push(value);
        }
      }
    return result;
  }

  var union = baseRest(function(arrays) {
    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
  });

  var unionBy = baseRest(function(arrays) {
    var iteratee = last(arrays);
    if (isArrayLikeObject(iteratee)) {
      iteratee = void 0;
    }
    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), baseIteratee(iteratee));
  });

  var unionWith = baseRest(function(arrays) {
    var comparator = last(arrays);
    comparator = typeof comparator == "function" ? comparator : void 0;
    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), void 0, comparator);
  });

  function uniq(array) {
    return array && array.length ? baseUniq(array) : [];
  }

  function uniqBy(array, iteratee) {
    return array && array.length ? baseUniq(array, baseIteratee(iteratee)) : [];
  }

  function uniqWith(array, comparator) {
    comparator = typeof comparator == "function" ? comparator : void 0;
    return array && array.length ? baseUniq(array, void 0, comparator) : [];
  }

  var idCounter = 0;
  function uniqueId(prefix) {
    var id = ++idCounter;
    return toString(prefix) + id;
  }

  function unset(object, path) {
    return object == null ? true : baseUnset(object, path);
  }

  var nativeMax$2 = Math.max;
  function unzip(array) {
    if (!(array && array.length)) {
      return [];
    }
    var length = 0;
    array = arrayFilter(array, function(group) {
      if (isArrayLikeObject(group)) {
        length = nativeMax$2(group.length, length);
        return true;
      }
    });
    return baseTimes(length, function(index) {
      return arrayMap(array, baseProperty(index));
    });
  }

  function unzipWith(array, iteratee) {
    if (!(array && array.length)) {
      return [];
    }
    var result = unzip(array);
    if (iteratee == null) {
      return result;
    }
    return arrayMap(result, function(group) {
      return apply(iteratee, void 0, group);
    });
  }

  function baseUpdate(object, path, updater, customizer) {
    return baseSet(object, path, updater(baseGet(object, path)), customizer);
  }

  function update(object, path, updater) {
    return object == null ? object : baseUpdate(object, path, castFunction(updater));
  }

  function updateWith(object, path, updater, customizer) {
    customizer = typeof customizer == "function" ? customizer : void 0;
    return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
  }

  var upperCase = createCompounder(function(result, word, index) {
    return result + (index ? " " : "") + word.toUpperCase();
  });

  function valuesIn(object) {
    return object == null ? [] : baseValues(object, keysIn(object));
  }

  var without = baseRest(function(array, values) {
    return isArrayLikeObject(array) ? baseDifference(array, values) : [];
  });

  function wrap(value, wrapper) {
    return partial(castFunction(wrapper), value);
  }

  var wrapperAt = flatRest(function(paths) {
    var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object) {
      return baseAt(object, paths);
    };
    if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) {
      return this.thru(interceptor);
    }
    value = value.slice(start, +start + (length ? 1 : 0));
    value.__actions__.push({
      "func": thru,
      "args": [interceptor],
      "thisArg": void 0
    });
    return new LodashWrapper(value, this.__chain__).thru(function(array) {
      if (length && !array.length) {
        array.push(void 0);
      }
      return array;
    });
  });

  function wrapperChain() {
    return chain(this);
  }

  function wrapperReverse() {
    var value = this.__wrapped__;
    if (value instanceof LazyWrapper) {
      var wrapped = value;
      if (this.__actions__.length) {
        wrapped = new LazyWrapper(this);
      }
      wrapped = wrapped.reverse();
      wrapped.__actions__.push({
        "func": thru,
        "args": [reverse],
        "thisArg": void 0
      });
      return new LodashWrapper(wrapped, this.__chain__);
    }
    return this.thru(reverse);
  }

  function baseXor(arrays, iteratee, comparator) {
    var length = arrays.length;
    if (length < 2) {
      return length ? baseUniq(arrays[0]) : [];
    }
    var index = -1, result = Array(length);
    while (++index < length) {
      var array = arrays[index], othIndex = -1;
      while (++othIndex < length) {
        if (othIndex != index) {
          result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
        }
      }
    }
    return baseUniq(baseFlatten(result, 1), iteratee, comparator);
  }

  var xor = baseRest(function(arrays) {
    return baseXor(arrayFilter(arrays, isArrayLikeObject));
  });

  var xorBy = baseRest(function(arrays) {
    var iteratee = last(arrays);
    if (isArrayLikeObject(iteratee)) {
      iteratee = void 0;
    }
    return baseXor(arrayFilter(arrays, isArrayLikeObject), baseIteratee(iteratee));
  });

  var xorWith = baseRest(function(arrays) {
    var comparator = last(arrays);
    comparator = typeof comparator == "function" ? comparator : void 0;
    return baseXor(arrayFilter(arrays, isArrayLikeObject), void 0, comparator);
  });

  var zip = baseRest(unzip);

  function baseZipObject(props, values, assignFunc) {
    var index = -1, length = props.length, valsLength = values.length, result = {};
    while (++index < length) {
      var value = index < valsLength ? values[index] : void 0;
      assignFunc(result, props[index], value);
    }
    return result;
  }

  function zipObject(props, values) {
    return baseZipObject(props || [], values || [], assignValue);
  }

  function zipObjectDeep(props, values) {
    return baseZipObject(props || [], values || [], baseSet);
  }

  var zipWith = baseRest(function(arrays) {
    var length = arrays.length, iteratee = length > 1 ? arrays[length - 1] : void 0;
    iteratee = typeof iteratee == "function" ? (arrays.pop(), iteratee) : void 0;
    return unzipWith(arrays, iteratee);
  });

  var array = {
    chunk,
    compact,
    concat,
    difference,
    differenceBy,
    differenceWith,
    drop,
    dropRight,
    dropRightWhile,
    dropWhile,
    fill,
    findIndex,
    findLastIndex,
    first: head,
    flatten,
    flattenDeep,
    flattenDepth,
    fromPairs,
    head,
    indexOf,
    initial: initial$1,
    intersection,
    intersectionBy,
    intersectionWith,
    join,
    last,
    lastIndexOf,
    nth,
    pull,
    pullAll,
    pullAllBy,
    pullAllWith,
    pullAt,
    remove,
    reverse,
    slice,
    sortedIndex,
    sortedIndexBy,
    sortedIndexOf,
    sortedLastIndex,
    sortedLastIndexBy,
    sortedLastIndexOf,
    sortedUniq,
    sortedUniqBy,
    tail,
    take,
    takeRight,
    takeRightWhile,
    takeWhile,
    union,
    unionBy,
    unionWith,
    uniq,
    uniqBy,
    uniqWith,
    unzip,
    unzipWith,
    without,
    xor,
    xorBy,
    xorWith,
    zip,
    zipObject,
    zipObjectDeep,
    zipWith
  };

  var collection = {
    countBy,
    each: forEach,
    eachRight: forEachRight,
    every,
    filter,
    find,
    findLast,
    flatMap,
    flatMapDeep,
    flatMapDepth,
    forEach,
    forEachRight,
    groupBy,
    includes,
    invokeMap,
    keyBy,
    map,
    orderBy: orderBy$1,
    partition,
    reduce,
    reduceRight,
    reject,
    sample,
    sampleSize,
    shuffle,
    size: size$1,
    some,
    sortBy
  };

  var date = {
    now
  };

  var func = {
    after,
    ary,
    before,
    bind,
    bindKey,
    curry,
    curryRight,
    debounce,
    defer,
    delay,
    flip: flip$2,
    memoize,
    negate,
    once,
    overArgs,
    partial,
    partialRight,
    rearg,
    rest,
    spread,
    throttle,
    unary,
    wrap
  };

  var lang = {
    castArray: castArray$1,
    clone,
    cloneDeep,
    cloneDeepWith,
    cloneWith,
    conformsTo,
    eq,
    gt: gt$1,
    gte,
    isArguments,
    isArray,
    isArrayBuffer,
    isArrayLike,
    isArrayLikeObject,
    isBoolean: isBoolean$1,
    isBuffer,
    isDate,
    isElement: isElement$3,
    isEmpty: isEmpty$1,
    isEqual: isEqual$1,
    isEqualWith,
    isError,
    isFinite,
    isFunction,
    isInteger,
    isLength,
    isMap,
    isMatch,
    isMatchWith,
    isNaN: isNaN$1,
    isNative,
    isNil,
    isNull,
    isNumber: isNumber$1,
    isObject,
    isObjectLike,
    isPlainObject,
    isRegExp,
    isSafeInteger,
    isSet,
    isString,
    isSymbol,
    isTypedArray,
    isUndefined: isUndefined$1,
    isWeakMap,
    isWeakSet,
    lt: lt$1,
    lte,
    toArray,
    toFinite,
    toInteger,
    toLength,
    toNumber,
    toPlainObject,
    toSafeInteger,
    toString
  };

  var math = {
    add,
    ceil,
    divide,
    floor: floor$1,
    max: max$4,
    maxBy,
    mean,
    meanBy,
    min: min$4,
    minBy,
    multiply,
    round: round$2,
    subtract,
    sum: sum$1,
    sumBy
  };

  var number = {
    clamp: clamp$1,
    inRange,
    random
  };

  var object = {
    assign,
    assignIn,
    assignInWith,
    assignWith,
    at: at$1,
    create,
    defaults,
    defaultsDeep,
    entries: toPairs,
    entriesIn: toPairsIn,
    extend: assignIn,
    extendWith: assignInWith,
    findKey,
    findLastKey,
    forIn,
    forInRight,
    forOwn,
    forOwnRight,
    functions,
    functionsIn,
    get,
    has,
    hasIn,
    invert,
    invertBy,
    invoke,
    keys,
    keysIn,
    mapKeys,
    mapValues,
    merge,
    mergeWith,
    omit,
    omitBy,
    pick,
    pickBy,
    result,
    set,
    setWith,
    toPairs,
    toPairsIn,
    transform,
    unset,
    update,
    updateWith,
    values,
    valuesIn
  };

  var seq = {
    at: wrapperAt,
    chain,
    commit: wrapperCommit,
    lodash,
    next: wrapperNext,
    plant: wrapperPlant,
    reverse: wrapperReverse,
    tap,
    thru,
    toIterator: wrapperToIterator,
    toJSON: wrapperValue,
    value: wrapperValue,
    valueOf: wrapperValue,
    wrapperChain
  };

  var string$1 = {
    camelCase,
    capitalize: capitalize$1,
    deburr,
    endsWith,
    escape,
    escapeRegExp,
    kebabCase,
    lowerCase,
    lowerFirst,
    pad,
    padEnd,
    padStart,
    parseInt: parseInt$1,
    repeat,
    replace,
    snakeCase,
    split,
    startCase,
    startsWith,
    template,
    templateSettings,
    toLower,
    toUpper,
    trim,
    trimEnd,
    trimStart,
    truncate,
    unescape,
    upperCase,
    upperFirst,
    words
  };

  var util = {
    attempt,
    bindAll,
    cond,
    conforms,
    constant,
    defaultTo,
    flow,
    flowRight,
    identity,
    iteratee,
    matches,
    matchesProperty,
    method,
    methodOf,
    mixin: mixin$1,
    noop,
    nthArg,
    over,
    overEvery,
    overSome,
    property,
    propertyOf,
    range: range$1,
    rangeRight,
    stubArray,
    stubFalse,
    stubObject,
    stubString,
    stubTrue,
    times,
    toPath,
    uniqueId
  };

  function lazyClone() {
    var result = new LazyWrapper(this.__wrapped__);
    result.__actions__ = copyArray(this.__actions__);
    result.__dir__ = this.__dir__;
    result.__filtered__ = this.__filtered__;
    result.__iteratees__ = copyArray(this.__iteratees__);
    result.__takeCount__ = this.__takeCount__;
    result.__views__ = copyArray(this.__views__);
    return result;
  }

  function lazyReverse() {
    if (this.__filtered__) {
      var result = new LazyWrapper(this);
      result.__dir__ = -1;
      result.__filtered__ = true;
    } else {
      result = this.clone();
      result.__dir__ *= -1;
    }
    return result;
  }

  var nativeMax$1 = Math.max;
  var nativeMin$2 = Math.min;
  function getView(start, end, transforms) {
    var index = -1, length = transforms.length;
    while (++index < length) {
      var data = transforms[index], size = data.size;
      switch (data.type) {
        case "drop":
          start += size;
          break;
        case "dropRight":
          end -= size;
          break;
        case "take":
          end = nativeMin$2(end, start + size);
          break;
        case "takeRight":
          start = nativeMax$1(start, end - size);
          break;
      }
    }
    return { "start": start, "end": end };
  }

  var LAZY_FILTER_FLAG$1 = 1;
  var LAZY_MAP_FLAG = 2;
  var nativeMin$1 = Math.min;
  function lazyValue() {
    var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin$1(length, this.__takeCount__);
    if (!isArr || !isRight && arrLength == length && takeCount == length) {
      return baseWrapperValue(array, this.__actions__);
    }
    var result = [];
    outer:
      while (length-- && resIndex < takeCount) {
        index += dir;
        var iterIndex = -1, value = array[index];
        while (++iterIndex < iterLength) {
          var data = iteratees[iterIndex], iteratee = data.iteratee, type = data.type, computed = iteratee(value);
          if (type == LAZY_MAP_FLAG) {
            value = computed;
          } else if (!computed) {
            if (type == LAZY_FILTER_FLAG$1) {
              continue outer;
            } else {
              break outer;
            }
          }
        }
        result[resIndex++] = value;
      }
    return result;
  }

  var VERSION = "4.17.21";
  var WRAP_BIND_KEY_FLAG = 2;
  var LAZY_FILTER_FLAG = 1;
  var LAZY_WHILE_FLAG = 3;
  var MAX_ARRAY_LENGTH = 4294967295;
  var arrayProto = Array.prototype;
  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;
  var symIterator = Symbol$1 ? Symbol$1.iterator : void 0;
  var nativeMax = Math.max;
  var nativeMin = Math.min;
  var mixin = function(func2) {
    return function(object2, source, options) {
      if (options == null) {
        var isObj = isObject(source), props = isObj && keys(source), methodNames = props && props.length && baseFunctions(source, props);
        if (!(methodNames ? methodNames.length : isObj)) {
          options = source;
          source = object2;
          object2 = this;
        }
      }
      return func2(object2, source, options);
    };
  }(mixin$1);
  lodash.after = func.after;
  lodash.ary = func.ary;
  lodash.assign = object.assign;
  lodash.assignIn = object.assignIn;
  lodash.assignInWith = object.assignInWith;
  lodash.assignWith = object.assignWith;
  lodash.at = object.at;
  lodash.before = func.before;
  lodash.bind = func.bind;
  lodash.bindAll = util.bindAll;
  lodash.bindKey = func.bindKey;
  lodash.castArray = lang.castArray;
  lodash.chain = seq.chain;
  lodash.chunk = array.chunk;
  lodash.compact = array.compact;
  lodash.concat = array.concat;
  lodash.cond = util.cond;
  lodash.conforms = util.conforms;
  lodash.constant = util.constant;
  lodash.countBy = collection.countBy;
  lodash.create = object.create;
  lodash.curry = func.curry;
  lodash.curryRight = func.curryRight;
  lodash.debounce = func.debounce;
  lodash.defaults = object.defaults;
  lodash.defaultsDeep = object.defaultsDeep;
  lodash.defer = func.defer;
  lodash.delay = func.delay;
  lodash.difference = array.difference;
  lodash.differenceBy = array.differenceBy;
  lodash.differenceWith = array.differenceWith;
  lodash.drop = array.drop;
  lodash.dropRight = array.dropRight;
  lodash.dropRightWhile = array.dropRightWhile;
  lodash.dropWhile = array.dropWhile;
  lodash.fill = array.fill;
  lodash.filter = collection.filter;
  lodash.flatMap = collection.flatMap;
  lodash.flatMapDeep = collection.flatMapDeep;
  lodash.flatMapDepth = collection.flatMapDepth;
  lodash.flatten = array.flatten;
  lodash.flattenDeep = array.flattenDeep;
  lodash.flattenDepth = array.flattenDepth;
  lodash.flip = func.flip;
  lodash.flow = util.flow;
  lodash.flowRight = util.flowRight;
  lodash.fromPairs = array.fromPairs;
  lodash.functions = object.functions;
  lodash.functionsIn = object.functionsIn;
  lodash.groupBy = collection.groupBy;
  lodash.initial = array.initial;
  lodash.intersection = array.intersection;
  lodash.intersectionBy = array.intersectionBy;
  lodash.intersectionWith = array.intersectionWith;
  lodash.invert = object.invert;
  lodash.invertBy = object.invertBy;
  lodash.invokeMap = collection.invokeMap;
  lodash.iteratee = util.iteratee;
  lodash.keyBy = collection.keyBy;
  lodash.keys = keys;
  lodash.keysIn = object.keysIn;
  lodash.map = collection.map;
  lodash.mapKeys = object.mapKeys;
  lodash.mapValues = object.mapValues;
  lodash.matches = util.matches;
  lodash.matchesProperty = util.matchesProperty;
  lodash.memoize = func.memoize;
  lodash.merge = object.merge;
  lodash.mergeWith = object.mergeWith;
  lodash.method = util.method;
  lodash.methodOf = util.methodOf;
  lodash.mixin = mixin;
  lodash.negate = negate;
  lodash.nthArg = util.nthArg;
  lodash.omit = object.omit;
  lodash.omitBy = object.omitBy;
  lodash.once = func.once;
  lodash.orderBy = collection.orderBy;
  lodash.over = util.over;
  lodash.overArgs = func.overArgs;
  lodash.overEvery = util.overEvery;
  lodash.overSome = util.overSome;
  lodash.partial = func.partial;
  lodash.partialRight = func.partialRight;
  lodash.partition = collection.partition;
  lodash.pick = object.pick;
  lodash.pickBy = object.pickBy;
  lodash.property = util.property;
  lodash.propertyOf = util.propertyOf;
  lodash.pull = array.pull;
  lodash.pullAll = array.pullAll;
  lodash.pullAllBy = array.pullAllBy;
  lodash.pullAllWith = array.pullAllWith;
  lodash.pullAt = array.pullAt;
  lodash.range = util.range;
  lodash.rangeRight = util.rangeRight;
  lodash.rearg = func.rearg;
  lodash.reject = collection.reject;
  lodash.remove = array.remove;
  lodash.rest = func.rest;
  lodash.reverse = array.reverse;
  lodash.sampleSize = collection.sampleSize;
  lodash.set = object.set;
  lodash.setWith = object.setWith;
  lodash.shuffle = collection.shuffle;
  lodash.slice = array.slice;
  lodash.sortBy = collection.sortBy;
  lodash.sortedUniq = array.sortedUniq;
  lodash.sortedUniqBy = array.sortedUniqBy;
  lodash.split = string$1.split;
  lodash.spread = func.spread;
  lodash.tail = array.tail;
  lodash.take = array.take;
  lodash.takeRight = array.takeRight;
  lodash.takeRightWhile = array.takeRightWhile;
  lodash.takeWhile = array.takeWhile;
  lodash.tap = seq.tap;
  lodash.throttle = func.throttle;
  lodash.thru = thru;
  lodash.toArray = lang.toArray;
  lodash.toPairs = object.toPairs;
  lodash.toPairsIn = object.toPairsIn;
  lodash.toPath = util.toPath;
  lodash.toPlainObject = lang.toPlainObject;
  lodash.transform = object.transform;
  lodash.unary = func.unary;
  lodash.union = array.union;
  lodash.unionBy = array.unionBy;
  lodash.unionWith = array.unionWith;
  lodash.uniq = array.uniq;
  lodash.uniqBy = array.uniqBy;
  lodash.uniqWith = array.uniqWith;
  lodash.unset = object.unset;
  lodash.unzip = array.unzip;
  lodash.unzipWith = array.unzipWith;
  lodash.update = object.update;
  lodash.updateWith = object.updateWith;
  lodash.values = object.values;
  lodash.valuesIn = object.valuesIn;
  lodash.without = array.without;
  lodash.words = string$1.words;
  lodash.wrap = func.wrap;
  lodash.xor = array.xor;
  lodash.xorBy = array.xorBy;
  lodash.xorWith = array.xorWith;
  lodash.zip = array.zip;
  lodash.zipObject = array.zipObject;
  lodash.zipObjectDeep = array.zipObjectDeep;
  lodash.zipWith = array.zipWith;
  lodash.entries = object.toPairs;
  lodash.entriesIn = object.toPairsIn;
  lodash.extend = object.assignIn;
  lodash.extendWith = object.assignInWith;
  mixin(lodash, lodash);
  lodash.add = math.add;
  lodash.attempt = util.attempt;
  lodash.camelCase = string$1.camelCase;
  lodash.capitalize = string$1.capitalize;
  lodash.ceil = math.ceil;
  lodash.clamp = number.clamp;
  lodash.clone = lang.clone;
  lodash.cloneDeep = lang.cloneDeep;
  lodash.cloneDeepWith = lang.cloneDeepWith;
  lodash.cloneWith = lang.cloneWith;
  lodash.conformsTo = lang.conformsTo;
  lodash.deburr = string$1.deburr;
  lodash.defaultTo = util.defaultTo;
  lodash.divide = math.divide;
  lodash.endsWith = string$1.endsWith;
  lodash.eq = lang.eq;
  lodash.escape = string$1.escape;
  lodash.escapeRegExp = string$1.escapeRegExp;
  lodash.every = collection.every;
  lodash.find = collection.find;
  lodash.findIndex = array.findIndex;
  lodash.findKey = object.findKey;
  lodash.findLast = collection.findLast;
  lodash.findLastIndex = array.findLastIndex;
  lodash.findLastKey = object.findLastKey;
  lodash.floor = math.floor;
  lodash.forEach = collection.forEach;
  lodash.forEachRight = collection.forEachRight;
  lodash.forIn = object.forIn;
  lodash.forInRight = object.forInRight;
  lodash.forOwn = object.forOwn;
  lodash.forOwnRight = object.forOwnRight;
  lodash.get = object.get;
  lodash.gt = lang.gt;
  lodash.gte = lang.gte;
  lodash.has = object.has;
  lodash.hasIn = object.hasIn;
  lodash.head = array.head;
  lodash.identity = identity;
  lodash.includes = collection.includes;
  lodash.indexOf = array.indexOf;
  lodash.inRange = number.inRange;
  lodash.invoke = object.invoke;
  lodash.isArguments = lang.isArguments;
  lodash.isArray = isArray;
  lodash.isArrayBuffer = lang.isArrayBuffer;
  lodash.isArrayLike = lang.isArrayLike;
  lodash.isArrayLikeObject = lang.isArrayLikeObject;
  lodash.isBoolean = lang.isBoolean;
  lodash.isBuffer = lang.isBuffer;
  lodash.isDate = lang.isDate;
  lodash.isElement = lang.isElement;
  lodash.isEmpty = lang.isEmpty;
  lodash.isEqual = lang.isEqual;
  lodash.isEqualWith = lang.isEqualWith;
  lodash.isError = lang.isError;
  lodash.isFinite = lang.isFinite;
  lodash.isFunction = lang.isFunction;
  lodash.isInteger = lang.isInteger;
  lodash.isLength = lang.isLength;
  lodash.isMap = lang.isMap;
  lodash.isMatch = lang.isMatch;
  lodash.isMatchWith = lang.isMatchWith;
  lodash.isNaN = lang.isNaN;
  lodash.isNative = lang.isNative;
  lodash.isNil = lang.isNil;
  lodash.isNull = lang.isNull;
  lodash.isNumber = lang.isNumber;
  lodash.isObject = isObject;
  lodash.isObjectLike = lang.isObjectLike;
  lodash.isPlainObject = lang.isPlainObject;
  lodash.isRegExp = lang.isRegExp;
  lodash.isSafeInteger = lang.isSafeInteger;
  lodash.isSet = lang.isSet;
  lodash.isString = lang.isString;
  lodash.isSymbol = lang.isSymbol;
  lodash.isTypedArray = lang.isTypedArray;
  lodash.isUndefined = lang.isUndefined;
  lodash.isWeakMap = lang.isWeakMap;
  lodash.isWeakSet = lang.isWeakSet;
  lodash.join = array.join;
  lodash.kebabCase = string$1.kebabCase;
  lodash.last = last;
  lodash.lastIndexOf = array.lastIndexOf;
  lodash.lowerCase = string$1.lowerCase;
  lodash.lowerFirst = string$1.lowerFirst;
  lodash.lt = lang.lt;
  lodash.lte = lang.lte;
  lodash.max = math.max;
  lodash.maxBy = math.maxBy;
  lodash.mean = math.mean;
  lodash.meanBy = math.meanBy;
  lodash.min = math.min;
  lodash.minBy = math.minBy;
  lodash.stubArray = util.stubArray;
  lodash.stubFalse = util.stubFalse;
  lodash.stubObject = util.stubObject;
  lodash.stubString = util.stubString;
  lodash.stubTrue = util.stubTrue;
  lodash.multiply = math.multiply;
  lodash.nth = array.nth;
  lodash.noop = util.noop;
  lodash.now = date.now;
  lodash.pad = string$1.pad;
  lodash.padEnd = string$1.padEnd;
  lodash.padStart = string$1.padStart;
  lodash.parseInt = string$1.parseInt;
  lodash.random = number.random;
  lodash.reduce = collection.reduce;
  lodash.reduceRight = collection.reduceRight;
  lodash.repeat = string$1.repeat;
  lodash.replace = string$1.replace;
  lodash.result = object.result;
  lodash.round = math.round;
  lodash.sample = collection.sample;
  lodash.size = collection.size;
  lodash.snakeCase = string$1.snakeCase;
  lodash.some = collection.some;
  lodash.sortedIndex = array.sortedIndex;
  lodash.sortedIndexBy = array.sortedIndexBy;
  lodash.sortedIndexOf = array.sortedIndexOf;
  lodash.sortedLastIndex = array.sortedLastIndex;
  lodash.sortedLastIndexBy = array.sortedLastIndexBy;
  lodash.sortedLastIndexOf = array.sortedLastIndexOf;
  lodash.startCase = string$1.startCase;
  lodash.startsWith = string$1.startsWith;
  lodash.subtract = math.subtract;
  lodash.sum = math.sum;
  lodash.sumBy = math.sumBy;
  lodash.template = string$1.template;
  lodash.times = util.times;
  lodash.toFinite = lang.toFinite;
  lodash.toInteger = toInteger;
  lodash.toLength = lang.toLength;
  lodash.toLower = string$1.toLower;
  lodash.toNumber = lang.toNumber;
  lodash.toSafeInteger = lang.toSafeInteger;
  lodash.toString = lang.toString;
  lodash.toUpper = string$1.toUpper;
  lodash.trim = string$1.trim;
  lodash.trimEnd = string$1.trimEnd;
  lodash.trimStart = string$1.trimStart;
  lodash.truncate = string$1.truncate;
  lodash.unescape = string$1.unescape;
  lodash.uniqueId = util.uniqueId;
  lodash.upperCase = string$1.upperCase;
  lodash.upperFirst = string$1.upperFirst;
  lodash.each = collection.forEach;
  lodash.eachRight = collection.forEachRight;
  lodash.first = array.head;
  mixin(lodash, function() {
    var source = {};
    baseForOwn(lodash, function(func2, methodName) {
      if (!hasOwnProperty.call(lodash.prototype, methodName)) {
        source[methodName] = func2;
      }
    });
    return source;
  }(), { "chain": false });
  lodash.VERSION = VERSION;
  (lodash.templateSettings = string$1.templateSettings).imports._ = lodash;
  arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
    lodash[methodName].placeholder = lodash;
  });
  arrayEach(["drop", "take"], function(methodName, index) {
    LazyWrapper.prototype[methodName] = function(n) {
      n = n === void 0 ? 1 : nativeMax(toInteger(n), 0);
      var result = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
      if (result.__filtered__) {
        result.__takeCount__ = nativeMin(n, result.__takeCount__);
      } else {
        result.__views__.push({
          "size": nativeMin(n, MAX_ARRAY_LENGTH),
          "type": methodName + (result.__dir__ < 0 ? "Right" : "")
        });
      }
      return result;
    };
    LazyWrapper.prototype[methodName + "Right"] = function(n) {
      return this.reverse()[methodName](n).reverse();
    };
  });
  arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
    var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
    LazyWrapper.prototype[methodName] = function(iteratee) {
      var result = this.clone();
      result.__iteratees__.push({
        "iteratee": baseIteratee(iteratee),
        "type": type
      });
      result.__filtered__ = result.__filtered__ || isFilter;
      return result;
    };
  });
  arrayEach(["head", "last"], function(methodName, index) {
    var takeName = "take" + (index ? "Right" : "");
    LazyWrapper.prototype[methodName] = function() {
      return this[takeName](1).value()[0];
    };
  });
  arrayEach(["initial", "tail"], function(methodName, index) {
    var dropName = "drop" + (index ? "" : "Right");
    LazyWrapper.prototype[methodName] = function() {
      return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
    };
  });
  LazyWrapper.prototype.compact = function() {
    return this.filter(identity);
  };
  LazyWrapper.prototype.find = function(predicate) {
    return this.filter(predicate).head();
  };
  LazyWrapper.prototype.findLast = function(predicate) {
    return this.reverse().find(predicate);
  };
  LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
    if (typeof path == "function") {
      return new LazyWrapper(this);
    }
    return this.map(function(value) {
      return baseInvoke(value, path, args);
    });
  });
  LazyWrapper.prototype.reject = function(predicate) {
    return this.filter(negate(baseIteratee(predicate)));
  };
  LazyWrapper.prototype.slice = function(start, end) {
    start = toInteger(start);
    var result = this;
    if (result.__filtered__ && (start > 0 || end < 0)) {
      return new LazyWrapper(result);
    }
    if (start < 0) {
      result = result.takeRight(-start);
    } else if (start) {
      result = result.drop(start);
    }
    if (end !== void 0) {
      end = toInteger(end);
      result = end < 0 ? result.dropRight(-end) : result.take(end - start);
    }
    return result;
  };
  LazyWrapper.prototype.takeRightWhile = function(predicate) {
    return this.reverse().takeWhile(predicate).reverse();
  };
  LazyWrapper.prototype.toArray = function() {
    return this.take(MAX_ARRAY_LENGTH);
  };
  baseForOwn(LazyWrapper.prototype, function(func2, methodName) {
    var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
    if (!lodashFunc) {
      return;
    }
    lodash.prototype[methodName] = function() {
      var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee = args[0], useLazy = isLazy || isArray(value);
      var interceptor = function(value2) {
        var result2 = lodashFunc.apply(lodash, arrayPush([value2], args));
        return isTaker && chainAll ? result2[0] : result2;
      };
      if (useLazy && checkIteratee && typeof iteratee == "function" && iteratee.length != 1) {
        isLazy = useLazy = false;
      }
      var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
      if (!retUnwrapped && useLazy) {
        value = onlyLazy ? value : new LazyWrapper(this);
        var result = func2.apply(value, args);
        result.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": void 0 });
        return new LodashWrapper(result, chainAll);
      }
      if (isUnwrapped && onlyLazy) {
        return func2.apply(this, args);
      }
      result = this.thru(interceptor);
      return isUnwrapped ? isTaker ? result.value()[0] : result.value() : result;
    };
  });
  arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
    var func2 = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
    lodash.prototype[methodName] = function() {
      var args = arguments;
      if (retUnwrapped && !this.__chain__) {
        var value = this.value();
        return func2.apply(isArray(value) ? value : [], args);
      }
      return this[chainName](function(value2) {
        return func2.apply(isArray(value2) ? value2 : [], args);
      });
    };
  });
  baseForOwn(LazyWrapper.prototype, function(func2, methodName) {
    var lodashFunc = lodash[methodName];
    if (lodashFunc) {
      var key = lodashFunc.name + "";
      if (!hasOwnProperty.call(realNames, key)) {
        realNames[key] = [];
      }
      realNames[key].push({ "name": methodName, "func": lodashFunc });
    }
  });
  realNames[createHybrid(void 0, WRAP_BIND_KEY_FLAG).name] = [{
    "name": "wrapper",
    "func": void 0
  }];
  LazyWrapper.prototype.clone = lazyClone;
  LazyWrapper.prototype.reverse = lazyReverse;
  LazyWrapper.prototype.value = lazyValue;
  lodash.prototype.at = seq.at;
  lodash.prototype.chain = seq.wrapperChain;
  lodash.prototype.commit = seq.commit;
  lodash.prototype.next = seq.next;
  lodash.prototype.plant = seq.plant;
  lodash.prototype.reverse = seq.reverse;
  lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = seq.value;
  lodash.prototype.first = lodash.prototype.head;
  if (symIterator) {
    lodash.prototype[symIterator] = seq.toIterator;
  }
  /**
   * @license
   * Lodash (Custom Build) <https://lodash.com/>
   * Build: `lodash modularize exports="es" -o ./`
   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
   * Released under MIT license <https://lodash.com/license>
   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   */

  const isUndefined = (val) => val === void 0;
  const isBoolean = (val) => typeof val === "boolean";
  const isNumber = (val) => typeof val === "number";
  const isEmpty = (val) => !val && val !== 0 || isArray$1(val) && val.length === 0 || isObject$1(val) && !Object.keys(val).length;
  const isElement$2 = (e) => {
    if (typeof Element === "undefined")
      return false;
    return e instanceof Element;
  };
  const isPropAbsent = (prop) => isNil(prop);
  const isStringNumber = (val) => {
    if (!isString$1(val)) {
      return false;
    }
    return !Number.isNaN(Number(val));
  };
  const isWindow$1 = (val) => val === window;

  const rAF = (fn) => isClient ? window.requestAnimationFrame(fn) : setTimeout(fn, 16);
  const cAF = (handle) => isClient ? window.cancelAnimationFrame(handle) : clearTimeout(handle);

  const escapeStringRegexp = (string = "") => string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
  const capitalize = (str) => capitalize$2(str);

  const keysOf = (arr) => Object.keys(arr);
  const entriesOf = (arr) => Object.entries(arr);
  const getProp = (obj, path, defaultValue) => {
    return {
      get value() {
        return get(obj, path, defaultValue);
      },
      set value(val) {
        set(obj, path, val);
      }
    };
  };

  class ElementPlusError extends Error {
    constructor(m) {
      super(m);
      this.name = "ElementPlusError";
    }
  }
  function throwError(scope, m) {
    throw new ElementPlusError(`[${scope}] ${m}`);
  }
  function debugWarn(scope, message) {
    const error = isString$1(scope) ? new ElementPlusError(`[${scope}] ${message}`) : scope;
    console.warn(error);
  }

  const SCOPE$9 = "utils/dom/style";
  const classNameToArray = (cls = "") => cls.split(" ").filter((item) => !!item.trim());
  const hasClass = (el, cls) => {
    if (!el || !cls)
      return false;
    if (cls.includes(" "))
      throw new Error("className should not contain space.");
    return el.classList.contains(cls);
  };
  const addClass = (el, cls) => {
    if (!el || !cls.trim())
      return;
    el.classList.add(...classNameToArray(cls));
  };
  const removeClass = (el, cls) => {
    if (!el || !cls.trim())
      return;
    el.classList.remove(...classNameToArray(cls));
  };
  const getStyle = (element, styleName) => {
    var _a;
    if (!isClient || !element || !styleName)
      return "";
    let key = camelize(styleName);
    if (key === "float")
      key = "cssFloat";
    try {
      const style = element.style[key];
      if (style)
        return style;
      const computed = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(element, "");
      return computed ? computed[key] : "";
    } catch (e) {
      return element.style[key];
    }
  };
  const setStyle = (element, styleName, value) => {
    if (!element || !styleName)
      return;
    if (isObject$1(styleName)) {
      entriesOf(styleName).forEach(([prop, value2]) => setStyle(element, prop, value2));
    } else {
      const key = camelize(styleName);
      element.style[key] = value;
    }
  };
  function addUnit(value, defaultUnit = "px") {
    if (!value)
      return "";
    if (isNumber(value) || isStringNumber(value)) {
      return `${value}${defaultUnit}`;
    } else if (isString$1(value)) {
      return value;
    }
    debugWarn(SCOPE$9, "binding value must be a string or number");
  }

  const isScroll = (el, isVertical) => {
    if (!isClient)
      return false;
    const key = {
      undefined: "overflow",
      true: "overflow-y",
      false: "overflow-x"
    }[String(isVertical)];
    const overflow = getStyle(el, key);
    return ["scroll", "auto", "overlay"].some((s) => overflow.includes(s));
  };
  const getScrollContainer = (el, isVertical) => {
    if (!isClient)
      return;
    let parent = el;
    while (parent) {
      if ([window, document, document.documentElement].includes(parent))
        return window;
      if (isScroll(parent, isVertical))
        return parent;
      parent = parent.parentNode;
    }
    return parent;
  };
  let scrollBarWidth;
  const getScrollBarWidth = (namespace) => {
    var _a;
    if (!isClient)
      return 0;
    if (scrollBarWidth !== void 0)
      return scrollBarWidth;
    const outer = document.createElement("div");
    outer.className = `${namespace}-scrollbar__wrap`;
    outer.style.visibility = "hidden";
    outer.style.width = "100px";
    outer.style.position = "absolute";
    outer.style.top = "-9999px";
    document.body.appendChild(outer);
    const widthNoScroll = outer.offsetWidth;
    outer.style.overflow = "scroll";
    const inner = document.createElement("div");
    inner.style.width = "100%";
    outer.appendChild(inner);
    const widthWithScroll = inner.offsetWidth;
    (_a = outer.parentNode) == null ? void 0 : _a.removeChild(outer);
    scrollBarWidth = widthNoScroll - widthWithScroll;
    return scrollBarWidth;
  };
  function scrollIntoView(container, selected) {
    if (!isClient)
      return;
    if (!selected) {
      container.scrollTop = 0;
      return;
    }
    const offsetParents = [];
    let pointer = selected.offsetParent;
    while (pointer !== null && container !== pointer && container.contains(pointer)) {
      offsetParents.push(pointer);
      pointer = pointer.offsetParent;
    }
    const top = selected.offsetTop + offsetParents.reduce((prev, curr) => prev + curr.offsetTop, 0);
    const bottom = top + selected.offsetHeight;
    const viewRectTop = container.scrollTop;
    const viewRectBottom = viewRectTop + container.clientHeight;
    if (top < viewRectTop) {
      container.scrollTop = top;
    } else if (bottom > viewRectBottom) {
      container.scrollTop = bottom - container.clientHeight;
    }
  }
  function animateScrollTo(container, from, to, duration, callback) {
    const startTime = Date.now();
    let handle;
    const scroll = () => {
      const timestamp = Date.now();
      const time = timestamp - startTime;
      const nextScrollTop = easeInOutCubic(time > duration ? duration : time, from, to, duration);
      if (isWindow$1(container)) {
        container.scrollTo(window.pageXOffset, nextScrollTop);
      } else {
        container.scrollTop = nextScrollTop;
      }
      if (time < duration) {
        handle = rAF(scroll);
      } else if (isFunction$1(callback)) {
        callback();
      }
    };
    scroll();
    return () => {
      handle && cAF(handle);
    };
  }
  const getScrollElement = (target, container) => {
    if (isWindow$1(container)) {
      return target.ownerDocument.documentElement;
    }
    return container;
  };
  const getScrollTop = (container) => {
    if (isWindow$1(container)) {
      return window.scrollY;
    }
    return container.scrollTop;
  };

  const getElement = (target) => {
    if (!isClient || target === "")
      return null;
    if (isString$1(target)) {
      try {
        return document.querySelector(target);
      } catch (e) {
        return null;
      }
    }
    return target;
  };

  let target = !isClient ? void 0 : document.body;
  function createGlobalNode(id) {
    const el = document.createElement("div");
    if (id !== void 0) {
      el.setAttribute("id", id);
    }
    if (target) {
      target.appendChild(el);
    }
    return el;
  }
  function removeGlobalNode(el) {
    el.remove();
  }

  var _sfc_main6 = /* @__PURE__ */ vue.defineComponent({
    name: "ArrowDown",
    __name: "arrow-down",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M831.872 340.864 512 652.672 192.128 340.864a30.59 30.59 0 0 0-42.752 0 29.12 29.12 0 0 0 0 41.6L489.664 714.24a32 32 0 0 0 44.672 0l340.288-331.712a29.12 29.12 0 0 0 0-41.728 30.59 30.59 0 0 0-42.752 0z"
        })
      ]));
    }
  });
  var arrow_down_default = _sfc_main6;
  var _sfc_main8 = /* @__PURE__ */ vue.defineComponent({
    name: "ArrowLeft",
    __name: "arrow-left",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M609.408 149.376 277.76 489.6a32 32 0 0 0 0 44.672l331.648 340.352a29.12 29.12 0 0 0 41.728 0 30.59 30.59 0 0 0 0-42.752L339.264 511.936l311.872-319.872a30.59 30.59 0 0 0 0-42.688 29.12 29.12 0 0 0-41.728 0"
        })
      ]));
    }
  });
  var arrow_left_default = _sfc_main8;
  var _sfc_main10 = /* @__PURE__ */ vue.defineComponent({
    name: "ArrowRight",
    __name: "arrow-right",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M340.864 149.312a30.59 30.59 0 0 0 0 42.752L652.736 512 340.864 831.872a30.59 30.59 0 0 0 0 42.752 29.12 29.12 0 0 0 41.728 0L714.24 534.336a32 32 0 0 0 0-44.672L382.592 149.376a29.12 29.12 0 0 0-41.728 0z"
        })
      ]));
    }
  });
  var arrow_right_default = _sfc_main10;
  var _sfc_main12 = /* @__PURE__ */ vue.defineComponent({
    name: "ArrowUp",
    __name: "arrow-up",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m488.832 344.32-339.84 356.672a32 32 0 0 0 0 44.16l.384.384a29.44 29.44 0 0 0 42.688 0l320-335.872 319.872 335.872a29.44 29.44 0 0 0 42.688 0l.384-.384a32 32 0 0 0 0-44.16L535.168 344.32a32 32 0 0 0-46.336 0"
        })
      ]));
    }
  });
  var arrow_up_default = _sfc_main12;
  var _sfc_main14 = /* @__PURE__ */ vue.defineComponent({
    name: "Back",
    __name: "back",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M224 480h640a32 32 0 1 1 0 64H224a32 32 0 0 1 0-64"
        }),
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m237.248 512 265.408 265.344a32 32 0 0 1-45.312 45.312l-288-288a32 32 0 0 1 0-45.312l288-288a32 32 0 1 1 45.312 45.312z"
        })
      ]));
    }
  });
  var back_default = _sfc_main14;
  var _sfc_main29 = /* @__PURE__ */ vue.defineComponent({
    name: "Calendar",
    __name: "calendar",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M128 384v512h768V192H768v32a32 32 0 1 1-64 0v-32H320v32a32 32 0 0 1-64 0v-32H128v128h768v64zm192-256h384V96a32 32 0 1 1 64 0v32h160a32 32 0 0 1 32 32v768a32 32 0 0 1-32 32H96a32 32 0 0 1-32-32V160a32 32 0 0 1 32-32h160V96a32 32 0 0 1 64 0zm-32 384h64a32 32 0 0 1 0 64h-64a32 32 0 0 1 0-64m0 192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64m192-192h64a32 32 0 0 1 0 64h-64a32 32 0 0 1 0-64m0 192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64m192-192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64m0 192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64"
        })
      ]));
    }
  });
  var calendar_default = _sfc_main29;
  var _sfc_main34 = /* @__PURE__ */ vue.defineComponent({
    name: "CaretRight",
    __name: "caret-right",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M384 192v640l384-320.064z"
        })
      ]));
    }
  });
  var caret_right_default = _sfc_main34;
  var _sfc_main35 = /* @__PURE__ */ vue.defineComponent({
    name: "CaretTop",
    __name: "caret-top",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 320 192 704h639.936z"
        })
      ]));
    }
  });
  var caret_top_default = _sfc_main35;
  var _sfc_main43 = /* @__PURE__ */ vue.defineComponent({
    name: "Check",
    __name: "check",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M406.656 706.944 195.84 496.256a32 32 0 1 0-45.248 45.248l256 256 512-512a32 32 0 0 0-45.248-45.248L406.592 706.944z"
        })
      ]));
    }
  });
  var check_default = _sfc_main43;
  var _sfc_main48 = /* @__PURE__ */ vue.defineComponent({
    name: "CircleCheckFilled",
    __name: "circle-check-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896m-55.808 536.384-99.52-99.584a38.4 38.4 0 1 0-54.336 54.336l126.72 126.72a38.27 38.27 0 0 0 54.336 0l262.4-262.464a38.4 38.4 0 1 0-54.272-54.336z"
        })
      ]));
    }
  });
  var circle_check_filled_default = _sfc_main48;
  var _sfc_main49 = /* @__PURE__ */ vue.defineComponent({
    name: "CircleCheck",
    __name: "circle-check",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768m0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896"
        }),
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M745.344 361.344a32 32 0 0 1 45.312 45.312l-288 288a32 32 0 0 1-45.312 0l-160-160a32 32 0 1 1 45.312-45.312L480 626.752z"
        })
      ]));
    }
  });
  var circle_check_default = _sfc_main49;
  var _sfc_main50 = /* @__PURE__ */ vue.defineComponent({
    name: "CircleCloseFilled",
    __name: "circle-close-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896m0 393.664L407.936 353.6a38.4 38.4 0 1 0-54.336 54.336L457.664 512 353.6 616.064a38.4 38.4 0 1 0 54.336 54.336L512 566.336 616.064 670.4a38.4 38.4 0 1 0 54.336-54.336L566.336 512 670.4 407.936a38.4 38.4 0 1 0-54.336-54.336z"
        })
      ]));
    }
  });
  var circle_close_filled_default = _sfc_main50;
  var _sfc_main51 = /* @__PURE__ */ vue.defineComponent({
    name: "CircleClose",
    __name: "circle-close",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m466.752 512-90.496-90.496a32 32 0 0 1 45.248-45.248L512 466.752l90.496-90.496a32 32 0 1 1 45.248 45.248L557.248 512l90.496 90.496a32 32 0 1 1-45.248 45.248L512 557.248l-90.496 90.496a32 32 0 0 1-45.248-45.248z"
        }),
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768m0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896"
        })
      ]));
    }
  });
  var circle_close_default = _sfc_main51;
  var _sfc_main54 = /* @__PURE__ */ vue.defineComponent({
    name: "Clock",
    __name: "clock",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768m0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896"
        }),
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M480 256a32 32 0 0 1 32 32v256a32 32 0 0 1-64 0V288a32 32 0 0 1 32-32"
        }),
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M480 512h256q32 0 32 32t-32 32H480q-32 0-32-32t32-32"
        })
      ]));
    }
  });
  var clock_default = _sfc_main54;
  var _sfc_main56 = /* @__PURE__ */ vue.defineComponent({
    name: "Close",
    __name: "close",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M764.288 214.592 512 466.88 259.712 214.592a31.936 31.936 0 0 0-45.12 45.12L466.752 512 214.528 764.224a31.936 31.936 0 1 0 45.12 45.184L512 557.184l252.288 252.288a31.936 31.936 0 0 0 45.12-45.12L557.12 512.064l252.288-252.352a31.936 31.936 0 1 0-45.12-45.184z"
        })
      ]));
    }
  });
  var close_default = _sfc_main56;
  var _sfc_main72 = /* @__PURE__ */ vue.defineComponent({
    name: "DArrowLeft",
    __name: "d-arrow-left",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M529.408 149.376a29.12 29.12 0 0 1 41.728 0 30.59 30.59 0 0 1 0 42.688L259.264 511.936l311.872 319.936a30.59 30.59 0 0 1-.512 43.264 29.12 29.12 0 0 1-41.216-.512L197.76 534.272a32 32 0 0 1 0-44.672zm256 0a29.12 29.12 0 0 1 41.728 0 30.59 30.59 0 0 1 0 42.688L515.264 511.936l311.872 319.936a30.59 30.59 0 0 1-.512 43.264 29.12 29.12 0 0 1-41.216-.512L453.76 534.272a32 32 0 0 1 0-44.672z"
        })
      ]));
    }
  });
  var d_arrow_left_default = _sfc_main72;
  var _sfc_main73 = /* @__PURE__ */ vue.defineComponent({
    name: "DArrowRight",
    __name: "d-arrow-right",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M452.864 149.312a29.12 29.12 0 0 1 41.728.064L826.24 489.664a32 32 0 0 1 0 44.672L494.592 874.624a29.12 29.12 0 0 1-41.728 0 30.59 30.59 0 0 1 0-42.752L764.736 512 452.864 192a30.59 30.59 0 0 1 0-42.688m-256 0a29.12 29.12 0 0 1 41.728.064L570.24 489.664a32 32 0 0 1 0 44.672L238.592 874.624a29.12 29.12 0 0 1-41.728 0 30.59 30.59 0 0 1 0-42.752L508.736 512 196.864 192a30.59 30.59 0 0 1 0-42.688"
        })
      ]));
    }
  });
  var d_arrow_right_default = _sfc_main73;
  var _sfc_main80 = /* @__PURE__ */ vue.defineComponent({
    name: "Delete",
    __name: "delete",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M160 256H96a32 32 0 0 1 0-64h256V95.936a32 32 0 0 1 32-32h256a32 32 0 0 1 32 32V192h256a32 32 0 1 1 0 64h-64v672a32 32 0 0 1-32 32H192a32 32 0 0 1-32-32zm448-64v-64H416v64zM224 896h576V256H224zm192-128a32 32 0 0 1-32-32V416a32 32 0 0 1 64 0v320a32 32 0 0 1-32 32m192 0a32 32 0 0 1-32-32V416a32 32 0 0 1 64 0v320a32 32 0 0 1-32 32"
        })
      ]));
    }
  });
  var delete_default = _sfc_main80;
  var _sfc_main90 = /* @__PURE__ */ vue.defineComponent({
    name: "Document",
    __name: "document",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M832 384H576V128H192v768h640zm-26.496-64L640 154.496V320zM160 64h480l256 256v608a32 32 0 0 1-32 32H160a32 32 0 0 1-32-32V96a32 32 0 0 1 32-32m160 448h384v64H320zm0-192h160v64H320zm0 384h384v64H320z"
        })
      ]));
    }
  });
  var document_default = _sfc_main90;
  var _sfc_main118 = /* @__PURE__ */ vue.defineComponent({
    name: "FullScreen",
    __name: "full-screen",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m160 96.064 192 .192a32 32 0 0 1 0 64l-192-.192V352a32 32 0 0 1-64 0V96h64zm0 831.872V928H96V672a32 32 0 1 1 64 0v191.936l192-.192a32 32 0 1 1 0 64zM864 96.064V96h64v256a32 32 0 1 1-64 0V160.064l-192 .192a32 32 0 1 1 0-64zm0 831.872-192-.192a32 32 0 0 1 0-64l192 .192V672a32 32 0 1 1 64 0v256h-64z"
        })
      ]));
    }
  });
  var full_screen_default = _sfc_main118;
  var _sfc_main133 = /* @__PURE__ */ vue.defineComponent({
    name: "Hide",
    __name: "hide",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M876.8 156.8c0-9.6-3.2-16-9.6-22.4s-12.8-9.6-22.4-9.6-16 3.2-22.4 9.6L736 220.8c-64-32-137.6-51.2-224-60.8-160 16-288 73.6-377.6 176S0 496 0 512s48 73.6 134.4 176c22.4 25.6 44.8 48 73.6 67.2l-86.4 89.6c-6.4 6.4-9.6 12.8-9.6 22.4s3.2 16 9.6 22.4 12.8 9.6 22.4 9.6 16-3.2 22.4-9.6l704-710.4c3.2-6.4 6.4-12.8 6.4-22.4m-646.4 528Q115.2 579.2 76.8 512q43.2-72 153.6-172.8C304 272 400 230.4 512 224c64 3.2 124.8 19.2 176 44.8l-54.4 54.4C598.4 300.8 560 288 512 288c-64 0-115.2 22.4-160 64s-64 96-64 160c0 48 12.8 89.6 35.2 124.8L256 707.2c-9.6-6.4-19.2-16-25.6-22.4m140.8-96Q352 555.2 352 512c0-44.8 16-83.2 48-112s67.2-48 112-48c28.8 0 54.4 6.4 73.6 19.2zM889.599 336c-12.8-16-28.8-28.8-41.6-41.6l-48 48c73.6 67.2 124.8 124.8 150.4 169.6q-43.2 72-153.6 172.8c-73.6 67.2-172.8 108.8-284.8 115.2-51.2-3.2-99.2-12.8-140.8-28.8l-48 48c57.6 22.4 118.4 38.4 188.8 44.8 160-16 288-73.6 377.6-176S1024 528 1024 512s-48.001-73.6-134.401-176"
        }),
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M511.998 672c-12.8 0-25.6-3.2-38.4-6.4l-51.2 51.2c28.8 12.8 57.6 19.2 89.6 19.2 64 0 115.2-22.4 160-64 41.6-41.6 64-96 64-160 0-32-6.4-64-19.2-89.6l-51.2 51.2c3.2 12.8 6.4 25.6 6.4 38.4 0 44.8-16 83.2-48 112s-67.2 48-112 48"
        })
      ]));
    }
  });
  var hide_default = _sfc_main133;
  var _sfc_main143 = /* @__PURE__ */ vue.defineComponent({
    name: "InfoFilled",
    __name: "info-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 64a448 448 0 1 1 0 896.064A448 448 0 0 1 512 64m67.2 275.072c33.28 0 60.288-23.104 60.288-57.344s-27.072-57.344-60.288-57.344c-33.28 0-60.16 23.104-60.16 57.344s26.88 57.344 60.16 57.344M590.912 699.2c0-6.848 2.368-24.64 1.024-34.752l-52.608 60.544c-10.88 11.456-24.512 19.392-30.912 17.28a12.99 12.99 0 0 1-8.256-14.72l87.68-276.992c7.168-35.136-12.544-67.2-54.336-71.296-44.096 0-108.992 44.736-148.48 101.504 0 6.784-1.28 23.68.064 33.792l52.544-60.608c10.88-11.328 23.552-19.328 29.952-17.152a12.8 12.8 0 0 1 7.808 16.128L388.48 728.576c-10.048 32.256 8.96 63.872 55.04 71.04 67.84 0 107.904-43.648 147.456-100.416z"
        })
      ]));
    }
  });
  var info_filled_default = _sfc_main143;
  var _sfc_main150 = /* @__PURE__ */ vue.defineComponent({
    name: "Loading",
    __name: "loading",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 64a32 32 0 0 1 32 32v192a32 32 0 0 1-64 0V96a32 32 0 0 1 32-32m0 640a32 32 0 0 1 32 32v192a32 32 0 1 1-64 0V736a32 32 0 0 1 32-32m448-192a32 32 0 0 1-32 32H736a32 32 0 1 1 0-64h192a32 32 0 0 1 32 32m-640 0a32 32 0 0 1-32 32H96a32 32 0 0 1 0-64h192a32 32 0 0 1 32 32M195.2 195.2a32 32 0 0 1 45.248 0L376.32 331.008a32 32 0 0 1-45.248 45.248L195.2 240.448a32 32 0 0 1 0-45.248m452.544 452.544a32 32 0 0 1 45.248 0L828.8 783.552a32 32 0 0 1-45.248 45.248L647.744 692.992a32 32 0 0 1 0-45.248M828.8 195.264a32 32 0 0 1 0 45.184L692.992 376.32a32 32 0 0 1-45.248-45.248l135.808-135.808a32 32 0 0 1 45.248 0m-452.544 452.48a32 32 0 0 1 0 45.248L240.448 828.8a32 32 0 0 1-45.248-45.248l135.808-135.808a32 32 0 0 1 45.248 0"
        })
      ]));
    }
  });
  var loading_default = _sfc_main150;
  var _sfc_main169 = /* @__PURE__ */ vue.defineComponent({
    name: "Minus",
    __name: "minus",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M128 544h768a32 32 0 1 0 0-64H128a32 32 0 0 0 0 64"
        })
      ]));
    }
  });
  var minus_default = _sfc_main169;
  var _sfc_main174 = /* @__PURE__ */ vue.defineComponent({
    name: "MoreFilled",
    __name: "more-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M176 416a112 112 0 1 1 0 224 112 112 0 0 1 0-224m336 0a112 112 0 1 1 0 224 112 112 0 0 1 0-224m336 0a112 112 0 1 1 0 224 112 112 0 0 1 0-224"
        })
      ]));
    }
  });
  var more_filled_default = _sfc_main174;
  var _sfc_main175 = /* @__PURE__ */ vue.defineComponent({
    name: "More",
    __name: "more",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M176 416a112 112 0 1 0 0 224 112 112 0 0 0 0-224m0 64a48 48 0 1 1 0 96 48 48 0 0 1 0-96m336-64a112 112 0 1 1 0 224 112 112 0 0 1 0-224m0 64a48 48 0 1 0 0 96 48 48 0 0 0 0-96m336-64a112 112 0 1 1 0 224 112 112 0 0 1 0-224m0 64a48 48 0 1 0 0 96 48 48 0 0 0 0-96"
        })
      ]));
    }
  });
  var more_default = _sfc_main175;
  var _sfc_main195 = /* @__PURE__ */ vue.defineComponent({
    name: "PictureFilled",
    __name: "picture-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M96 896a32 32 0 0 1-32-32V160a32 32 0 0 1 32-32h832a32 32 0 0 1 32 32v704a32 32 0 0 1-32 32zm315.52-228.48-68.928-68.928a32 32 0 0 0-45.248 0L128 768.064h778.688l-242.112-290.56a32 32 0 0 0-49.216 0L458.752 665.408a32 32 0 0 1-47.232 2.112M256 384a96 96 0 1 0 192.064-.064A96 96 0 0 0 256 384"
        })
      ]));
    }
  });
  var picture_filled_default = _sfc_main195;
  var _sfc_main201 = /* @__PURE__ */ vue.defineComponent({
    name: "Plus",
    __name: "plus",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M480 480V128a32 32 0 0 1 64 0v352h352a32 32 0 1 1 0 64H544v352a32 32 0 1 1-64 0V544H128a32 32 0 0 1 0-64z"
        })
      ]));
    }
  });
  var plus_default = _sfc_main201;
  var _sfc_main211 = /* @__PURE__ */ vue.defineComponent({
    name: "QuestionFilled",
    __name: "question-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896m23.744 191.488c-52.096 0-92.928 14.784-123.2 44.352-30.976 29.568-45.76 70.4-45.76 122.496h80.256c0-29.568 5.632-52.8 17.6-68.992 13.376-19.712 35.2-28.864 66.176-28.864 23.936 0 42.944 6.336 56.32 19.712 12.672 13.376 19.712 31.68 19.712 54.912 0 17.6-6.336 34.496-19.008 49.984l-8.448 9.856c-45.76 40.832-73.216 70.4-82.368 89.408-9.856 19.008-14.08 42.24-14.08 68.992v9.856h80.96v-9.856c0-16.896 3.52-31.68 10.56-45.76 6.336-12.672 15.488-24.64 28.16-35.2 33.792-29.568 54.208-48.576 60.544-55.616 16.896-22.528 26.048-51.392 26.048-86.592q0-64.416-42.24-101.376c-28.16-25.344-65.472-37.312-111.232-37.312m-12.672 406.208a54.27 54.27 0 0 0-38.72 14.784 49.4 49.4 0 0 0-15.488 38.016c0 15.488 4.928 28.16 15.488 38.016A54.85 54.85 0 0 0 523.072 768c15.488 0 28.16-4.928 38.72-14.784a51.52 51.52 0 0 0 16.192-38.72 51.97 51.97 0 0 0-15.488-38.016 55.94 55.94 0 0 0-39.424-14.784"
        })
      ]));
    }
  });
  var question_filled_default = _sfc_main211;
  var _sfc_main215 = /* @__PURE__ */ vue.defineComponent({
    name: "RefreshLeft",
    __name: "refresh-left",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M289.088 296.704h92.992a32 32 0 0 1 0 64H232.96a32 32 0 0 1-32-32V179.712a32 32 0 0 1 64 0v50.56a384 384 0 0 1 643.84 282.88 384 384 0 0 1-383.936 384 384 384 0 0 1-384-384h64a320 320 0 1 0 640 0 320 320 0 0 0-555.712-216.448z"
        })
      ]));
    }
  });
  var refresh_left_default = _sfc_main215;
  var _sfc_main216 = /* @__PURE__ */ vue.defineComponent({
    name: "RefreshRight",
    __name: "refresh-right",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M784.512 230.272v-50.56a32 32 0 1 1 64 0v149.056a32 32 0 0 1-32 32H667.52a32 32 0 1 1 0-64h92.992A320 320 0 1 0 524.8 833.152a320 320 0 0 0 320-320h64a384 384 0 0 1-384 384 384 384 0 0 1-384-384 384 384 0 0 1 643.712-282.88"
        })
      ]));
    }
  });
  var refresh_right_default = _sfc_main216;
  var _sfc_main222 = /* @__PURE__ */ vue.defineComponent({
    name: "ScaleToOriginal",
    __name: "scale-to-original",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M813.176 180.706a60.235 60.235 0 0 1 60.236 60.235v481.883a60.235 60.235 0 0 1-60.236 60.235H210.824a60.235 60.235 0 0 1-60.236-60.235V240.94a60.235 60.235 0 0 1 60.236-60.235h602.352zm0-60.235H210.824A120.47 120.47 0 0 0 90.353 240.94v481.883a120.47 120.47 0 0 0 120.47 120.47h602.353a120.47 120.47 0 0 0 120.471-120.47V240.94a120.47 120.47 0 0 0-120.47-120.47zm-120.47 180.705a30.12 30.12 0 0 0-30.118 30.118v301.177a30.118 30.118 0 0 0 60.236 0V331.294a30.12 30.12 0 0 0-30.118-30.118m-361.412 0a30.12 30.12 0 0 0-30.118 30.118v301.177a30.118 30.118 0 1 0 60.236 0V331.294a30.12 30.12 0 0 0-30.118-30.118M512 361.412a30.12 30.12 0 0 0-30.118 30.117v30.118a30.118 30.118 0 0 0 60.236 0V391.53A30.12 30.12 0 0 0 512 361.412M512 512a30.12 30.12 0 0 0-30.118 30.118v30.117a30.118 30.118 0 0 0 60.236 0v-30.117A30.12 30.12 0 0 0 512 512"
        })
      ]));
    }
  });
  var scale_to_original_default = _sfc_main222;
  var _sfc_main225 = /* @__PURE__ */ vue.defineComponent({
    name: "Search",
    __name: "search",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m795.904 750.72 124.992 124.928a32 32 0 0 1-45.248 45.248L750.656 795.904a416 416 0 1 1 45.248-45.248zM480 832a352 352 0 1 0 0-704 352 352 0 0 0 0 704"
        })
      ]));
    }
  });
  var search_default = _sfc_main225;
  var _sfc_main242 = /* @__PURE__ */ vue.defineComponent({
    name: "SortDown",
    __name: "sort-down",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M576 96v709.568L333.312 562.816A32 32 0 1 0 288 608l297.408 297.344A32 32 0 0 0 640 882.688V96a32 32 0 0 0-64 0"
        })
      ]));
    }
  });
  var sort_down_default = _sfc_main242;
  var _sfc_main243 = /* @__PURE__ */ vue.defineComponent({
    name: "SortUp",
    __name: "sort-up",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M384 141.248V928a32 32 0 1 0 64 0V218.56l242.688 242.688A32 32 0 1 0 736 416L438.592 118.656A32 32 0 0 0 384 141.248"
        })
      ]));
    }
  });
  var sort_up_default = _sfc_main243;
  var _sfc_main246 = /* @__PURE__ */ vue.defineComponent({
    name: "StarFilled",
    __name: "star-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M313.6 924.48a70.4 70.4 0 0 1-74.152-5.365 70.4 70.4 0 0 1-27.992-68.875l37.888-220.928L88.96 472.96a70.4 70.4 0 0 1 3.788-104.225A70.4 70.4 0 0 1 128 352.896l221.76-32.256 99.2-200.96a70.4 70.4 0 0 1 100.246-28.595 70.4 70.4 0 0 1 25.962 28.595l99.2 200.96 221.824 32.256a70.4 70.4 0 0 1 39.04 120.064L774.72 629.376l37.888 220.928a70.4 70.4 0 0 1-102.144 74.24L512 820.096l-198.4 104.32z"
        })
      ]));
    }
  });
  var star_filled_default = _sfc_main246;
  var _sfc_main247 = /* @__PURE__ */ vue.defineComponent({
    name: "Star",
    __name: "star",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m512 747.84 228.16 119.936a6.4 6.4 0 0 0 9.28-6.72l-43.52-254.08 184.512-179.904a6.4 6.4 0 0 0-3.52-10.88l-255.104-37.12L517.76 147.904a6.4 6.4 0 0 0-11.52 0L392.192 379.072l-255.104 37.12a6.4 6.4 0 0 0-3.52 10.88L318.08 606.976l-43.584 254.08a6.4 6.4 0 0 0 9.28 6.72zM313.6 924.48a70.4 70.4 0 0 1-102.144-74.24l37.888-220.928L88.96 472.96A70.4 70.4 0 0 1 128 352.896l221.76-32.256 99.2-200.96a70.4 70.4 0 0 1 126.208 0l99.2 200.96 221.824 32.256a70.4 70.4 0 0 1 39.04 120.064L774.72 629.376l37.888 220.928a70.4 70.4 0 0 1-102.144 74.24L512 820.096l-198.4 104.32z"
        })
      ]));
    }
  });
  var star_default = _sfc_main247;
  var _sfc_main249 = /* @__PURE__ */ vue.defineComponent({
    name: "SuccessFilled",
    __name: "success-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896m-55.808 536.384-99.52-99.584a38.4 38.4 0 1 0-54.336 54.336l126.72 126.72a38.27 38.27 0 0 0 54.336 0l262.4-262.464a38.4 38.4 0 1 0-54.272-54.336z"
        })
      ]));
    }
  });
  var success_filled_default = _sfc_main249;
  var _sfc_main283 = /* @__PURE__ */ vue.defineComponent({
    name: "View",
    __name: "view",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 160c320 0 512 352 512 352S832 864 512 864 0 512 0 512s192-352 512-352m0 64c-225.28 0-384.128 208.064-436.8 288 52.608 79.872 211.456 288 436.8 288 225.28 0 384.128-208.064 436.8-288-52.608-79.872-211.456-288-436.8-288m0 64a224 224 0 1 1 0 448 224 224 0 0 1 0-448m0 64a160.19 160.19 0 0 0-160 160c0 88.192 71.744 160 160 160s160-71.808 160-160-71.744-160-160-160"
        })
      ]));
    }
  });
  var view_default = _sfc_main283;
  var _sfc_main287 = /* @__PURE__ */ vue.defineComponent({
    name: "WarningFilled",
    __name: "warning-filled",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896m0 192a58.43 58.43 0 0 0-58.24 63.744l23.36 256.384a35.072 35.072 0 0 0 69.76 0l23.296-256.384A58.43 58.43 0 0 0 512 256m0 512a51.2 51.2 0 1 0 0-102.4 51.2 51.2 0 0 0 0 102.4"
        })
      ]));
    }
  });
  var warning_filled_default = _sfc_main287;
  var _sfc_main292 = /* @__PURE__ */ vue.defineComponent({
    name: "ZoomIn",
    __name: "zoom-in",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m795.904 750.72 124.992 124.928a32 32 0 0 1-45.248 45.248L750.656 795.904a416 416 0 1 1 45.248-45.248zM480 832a352 352 0 1 0 0-704 352 352 0 0 0 0 704m-32-384v-96a32 32 0 0 1 64 0v96h96a32 32 0 0 1 0 64h-96v96a32 32 0 0 1-64 0v-96h-96a32 32 0 0 1 0-64z"
        })
      ]));
    }
  });
  var zoom_in_default = _sfc_main292;
  var _sfc_main293 = /* @__PURE__ */ vue.defineComponent({
    name: "ZoomOut",
    __name: "zoom-out",
    setup(__props) {
      return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
        xmlns: "http://www.w3.org/2000/svg",
        viewBox: "0 0 1024 1024"
      }, [
        vue.createElementVNode("path", {
          fill: "currentColor",
          d: "m795.904 750.72 124.992 124.928a32 32 0 0 1-45.248 45.248L750.656 795.904a416 416 0 1 1 45.248-45.248zM480 832a352 352 0 1 0 0-704 352 352 0 0 0 0 704M352 448h256a32 32 0 0 1 0 64H352a32 32 0 0 1 0-64"
        })
      ]));
    }
  });
  var zoom_out_default = _sfc_main293;
  /*! Element Plus Icons Vue v2.3.2 */

  const epPropKey = "__epPropKey";
  const definePropType = (val) => val;
  const isEpProp = (val) => isObject$1(val) && !!val[epPropKey];
  const buildProp = (prop, key) => {
    if (!isObject$1(prop) || isEpProp(prop))
      return prop;
    const { values, required, default: defaultValue, type, validator } = prop;
    const _validator = values || validator ? (val) => {
      let valid = false;
      let allowedValues = [];
      if (values) {
        allowedValues = Array.from(values);
        if (hasOwn(prop, "default")) {
          allowedValues.push(defaultValue);
        }
        valid || (valid = allowedValues.includes(val));
      }
      if (validator)
        valid || (valid = validator(val));
      if (!valid && allowedValues.length > 0) {
        const allowValuesText = [...new Set(allowedValues)].map((value) => JSON.stringify(value)).join(", ");
        vue.warn(`Invalid prop: validation failed${key ? ` for prop "${key}"` : ""}. Expected one of [${allowValuesText}], got value ${JSON.stringify(val)}.`);
      }
      return valid;
    } : void 0;
    const epProp = {
      type,
      required: !!required,
      validator: _validator,
      [epPropKey]: true
    };
    if (hasOwn(prop, "default"))
      epProp.default = defaultValue;
    return epProp;
  };
  const buildProps = (props) => fromPairs(Object.entries(props).map(([key, option]) => [
    key,
    buildProp(option, key)
  ]));

  const iconPropType = definePropType([
    String,
    Object,
    Function
  ]);
  const CloseComponents = {
    Close: close_default
  };
  const TypeComponents = {
    Close: close_default,
    SuccessFilled: success_filled_default,
    InfoFilled: info_filled_default,
    WarningFilled: warning_filled_default,
    CircleCloseFilled: circle_close_filled_default
  };
  const TypeComponentsMap = {
    primary: info_filled_default,
    success: success_filled_default,
    warning: warning_filled_default,
    error: circle_close_filled_default,
    info: info_filled_default
  };
  const ValidateComponentsMap = {
    validating: loading_default,
    success: circle_check_default,
    error: circle_close_default
  };

  const withInstall = (main, extra) => {
    main.install = (app) => {
      for (const comp of [main, ...Object.values(extra != null ? extra : {})]) {
        app.component(comp.name, comp);
      }
    };
    if (extra) {
      for (const [key, comp] of Object.entries(extra)) {
        main[key] = comp;
      }
    }
    return main;
  };
  const withInstallFunction = (fn, name) => {
    fn.install = (app) => {
      fn._context = app._context;
      app.config.globalProperties[name] = fn;
    };
    return fn;
  };
  const withInstallDirective = (directive, name) => {
    directive.install = (app) => {
      app.directive(name, directive);
    };
    return directive;
  };
  const withNoopInstall = (component) => {
    component.install = NOOP;
    return component;
  };

  const composeRefs = (...refs) => {
    return (el) => {
      refs.forEach((ref) => {
        ref.value = el;
      });
    };
  };

  const isValidComponentSize = (val) => ["", ...componentSizes].includes(val);

  const SCOPE$8 = "utils/vue/vnode";
  var PatchFlags = /* @__PURE__ */ ((PatchFlags2) => {
    PatchFlags2[PatchFlags2["TEXT"] = 1] = "TEXT";
    PatchFlags2[PatchFlags2["CLASS"] = 2] = "CLASS";
    PatchFlags2[PatchFlags2["STYLE"] = 4] = "STYLE";
    PatchFlags2[PatchFlags2["PROPS"] = 8] = "PROPS";
    PatchFlags2[PatchFlags2["FULL_PROPS"] = 16] = "FULL_PROPS";
    PatchFlags2[PatchFlags2["HYDRATE_EVENTS"] = 32] = "HYDRATE_EVENTS";
    PatchFlags2[PatchFlags2["STABLE_FRAGMENT"] = 64] = "STABLE_FRAGMENT";
    PatchFlags2[PatchFlags2["KEYED_FRAGMENT"] = 128] = "KEYED_FRAGMENT";
    PatchFlags2[PatchFlags2["UNKEYED_FRAGMENT"] = 256] = "UNKEYED_FRAGMENT";
    PatchFlags2[PatchFlags2["NEED_PATCH"] = 512] = "NEED_PATCH";
    PatchFlags2[PatchFlags2["DYNAMIC_SLOTS"] = 1024] = "DYNAMIC_SLOTS";
    PatchFlags2[PatchFlags2["HOISTED"] = -1] = "HOISTED";
    PatchFlags2[PatchFlags2["BAIL"] = -2] = "BAIL";
    return PatchFlags2;
  })(PatchFlags || {});
  function isFragment(node) {
    return vue.isVNode(node) && node.type === vue.Fragment;
  }
  function isComment(node) {
    return vue.isVNode(node) && node.type === vue.Comment;
  }
  function isValidElementNode(node) {
    return vue.isVNode(node) && !isFragment(node) && !isComment(node);
  }
  const getNormalizedProps = (node) => {
    if (!vue.isVNode(node)) {
      debugWarn(SCOPE$8, "[getNormalizedProps] must be a VNode");
      return {};
    }
    const raw = node.props || {};
    const type = (vue.isVNode(node.type) ? node.type.props : void 0) || {};
    const props = {};
    Object.keys(type).forEach((key) => {
      if (hasOwn(type[key], "default")) {
        props[key] = type[key].default;
      }
    });
    Object.keys(raw).forEach((key) => {
      props[camelize(key)] = raw[key];
    });
    return props;
  };
  const flattedChildren = (children) => {
    const vNodes = isArray$1(children) ? children : [children];
    const result = [];
    vNodes.forEach((child) => {
      var _a;
      if (isArray$1(child)) {
        result.push(...flattedChildren(child));
      } else if (vue.isVNode(child) && ((_a = child.component) == null ? void 0 : _a.subTree)) {
        result.push(child, ...flattedChildren(child.component.subTree));
      } else if (vue.isVNode(child) && isArray$1(child.children)) {
        result.push(...flattedChildren(child.children));
      } else if (vue.isVNode(child) && child.shapeFlag === 2) {
        result.push(...flattedChildren(child.type()));
      } else {
        result.push(child);
      }
    });
    return result;
  };

  const unique = (arr) => [...new Set(arr)];
  const extractFirst = (arr) => {
    return isArray$1(arr) ? arr[0] : arr;
  };
  const castArray = (arr) => {
    if (!arr && arr !== 0)
      return [];
    return isArray$1(arr) ? arr : [arr];
  };

  const isKorean = (text) => /([\uAC00-\uD7AF\u3130-\u318F])+/gi.test(text);

  const mutable = (val) => val;

  function throttleByRaf(cb) {
    let timer = 0;
    const throttle = (...args) => {
      if (timer) {
        cAF(timer);
      }
      timer = rAF(() => {
        cb(...args);
        timer = 0;
      });
    };
    throttle.cancel = () => {
      cAF(timer);
      timer = 0;
    };
    return throttle;
  }

  const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
  const LISTENER_PREFIX = /^on[A-Z]/;
  const useAttrs = (params = {}) => {
    const { excludeListeners = false, excludeKeys } = params;
    const allExcludeKeys = vue.computed(() => {
      return ((excludeKeys == null ? void 0 : excludeKeys.value) || []).concat(DEFAULT_EXCLUDE_KEYS);
    });
    const instance = vue.getCurrentInstance();
    if (!instance) {
      debugWarn("use-attrs", "getCurrentInstance() returned null. useAttrs() must be called at the top of a setup function");
      return vue.computed(() => ({}));
    }
    return vue.computed(() => {
      var _a;
      return fromPairs(Object.entries((_a = instance.proxy) == null ? void 0 : _a.$attrs).filter(([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
    });
  };

  function useCalcInputWidth() {
    const calculatorRef = vue.shallowRef();
    const calculatorWidth = vue.ref(0);
    const inputStyle = vue.computed(() => ({
      minWidth: `${Math.max(calculatorWidth.value, MINIMUM_INPUT_WIDTH)}px`
    }));
    const resetCalculatorWidth = () => {
      var _a, _b;
      calculatorWidth.value = (_b = (_a = calculatorRef.value) == null ? void 0 : _a.getBoundingClientRect().width) != null ? _b : 0;
    };
    useResizeObserver(calculatorRef, resetCalculatorWidth);
    return {
      calculatorRef,
      calculatorWidth,
      inputStyle
    };
  }

  const useDeprecated = ({ from, replacement, scope, version, ref, type = "API" }, condition) => {
    vue.watch(() => vue.unref(condition), (val) => {
      if (val) {
        debugWarn(scope, `[${type}] ${from} is about to be deprecated in version ${version}, please use ${replacement} instead.
For more detail, please visit: ${ref}
`);
      }
    }, {
      immediate: true
    });
  };

  const useDraggable = (targetRef, dragRef, draggable, overflow) => {
    const transform = {
      offsetX: 0,
      offsetY: 0
    };
    const isDragging = vue.ref(false);
    const adjustPosition = (moveX, moveY) => {
      if (targetRef.value) {
        const { offsetX, offsetY } = transform;
        const targetRect = targetRef.value.getBoundingClientRect();
        const targetLeft = targetRect.left;
        const targetTop = targetRect.top;
        const targetWidth = targetRect.width;
        const targetHeight = targetRect.height;
        const clientWidth = document.documentElement.clientWidth;
        const clientHeight = document.documentElement.clientHeight;
        const minLeft = -targetLeft + offsetX;
        const minTop = -targetTop + offsetY;
        const maxLeft = clientWidth - targetLeft - targetWidth + offsetX;
        const maxTop = clientHeight - targetTop - (targetHeight < clientHeight ? targetHeight : 0) + offsetY;
        if (!(overflow == null ? void 0 : overflow.value)) {
          moveX = Math.min(Math.max(moveX, minLeft), maxLeft);
          moveY = Math.min(Math.max(moveY, minTop), maxTop);
        }
        transform.offsetX = moveX;
        transform.offsetY = moveY;
        targetRef.value.style.transform = `translate(${addUnit(moveX)}, ${addUnit(moveY)})`;
      }
    };
    const onMousedown = (e) => {
      const downX = e.clientX;
      const downY = e.clientY;
      const { offsetX, offsetY } = transform;
      const onMousemove = (e2) => {
        if (!isDragging.value) {
          isDragging.value = true;
        }
        const moveX = offsetX + e2.clientX - downX;
        const moveY = offsetY + e2.clientY - downY;
        adjustPosition(moveX, moveY);
      };
      const onMouseup = () => {
        isDragging.value = false;
        document.removeEventListener("mousemove", onMousemove);
        document.removeEventListener("mouseup", onMouseup);
      };
      document.addEventListener("mousemove", onMousemove);
      document.addEventListener("mouseup", onMouseup);
    };
    const onDraggable = () => {
      if (dragRef.value && targetRef.value) {
        dragRef.value.addEventListener("mousedown", onMousedown);
        window.addEventListener("resize", updatePosition);
      }
    };
    const offDraggable = () => {
      if (dragRef.value && targetRef.value) {
        dragRef.value.removeEventListener("mousedown", onMousedown);
        window.removeEventListener("resize", updatePosition);
      }
    };
    const resetPosition = () => {
      transform.offsetX = 0;
      transform.offsetY = 0;
      if (targetRef.value) {
        targetRef.value.style.transform = "";
      }
    };
    const updatePosition = () => {
      const { offsetX, offsetY } = transform;
      adjustPosition(offsetX, offsetY);
    };
    vue.onMounted(() => {
      vue.watchEffect(() => {
        if (draggable.value) {
          onDraggable();
        } else {
          offDraggable();
        }
      });
    });
    vue.onBeforeUnmount(() => {
      offDraggable();
    });
    return {
      isDragging,
      resetPosition,
      updatePosition
    };
  };

  const useFocus = (el) => {
    return {
      focus: () => {
        var _a, _b;
        (_b = (_a = el.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
      }
    };
  };

  var English = {
    name: "en",
    el: {
      breadcrumb: {
        label: "Breadcrumb"
      },
      colorpicker: {
        confirm: "OK",
        clear: "Clear",
        defaultLabel: "color picker",
        description: "current color is {color}. press enter to select a new color.",
        alphaLabel: "pick alpha value",
        alphaDescription: "alpha {alpha}, current color is {color}",
        hueLabel: "pick hue value",
        hueDescription: "hue {hue}, current color is {color}",
        svLabel: "pick saturation and brightness value",
        svDescription: "saturation {saturation}, brightness {brightness}, current color is {color}",
        predefineDescription: "select {value} as the color"
      },
      datepicker: {
        now: "Now",
        today: "Today",
        cancel: "Cancel",
        clear: "Clear",
        confirm: "OK",
        dateTablePrompt: "Use the arrow keys and enter to select the day of the month",
        monthTablePrompt: "Use the arrow keys and enter to select the month",
        yearTablePrompt: "Use the arrow keys and enter to select the year",
        selectedDate: "Selected date",
        selectDate: "Select date",
        selectTime: "Select time",
        startDate: "Start Date",
        startTime: "Start Time",
        endDate: "End Date",
        endTime: "End Time",
        prevYear: "Previous Year",
        nextYear: "Next Year",
        prevMonth: "Previous Month",
        nextMonth: "Next Month",
        year: "",
        month1: "January",
        month2: "February",
        month3: "March",
        month4: "April",
        month5: "May",
        month6: "June",
        month7: "July",
        month8: "August",
        month9: "September",
        month10: "October",
        month11: "November",
        month12: "December",
        weeks: {
          sun: "Sun",
          mon: "Mon",
          tue: "Tue",
          wed: "Wed",
          thu: "Thu",
          fri: "Fri",
          sat: "Sat"
        },
        weeksFull: {
          sun: "Sunday",
          mon: "Monday",
          tue: "Tuesday",
          wed: "Wednesday",
          thu: "Thursday",
          fri: "Friday",
          sat: "Saturday"
        },
        months: {
          jan: "Jan",
          feb: "Feb",
          mar: "Mar",
          apr: "Apr",
          may: "May",
          jun: "Jun",
          jul: "Jul",
          aug: "Aug",
          sep: "Sep",
          oct: "Oct",
          nov: "Nov",
          dec: "Dec"
        }
      },
      inputNumber: {
        decrease: "decrease number",
        increase: "increase number"
      },
      select: {
        loading: "Loading",
        noMatch: "No matching data",
        noData: "No data",
        placeholder: "Select"
      },
      mention: {
        loading: "Loading"
      },
      dropdown: {
        toggleDropdown: "Toggle Dropdown"
      },
      cascader: {
        noMatch: "No matching data",
        loading: "Loading",
        placeholder: "Select",
        noData: "No data"
      },
      pagination: {
        goto: "Go to",
        pagesize: "/page",
        total: "Total {total}",
        pageClassifier: "",
        page: "Page",
        prev: "Go to previous page",
        next: "Go to next page",
        currentPage: "page {pager}",
        prevPages: "Previous {pager} pages",
        nextPages: "Next {pager} pages",
        deprecationWarning: "Deprecated usages detected, please refer to the el-pagination documentation for more details"
      },
      dialog: {
        close: "Close this dialog"
      },
      drawer: {
        close: "Close this dialog"
      },
      messagebox: {
        title: "Message",
        confirm: "OK",
        cancel: "Cancel",
        error: "Illegal input",
        close: "Close this dialog"
      },
      upload: {
        deleteTip: "press delete to remove",
        delete: "Delete",
        preview: "Preview",
        continue: "Continue"
      },
      slider: {
        defaultLabel: "slider between {min} and {max}",
        defaultRangeStartLabel: "pick start value",
        defaultRangeEndLabel: "pick end value"
      },
      table: {
        emptyText: "No Data",
        confirmFilter: "Confirm",
        resetFilter: "Reset",
        clearFilter: "All",
        sumText: "Sum"
      },
      tour: {
        next: "Next",
        previous: "Previous",
        finish: "Finish",
        close: "Close this dialog"
      },
      tree: {
        emptyText: "No Data"
      },
      transfer: {
        noMatch: "No matching data",
        noData: "No data",
        titles: ["List 1", "List 2"],
        filterPlaceholder: "Enter keyword",
        noCheckedFormat: "{total} items",
        hasCheckedFormat: "{checked}/{total} checked"
      },
      image: {
        error: "FAILED"
      },
      pageHeader: {
        title: "Back"
      },
      popconfirm: {
        confirmButtonText: "Yes",
        cancelButtonText: "No"
      },
      carousel: {
        leftArrow: "Carousel arrow left",
        rightArrow: "Carousel arrow right",
        indicator: "Carousel switch to index {index}"
      }
    }
  };

  const buildTranslator = (locale) => (path, option) => translate(path, option, vue.unref(locale));
  const translate = (path, option, locale) => get(locale, path, path).replace(/\{(\w+)\}/g, (_, key) => {
    var _a;
    return `${(_a = option == null ? void 0 : option[key]) != null ? _a : `{${key}}`}`;
  });
  const buildLocaleContext = (locale) => {
    const lang = vue.computed(() => vue.unref(locale).name);
    const localeRef = vue.isRef(locale) ? locale : vue.ref(locale);
    return {
      lang,
      locale: localeRef,
      t: buildTranslator(locale)
    };
  };
  const localeContextKey = Symbol("localeContextKey");
  const useLocale = (localeOverrides) => {
    const locale = localeOverrides || vue.inject(localeContextKey, vue.ref());
    return buildLocaleContext(vue.computed(() => locale.value || English));
  };

  const defaultNamespace = "el";
  const statePrefix = "is-";
  const _bem = (namespace, block, blockSuffix, element, modifier) => {
    let cls = `${namespace}-${block}`;
    if (blockSuffix) {
      cls += `-${blockSuffix}`;
    }
    if (element) {
      cls += `__${element}`;
    }
    if (modifier) {
      cls += `--${modifier}`;
    }
    return cls;
  };
  const namespaceContextKey = Symbol("namespaceContextKey");
  const useGetDerivedNamespace = (namespaceOverrides) => {
    const derivedNamespace = namespaceOverrides || (vue.getCurrentInstance() ? vue.inject(namespaceContextKey, vue.ref(defaultNamespace)) : vue.ref(defaultNamespace));
    const namespace = vue.computed(() => {
      return vue.unref(derivedNamespace) || defaultNamespace;
    });
    return namespace;
  };
  const useNamespace = (block, namespaceOverrides) => {
    const namespace = useGetDerivedNamespace(namespaceOverrides);
    const b = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
    const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
    const m = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
    const be = (blockSuffix, element) => blockSuffix && element ? _bem(namespace.value, block, blockSuffix, element, "") : "";
    const em = (element, modifier) => element && modifier ? _bem(namespace.value, block, "", element, modifier) : "";
    const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(namespace.value, block, blockSuffix, "", modifier) : "";
    const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(namespace.value, block, blockSuffix, element, modifier) : "";
    const is = (name, ...args) => {
      const state = args.length >= 1 ? args[0] : true;
      return name && state ? `${statePrefix}${name}` : "";
    };
    const cssVar = (object) => {
      const styles = {};
      for (const key in object) {
        if (object[key]) {
          styles[`--${namespace.value}-${key}`] = object[key];
        }
      }
      return styles;
    };
    const cssVarBlock = (object) => {
      const styles = {};
      for (const key in object) {
        if (object[key]) {
          styles[`--${namespace.value}-${block}-${key}`] = object[key];
        }
      }
      return styles;
    };
    const cssVarName = (name) => `--${namespace.value}-${name}`;
    const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
    return {
      namespace,
      b,
      e,
      m,
      be,
      em,
      bm,
      bem,
      is,
      cssVar,
      cssVarName,
      cssVarBlock,
      cssVarBlockName
    };
  };

  const useLockscreen = (trigger, options = {}) => {
    if (!vue.isRef(trigger)) {
      throwError("[useLockscreen]", "You need to pass a ref param to this function");
    }
    const ns = options.ns || useNamespace("popup");
    const hiddenCls = vue.computed(() => ns.bm("parent", "hidden"));
    let scrollBarWidth = 0;
    let withoutHiddenClass = false;
    let bodyWidth = "0";
    const cleanup = () => {
      setTimeout(() => {
        if (typeof document === "undefined")
          return;
        if (withoutHiddenClass && document) {
          document.body.style.width = bodyWidth;
          removeClass(document.body, hiddenCls.value);
        }
      }, 200);
    };
    vue.watch(trigger, (val) => {
      if (!val) {
        cleanup();
        return;
      }
      withoutHiddenClass = !hasClass(document.body, hiddenCls.value);
      if (withoutHiddenClass) {
        bodyWidth = document.body.style.width;
        addClass(document.body, hiddenCls.value);
      }
      scrollBarWidth = getScrollBarWidth(ns.namespace.value);
      const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
      const bodyOverflowY = getStyle(document.body, "overflowY");
      if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
        document.body.style.width = `calc(100% - ${scrollBarWidth}px)`;
      }
    });
    vue.onScopeDispose(() => cleanup());
  };

  const modalStack = [];
  const closeModal = (e) => {
    if (modalStack.length === 0)
      return;
    const code = getEventCode(e);
    if (code === EVENT_CODE.esc) {
      e.stopPropagation();
      const topModal = modalStack[modalStack.length - 1];
      topModal.handleClose();
    }
  };
  const useModal = (instance, visibleRef) => {
    vue.watch(visibleRef, (val) => {
      if (val) {
        modalStack.push(instance);
      } else {
        modalStack.splice(modalStack.indexOf(instance), 1);
      }
    });
  };
  if (isClient)
    useEventListener(document, "keydown", closeModal);

  const _prop = buildProp({
    type: definePropType(Boolean),
    default: null
  });
  const _event = buildProp({
    type: definePropType(Function)
  });
  const createModelToggleComposable = (name) => {
    const updateEventKey = `update:${name}`;
    const updateEventKeyRaw = `onUpdate:${name}`;
    const useModelToggleEmits2 = [updateEventKey];
    const useModelToggleProps2 = {
      [name]: _prop,
      [updateEventKeyRaw]: _event
    };
    const useModelToggle2 = ({
      indicator,
      toggleReason,
      shouldHideWhenRouteChanges,
      shouldProceed,
      onShow,
      onHide
    }) => {
      const instance = vue.getCurrentInstance();
      const { emit } = instance;
      const props = instance.props;
      const hasUpdateHandler = vue.computed(() => isFunction$1(props[updateEventKeyRaw]));
      const isModelBindingAbsent = vue.computed(() => props[name] === null);
      const doShow = (event) => {
        if (indicator.value === true) {
          return;
        }
        indicator.value = true;
        if (toggleReason) {
          toggleReason.value = event;
        }
        if (isFunction$1(onShow)) {
          onShow(event);
        }
      };
      const doHide = (event) => {
        if (indicator.value === false) {
          return;
        }
        indicator.value = false;
        if (toggleReason) {
          toggleReason.value = event;
        }
        if (isFunction$1(onHide)) {
          onHide(event);
        }
      };
      const show = (event) => {
        if (props.disabled === true || isFunction$1(shouldProceed) && !shouldProceed())
          return;
        const shouldEmit = hasUpdateHandler.value && isClient;
        if (shouldEmit) {
          emit(updateEventKey, true);
        }
        if (isModelBindingAbsent.value || !shouldEmit) {
          doShow(event);
        }
      };
      const hide = (event) => {
        if (props.disabled === true || !isClient)
          return;
        const shouldEmit = hasUpdateHandler.value && isClient;
        if (shouldEmit) {
          emit(updateEventKey, false);
        }
        if (isModelBindingAbsent.value || !shouldEmit) {
          doHide(event);
        }
      };
      const onChange = (val) => {
        if (!isBoolean(val))
          return;
        if (props.disabled && val) {
          if (hasUpdateHandler.value) {
            emit(updateEventKey, false);
          }
        } else if (indicator.value !== val) {
          if (val) {
            doShow();
          } else {
            doHide();
          }
        }
      };
      const toggle = () => {
        if (indicator.value) {
          hide();
        } else {
          show();
        }
      };
      vue.watch(() => props[name], onChange);
      if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
        vue.watch(() => ({
          ...instance.proxy.$route
        }), () => {
          if (shouldHideWhenRouteChanges.value && indicator.value) {
            hide();
          }
        });
      }
      vue.onMounted(() => {
        onChange(props[name]);
      });
      return {
        hide,
        show,
        toggle,
        hasUpdateHandler
      };
    };
    return {
      useModelToggle: useModelToggle2,
      useModelToggleProps: useModelToggleProps2,
      useModelToggleEmits: useModelToggleEmits2
    };
  };
  const { useModelToggle, useModelToggleProps, useModelToggleEmits } = createModelToggleComposable("modelValue");

  const usePreventGlobal = (indicator, evt, cb) => {
    const prevent = (e) => {
      if (cb(e))
        e.stopImmediatePropagation();
    };
    let stop = void 0;
    vue.watch(() => indicator.value, (val) => {
      if (val) {
        stop = useEventListener(document, evt, prevent, true);
      } else {
        stop == null ? void 0 : stop();
      }
    }, { immediate: true });
  };

  const useProp = (name) => {
    const vm = vue.getCurrentInstance();
    return vue.computed(() => {
      var _a, _b;
      return (_b = (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$props) == null ? void 0 : _b[name];
    });
  };

  var E$1="top",R="bottom",W="right",P$1="left",me="auto",G=[E$1,R,W,P$1],U$1="start",J="end",Xe="clippingParents",je="viewport",K="popper",Ye="reference",De=G.reduce(function(t,e){return t.concat([e+"-"+U$1,e+"-"+J])},[]),Ee=[].concat(G,[me]).reduce(function(t,e){return t.concat([e,e+"-"+U$1,e+"-"+J])},[]),Ge="beforeRead",Je="read",Ke="afterRead",Qe="beforeMain",Ze="main",et="afterMain",tt="beforeWrite",nt="write",rt="afterWrite",ot=[Ge,Je,Ke,Qe,Ze,et,tt,nt,rt];function C(t){return t?(t.nodeName||"").toLowerCase():null}function H(t){if(t==null)return window;if(t.toString()!=="[object Window]"){var e=t.ownerDocument;return e&&e.defaultView||window}return t}function Q(t){var e=H(t).Element;return t instanceof e||t instanceof Element}function B(t){var e=H(t).HTMLElement;return t instanceof e||t instanceof HTMLElement}function Pe(t){if(typeof ShadowRoot=="undefined")return !1;var e=H(t).ShadowRoot;return t instanceof e||t instanceof ShadowRoot}function Mt(t){var e=t.state;Object.keys(e.elements).forEach(function(n){var r=e.styles[n]||{},o=e.attributes[n]||{},i=e.elements[n];!B(i)||!C(i)||(Object.assign(i.style,r),Object.keys(o).forEach(function(a){var s=o[a];s===!1?i.removeAttribute(a):i.setAttribute(a,s===!0?"":s);}));});}function Rt(t){var e=t.state,n={popper:{position:e.options.strategy,left:"0",top:"0",margin:"0"},arrow:{position:"absolute"},reference:{}};return Object.assign(e.elements.popper.style,n.popper),e.styles=n,e.elements.arrow&&Object.assign(e.elements.arrow.style,n.arrow),function(){Object.keys(e.elements).forEach(function(r){var o=e.elements[r],i=e.attributes[r]||{},a=Object.keys(e.styles.hasOwnProperty(r)?e.styles[r]:n[r]),s=a.reduce(function(f,c){return f[c]="",f},{});!B(o)||!C(o)||(Object.assign(o.style,s),Object.keys(i).forEach(function(f){o.removeAttribute(f);}));});}}var Ae={name:"applyStyles",enabled:!0,phase:"write",fn:Mt,effect:Rt,requires:["computeStyles"]};function q(t){return t.split("-")[0]}var X$1=Math.max,ve=Math.min,Z=Math.round;function ee(t,e){e===void 0&&(e=!1);var n=t.getBoundingClientRect(),r=1,o=1;if(B(t)&&e){var i=t.offsetHeight,a=t.offsetWidth;a>0&&(r=Z(n.width)/a||1),i>0&&(o=Z(n.height)/i||1);}return {width:n.width/r,height:n.height/o,top:n.top/o,right:n.right/r,bottom:n.bottom/o,left:n.left/r,x:n.left/r,y:n.top/o}}function ke(t){var e=ee(t),n=t.offsetWidth,r=t.offsetHeight;return Math.abs(e.width-n)<=1&&(n=e.width),Math.abs(e.height-r)<=1&&(r=e.height),{x:t.offsetLeft,y:t.offsetTop,width:n,height:r}}function it(t,e){var n=e.getRootNode&&e.getRootNode();if(t.contains(e))return !0;if(n&&Pe(n)){var r=e;do{if(r&&t.isSameNode(r))return !0;r=r.parentNode||r.host;}while(r)}return !1}function N$1(t){return H(t).getComputedStyle(t)}function Wt(t){return ["table","td","th"].indexOf(C(t))>=0}function I$1(t){return ((Q(t)?t.ownerDocument:t.document)||window.document).documentElement}function ge(t){return C(t)==="html"?t:t.assignedSlot||t.parentNode||(Pe(t)?t.host:null)||I$1(t)}function at(t){return !B(t)||N$1(t).position==="fixed"?null:t.offsetParent}function Bt(t){var e=navigator.userAgent.toLowerCase().indexOf("firefox")!==-1,n=navigator.userAgent.indexOf("Trident")!==-1;if(n&&B(t)){var r=N$1(t);if(r.position==="fixed")return null}var o=ge(t);for(Pe(o)&&(o=o.host);B(o)&&["html","body"].indexOf(C(o))<0;){var i=N$1(o);if(i.transform!=="none"||i.perspective!=="none"||i.contain==="paint"||["transform","perspective"].indexOf(i.willChange)!==-1||e&&i.willChange==="filter"||e&&i.filter&&i.filter!=="none")return o;o=o.parentNode;}return null}function se(t){for(var e=H(t),n=at(t);n&&Wt(n)&&N$1(n).position==="static";)n=at(n);return n&&(C(n)==="html"||C(n)==="body"&&N$1(n).position==="static")?e:n||Bt(t)||e}function Le(t){return ["top","bottom"].indexOf(t)>=0?"x":"y"}function fe(t,e,n){return X$1(t,ve(e,n))}function St(t,e,n){var r=fe(t,e,n);return r>n?n:r}function st(){return {top:0,right:0,bottom:0,left:0}}function ft(t){return Object.assign({},st(),t)}function ct(t,e){return e.reduce(function(n,r){return n[r]=t,n},{})}var Tt=function(t,e){return t=typeof t=="function"?t(Object.assign({},e.rects,{placement:e.placement})):t,ft(typeof t!="number"?t:ct(t,G))};function Ht(t){var e,n=t.state,r=t.name,o=t.options,i=n.elements.arrow,a=n.modifiersData.popperOffsets,s=q(n.placement),f=Le(s),c=[P$1,W].indexOf(s)>=0,u=c?"height":"width";if(!(!i||!a)){var m=Tt(o.padding,n),v=ke(i),l=f==="y"?E$1:P$1,h=f==="y"?R:W,p=n.rects.reference[u]+n.rects.reference[f]-a[f]-n.rects.popper[u],g=a[f]-n.rects.reference[f],x=se(i),y=x?f==="y"?x.clientHeight||0:x.clientWidth||0:0,$=p/2-g/2,d=m[l],b=y-v[u]-m[h],w=y/2-v[u]/2+$,O=fe(d,w,b),j=f;n.modifiersData[r]=(e={},e[j]=O,e.centerOffset=O-w,e);}}function Ct(t){var e=t.state,n=t.options,r=n.element,o=r===void 0?"[data-popper-arrow]":r;o!=null&&(typeof o=="string"&&(o=e.elements.popper.querySelector(o),!o)||!it(e.elements.popper,o)||(e.elements.arrow=o));}var pt={name:"arrow",enabled:!0,phase:"main",fn:Ht,effect:Ct,requires:["popperOffsets"],requiresIfExists:["preventOverflow"]};function te(t){return t.split("-")[1]}var qt={top:"auto",right:"auto",bottom:"auto",left:"auto"};function Vt(t){var e=t.x,n=t.y,r=window,o=r.devicePixelRatio||1;return {x:Z(e*o)/o||0,y:Z(n*o)/o||0}}function ut(t){var e,n=t.popper,r=t.popperRect,o=t.placement,i=t.variation,a=t.offsets,s=t.position,f=t.gpuAcceleration,c=t.adaptive,u=t.roundOffsets,m=t.isFixed,v=a.x,l=v===void 0?0:v,h=a.y,p=h===void 0?0:h,g=typeof u=="function"?u({x:l,y:p}):{x:l,y:p};l=g.x,p=g.y;var x=a.hasOwnProperty("x"),y=a.hasOwnProperty("y"),$=P$1,d=E$1,b=window;if(c){var w=se(n),O="clientHeight",j="clientWidth";if(w===H(n)&&(w=I$1(n),N$1(w).position!=="static"&&s==="absolute"&&(O="scrollHeight",j="scrollWidth")),w=w,o===E$1||(o===P$1||o===W)&&i===J){d=R;var A=m&&w===b&&b.visualViewport?b.visualViewport.height:w[O];p-=A-r.height,p*=f?1:-1;}if(o===P$1||(o===E$1||o===R)&&i===J){$=W;var k=m&&w===b&&b.visualViewport?b.visualViewport.width:w[j];l-=k-r.width,l*=f?1:-1;}}var D=Object.assign({position:s},c&&qt),S=u===!0?Vt({x:l,y:p}):{x:l,y:p};if(l=S.x,p=S.y,f){var L;return Object.assign({},D,(L={},L[d]=y?"0":"",L[$]=x?"0":"",L.transform=(b.devicePixelRatio||1)<=1?"translate("+l+"px, "+p+"px)":"translate3d("+l+"px, "+p+"px, 0)",L))}return Object.assign({},D,(e={},e[d]=y?p+"px":"",e[$]=x?l+"px":"",e.transform="",e))}function Nt(t){var e=t.state,n=t.options,r=n.gpuAcceleration,o=r===void 0?!0:r,i=n.adaptive,a=i===void 0?!0:i,s=n.roundOffsets,f=s===void 0?!0:s,c={placement:q(e.placement),variation:te(e.placement),popper:e.elements.popper,popperRect:e.rects.popper,gpuAcceleration:o,isFixed:e.options.strategy==="fixed"};e.modifiersData.popperOffsets!=null&&(e.styles.popper=Object.assign({},e.styles.popper,ut(Object.assign({},c,{offsets:e.modifiersData.popperOffsets,position:e.options.strategy,adaptive:a,roundOffsets:f})))),e.modifiersData.arrow!=null&&(e.styles.arrow=Object.assign({},e.styles.arrow,ut(Object.assign({},c,{offsets:e.modifiersData.arrow,position:"absolute",adaptive:!1,roundOffsets:f})))),e.attributes.popper=Object.assign({},e.attributes.popper,{"data-popper-placement":e.placement});}var Me={name:"computeStyles",enabled:!0,phase:"beforeWrite",fn:Nt,data:{}},ye={passive:!0};function It(t){var e=t.state,n=t.instance,r=t.options,o=r.scroll,i=o===void 0?!0:o,a=r.resize,s=a===void 0?!0:a,f=H(e.elements.popper),c=[].concat(e.scrollParents.reference,e.scrollParents.popper);return i&&c.forEach(function(u){u.addEventListener("scroll",n.update,ye);}),s&&f.addEventListener("resize",n.update,ye),function(){i&&c.forEach(function(u){u.removeEventListener("scroll",n.update,ye);}),s&&f.removeEventListener("resize",n.update,ye);}}var Re={name:"eventListeners",enabled:!0,phase:"write",fn:function(){},effect:It,data:{}},_t={left:"right",right:"left",bottom:"top",top:"bottom"};function be(t){return t.replace(/left|right|bottom|top/g,function(e){return _t[e]})}var zt={start:"end",end:"start"};function lt(t){return t.replace(/start|end/g,function(e){return zt[e]})}function We(t){var e=H(t),n=e.pageXOffset,r=e.pageYOffset;return {scrollLeft:n,scrollTop:r}}function Be(t){return ee(I$1(t)).left+We(t).scrollLeft}function Ft(t){var e=H(t),n=I$1(t),r=e.visualViewport,o=n.clientWidth,i=n.clientHeight,a=0,s=0;return r&&(o=r.width,i=r.height,/^((?!chrome|android).)*safari/i.test(navigator.userAgent)||(a=r.offsetLeft,s=r.offsetTop)),{width:o,height:i,x:a+Be(t),y:s}}function Ut(t){var e,n=I$1(t),r=We(t),o=(e=t.ownerDocument)==null?void 0:e.body,i=X$1(n.scrollWidth,n.clientWidth,o?o.scrollWidth:0,o?o.clientWidth:0),a=X$1(n.scrollHeight,n.clientHeight,o?o.scrollHeight:0,o?o.clientHeight:0),s=-r.scrollLeft+Be(t),f=-r.scrollTop;return N$1(o||n).direction==="rtl"&&(s+=X$1(n.clientWidth,o?o.clientWidth:0)-i),{width:i,height:a,x:s,y:f}}function Se(t){var e=N$1(t),n=e.overflow,r=e.overflowX,o=e.overflowY;return /auto|scroll|overlay|hidden/.test(n+o+r)}function dt(t){return ["html","body","#document"].indexOf(C(t))>=0?t.ownerDocument.body:B(t)&&Se(t)?t:dt(ge(t))}function ce(t,e){var n;e===void 0&&(e=[]);var r=dt(t),o=r===((n=t.ownerDocument)==null?void 0:n.body),i=H(r),a=o?[i].concat(i.visualViewport||[],Se(r)?r:[]):r,s=e.concat(a);return o?s:s.concat(ce(ge(a)))}function Te(t){return Object.assign({},t,{left:t.x,top:t.y,right:t.x+t.width,bottom:t.y+t.height})}function Xt(t){var e=ee(t);return e.top=e.top+t.clientTop,e.left=e.left+t.clientLeft,e.bottom=e.top+t.clientHeight,e.right=e.left+t.clientWidth,e.width=t.clientWidth,e.height=t.clientHeight,e.x=e.left,e.y=e.top,e}function ht(t,e){return e===je?Te(Ft(t)):Q(e)?Xt(e):Te(Ut(I$1(t)))}function Yt(t){var e=ce(ge(t)),n=["absolute","fixed"].indexOf(N$1(t).position)>=0,r=n&&B(t)?se(t):t;return Q(r)?e.filter(function(o){return Q(o)&&it(o,r)&&C(o)!=="body"}):[]}function Gt(t,e,n){var r=e==="clippingParents"?Yt(t):[].concat(e),o=[].concat(r,[n]),i=o[0],a=o.reduce(function(s,f){var c=ht(t,f);return s.top=X$1(c.top,s.top),s.right=ve(c.right,s.right),s.bottom=ve(c.bottom,s.bottom),s.left=X$1(c.left,s.left),s},ht(t,i));return a.width=a.right-a.left,a.height=a.bottom-a.top,a.x=a.left,a.y=a.top,a}function mt(t){var e=t.reference,n=t.element,r=t.placement,o=r?q(r):null,i=r?te(r):null,a=e.x+e.width/2-n.width/2,s=e.y+e.height/2-n.height/2,f;switch(o){case E$1:f={x:a,y:e.y-n.height};break;case R:f={x:a,y:e.y+e.height};break;case W:f={x:e.x+e.width,y:s};break;case P$1:f={x:e.x-n.width,y:s};break;default:f={x:e.x,y:e.y};}var c=o?Le(o):null;if(c!=null){var u=c==="y"?"height":"width";switch(i){case U$1:f[c]=f[c]-(e[u]/2-n[u]/2);break;case J:f[c]=f[c]+(e[u]/2-n[u]/2);break}}return f}function ne(t,e){e===void 0&&(e={});var n=e,r=n.placement,o=r===void 0?t.placement:r,i=n.boundary,a=i===void 0?Xe:i,s=n.rootBoundary,f=s===void 0?je:s,c=n.elementContext,u=c===void 0?K:c,m=n.altBoundary,v=m===void 0?!1:m,l=n.padding,h=l===void 0?0:l,p=ft(typeof h!="number"?h:ct(h,G)),g=u===K?Ye:K,x=t.rects.popper,y=t.elements[v?g:u],$=Gt(Q(y)?y:y.contextElement||I$1(t.elements.popper),a,f),d=ee(t.elements.reference),b=mt({reference:d,element:x,strategy:"absolute",placement:o}),w=Te(Object.assign({},x,b)),O=u===K?w:d,j={top:$.top-O.top+p.top,bottom:O.bottom-$.bottom+p.bottom,left:$.left-O.left+p.left,right:O.right-$.right+p.right},A=t.modifiersData.offset;if(u===K&&A){var k=A[o];Object.keys(j).forEach(function(D){var S=[W,R].indexOf(D)>=0?1:-1,L=[E$1,R].indexOf(D)>=0?"y":"x";j[D]+=k[L]*S;});}return j}function Jt(t,e){e===void 0&&(e={});var n=e,r=n.placement,o=n.boundary,i=n.rootBoundary,a=n.padding,s=n.flipVariations,f=n.allowedAutoPlacements,c=f===void 0?Ee:f,u=te(r),m=u?s?De:De.filter(function(h){return te(h)===u}):G,v=m.filter(function(h){return c.indexOf(h)>=0});v.length===0&&(v=m);var l=v.reduce(function(h,p){return h[p]=ne(t,{placement:p,boundary:o,rootBoundary:i,padding:a})[q(p)],h},{});return Object.keys(l).sort(function(h,p){return l[h]-l[p]})}function Kt(t){if(q(t)===me)return [];var e=be(t);return [lt(t),e,lt(e)]}function Qt(t){var e=t.state,n=t.options,r=t.name;if(!e.modifiersData[r]._skip){for(var o=n.mainAxis,i=o===void 0?!0:o,a=n.altAxis,s=a===void 0?!0:a,f=n.fallbackPlacements,c=n.padding,u=n.boundary,m=n.rootBoundary,v=n.altBoundary,l=n.flipVariations,h=l===void 0?!0:l,p=n.allowedAutoPlacements,g=e.options.placement,x=q(g),y=x===g,$=f||(y||!h?[be(g)]:Kt(g)),d=[g].concat($).reduce(function(z,V){return z.concat(q(V)===me?Jt(e,{placement:V,boundary:u,rootBoundary:m,padding:c,flipVariations:h,allowedAutoPlacements:p}):V)},[]),b=e.rects.reference,w=e.rects.popper,O=new Map,j=!0,A=d[0],k=0;k<d.length;k++){var D=d[k],S=q(D),L=te(D)===U$1,re=[E$1,R].indexOf(S)>=0,oe=re?"width":"height",M=ne(e,{placement:D,boundary:u,rootBoundary:m,altBoundary:v,padding:c}),T=re?L?W:P$1:L?R:E$1;b[oe]>w[oe]&&(T=be(T));var pe=be(T),_=[];if(i&&_.push(M[S]<=0),s&&_.push(M[T]<=0,M[pe]<=0),_.every(function(z){return z})){A=D,j=!1;break}O.set(D,_);}if(j)for(var ue=h?3:1,xe=function(z){var V=d.find(function(de){var ae=O.get(de);if(ae)return ae.slice(0,z).every(function(Y){return Y})});if(V)return A=V,"break"},ie=ue;ie>0;ie--){var le=xe(ie);if(le==="break")break}e.placement!==A&&(e.modifiersData[r]._skip=!0,e.placement=A,e.reset=!0);}}var vt={name:"flip",enabled:!0,phase:"main",fn:Qt,requiresIfExists:["offset"],data:{_skip:!1}};function gt(t,e,n){return n===void 0&&(n={x:0,y:0}),{top:t.top-e.height-n.y,right:t.right-e.width+n.x,bottom:t.bottom-e.height+n.y,left:t.left-e.width-n.x}}function yt(t){return [E$1,W,R,P$1].some(function(e){return t[e]>=0})}function Zt(t){var e=t.state,n=t.name,r=e.rects.reference,o=e.rects.popper,i=e.modifiersData.preventOverflow,a=ne(e,{elementContext:"reference"}),s=ne(e,{altBoundary:!0}),f=gt(a,r),c=gt(s,o,i),u=yt(f),m=yt(c);e.modifiersData[n]={referenceClippingOffsets:f,popperEscapeOffsets:c,isReferenceHidden:u,hasPopperEscaped:m},e.attributes.popper=Object.assign({},e.attributes.popper,{"data-popper-reference-hidden":u,"data-popper-escaped":m});}var bt={name:"hide",enabled:!0,phase:"main",requiresIfExists:["preventOverflow"],fn:Zt};function en(t,e,n){var r=q(t),o=[P$1,E$1].indexOf(r)>=0?-1:1,i=typeof n=="function"?n(Object.assign({},e,{placement:t})):n,a=i[0],s=i[1];return a=a||0,s=(s||0)*o,[P$1,W].indexOf(r)>=0?{x:s,y:a}:{x:a,y:s}}function tn(t){var e=t.state,n=t.options,r=t.name,o=n.offset,i=o===void 0?[0,0]:o,a=Ee.reduce(function(u,m){return u[m]=en(m,e.rects,i),u},{}),s=a[e.placement],f=s.x,c=s.y;e.modifiersData.popperOffsets!=null&&(e.modifiersData.popperOffsets.x+=f,e.modifiersData.popperOffsets.y+=c),e.modifiersData[r]=a;}var wt={name:"offset",enabled:!0,phase:"main",requires:["popperOffsets"],fn:tn};function nn(t){var e=t.state,n=t.name;e.modifiersData[n]=mt({reference:e.rects.reference,element:e.rects.popper,strategy:"absolute",placement:e.placement});}var He={name:"popperOffsets",enabled:!0,phase:"read",fn:nn,data:{}};function rn(t){return t==="x"?"y":"x"}function on(t){var e=t.state,n=t.options,r=t.name,o=n.mainAxis,i=o===void 0?!0:o,a=n.altAxis,s=a===void 0?!1:a,f=n.boundary,c=n.rootBoundary,u=n.altBoundary,m=n.padding,v=n.tether,l=v===void 0?!0:v,h=n.tetherOffset,p=h===void 0?0:h,g=ne(e,{boundary:f,rootBoundary:c,padding:m,altBoundary:u}),x=q(e.placement),y=te(e.placement),$=!y,d=Le(x),b=rn(d),w=e.modifiersData.popperOffsets,O=e.rects.reference,j=e.rects.popper,A=typeof p=="function"?p(Object.assign({},e.rects,{placement:e.placement})):p,k=typeof A=="number"?{mainAxis:A,altAxis:A}:Object.assign({mainAxis:0,altAxis:0},A),D=e.modifiersData.offset?e.modifiersData.offset[e.placement]:null,S={x:0,y:0};if(w){if(i){var L,re=d==="y"?E$1:P$1,oe=d==="y"?R:W,M=d==="y"?"height":"width",T=w[d],pe=T+g[re],_=T-g[oe],ue=l?-j[M]/2:0,xe=y===U$1?O[M]:j[M],ie=y===U$1?-j[M]:-O[M],le=e.elements.arrow,z=l&&le?ke(le):{width:0,height:0},V=e.modifiersData["arrow#persistent"]?e.modifiersData["arrow#persistent"].padding:st(),de=V[re],ae=V[oe],Y=fe(0,O[M],z[M]),jt=$?O[M]/2-ue-Y-de-k.mainAxis:xe-Y-de-k.mainAxis,Dt=$?-O[M]/2+ue+Y+ae+k.mainAxis:ie+Y+ae+k.mainAxis,Oe=e.elements.arrow&&se(e.elements.arrow),Et=Oe?d==="y"?Oe.clientTop||0:Oe.clientLeft||0:0,Ce=(L=D==null?void 0:D[d])!=null?L:0,Pt=T+jt-Ce-Et,At=T+Dt-Ce,qe=fe(l?ve(pe,Pt):pe,T,l?X$1(_,At):_);w[d]=qe,S[d]=qe-T;}if(s){var Ve,kt=d==="x"?E$1:P$1,Lt=d==="x"?R:W,F=w[b],he=b==="y"?"height":"width",Ne=F+g[kt],Ie=F-g[Lt],$e=[E$1,P$1].indexOf(x)!==-1,_e=(Ve=D==null?void 0:D[b])!=null?Ve:0,ze=$e?Ne:F-O[he]-j[he]-_e+k.altAxis,Fe=$e?F+O[he]+j[he]-_e-k.altAxis:Ie,Ue=l&&$e?St(ze,F,Fe):fe(l?ze:Ne,F,l?Fe:Ie);w[b]=Ue,S[b]=Ue-F;}e.modifiersData[r]=S;}}var xt={name:"preventOverflow",enabled:!0,phase:"main",fn:on,requiresIfExists:["offset"]};function an(t){return {scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}}function sn(t){return t===H(t)||!B(t)?We(t):an(t)}function fn(t){var e=t.getBoundingClientRect(),n=Z(e.width)/t.offsetWidth||1,r=Z(e.height)/t.offsetHeight||1;return n!==1||r!==1}function cn(t,e,n){n===void 0&&(n=!1);var r=B(e),o=B(e)&&fn(e),i=I$1(e),a=ee(t,o),s={scrollLeft:0,scrollTop:0},f={x:0,y:0};return (r||!r&&!n)&&((C(e)!=="body"||Se(i))&&(s=sn(e)),B(e)?(f=ee(e,!0),f.x+=e.clientLeft,f.y+=e.clientTop):i&&(f.x=Be(i))),{x:a.left+s.scrollLeft-f.x,y:a.top+s.scrollTop-f.y,width:a.width,height:a.height}}function pn(t){var e=new Map,n=new Set,r=[];t.forEach(function(i){e.set(i.name,i);});function o(i){n.add(i.name);var a=[].concat(i.requires||[],i.requiresIfExists||[]);a.forEach(function(s){if(!n.has(s)){var f=e.get(s);f&&o(f);}}),r.push(i);}return t.forEach(function(i){n.has(i.name)||o(i);}),r}function un(t){var e=pn(t);return ot.reduce(function(n,r){return n.concat(e.filter(function(o){return o.phase===r}))},[])}function ln(t){var e;return function(){return e||(e=new Promise(function(n){Promise.resolve().then(function(){e=void 0,n(t());});})),e}}function dn(t){var e=t.reduce(function(n,r){var o=n[r.name];return n[r.name]=o?Object.assign({},o,r,{options:Object.assign({},o.options,r.options),data:Object.assign({},o.data,r.data)}):r,n},{});return Object.keys(e).map(function(n){return e[n]})}var Ot={placement:"bottom",modifiers:[],strategy:"absolute"};function $t(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return !e.some(function(r){return !(r&&typeof r.getBoundingClientRect=="function")})}function we(t){t===void 0&&(t={});var e=t,n=e.defaultModifiers,r=n===void 0?[]:n,o=e.defaultOptions,i=o===void 0?Ot:o;return function(a,s,f){f===void 0&&(f=i);var c={placement:"bottom",orderedModifiers:[],options:Object.assign({},Ot,i),modifiersData:{},elements:{reference:a,popper:s},attributes:{},styles:{}},u=[],m=!1,v={state:c,setOptions:function(p){var g=typeof p=="function"?p(c.options):p;h(),c.options=Object.assign({},i,c.options,g),c.scrollParents={reference:Q(a)?ce(a):a.contextElement?ce(a.contextElement):[],popper:ce(s)};var x=un(dn([].concat(r,c.options.modifiers)));return c.orderedModifiers=x.filter(function(y){return y.enabled}),l(),v.update()},forceUpdate:function(){if(!m){var p=c.elements,g=p.reference,x=p.popper;if($t(g,x)){c.rects={reference:cn(g,se(x),c.options.strategy==="fixed"),popper:ke(x)},c.reset=!1,c.placement=c.options.placement,c.orderedModifiers.forEach(function(j){return c.modifiersData[j.name]=Object.assign({},j.data)});for(var y=0;y<c.orderedModifiers.length;y++){if(c.reset===!0){c.reset=!1,y=-1;continue}var $=c.orderedModifiers[y],d=$.fn,b=$.options,w=b===void 0?{}:b,O=$.name;typeof d=="function"&&(c=d({state:c,options:w,name:O,instance:v})||c);}}}},update:ln(function(){return new Promise(function(p){v.forceUpdate(),p(c);})}),destroy:function(){h(),m=!0;}};if(!$t(a,s))return v;v.setOptions(f).then(function(p){!m&&f.onFirstUpdate&&f.onFirstUpdate(p);});function l(){c.orderedModifiers.forEach(function(p){var g=p.name,x=p.options,y=x===void 0?{}:x,$=p.effect;if(typeof $=="function"){var d=$({state:c,name:g,instance:v,options:y}),b=function(){};u.push(d||b);}});}function h(){u.forEach(function(p){return p()}),u=[];}return v}}we();var mn=[Re,He,Me,Ae];we({defaultModifiers:mn});var gn=[Re,He,Me,Ae,wt,vt,xt,pt,bt],yn=we({defaultModifiers:gn});

  const usePopper = (referenceElementRef, popperElementRef, opts = {}) => {
    const stateUpdater = {
      name: "updateState",
      enabled: true,
      phase: "write",
      fn: ({ state }) => {
        const derivedState = deriveState(state);
        Object.assign(states.value, derivedState);
      },
      requires: ["computeStyles"]
    };
    const options = vue.computed(() => {
      const { onFirstUpdate, placement, strategy, modifiers } = vue.unref(opts);
      return {
        onFirstUpdate,
        placement: placement || "bottom",
        strategy: strategy || "absolute",
        modifiers: [
          ...modifiers || [],
          stateUpdater,
          { name: "applyStyles", enabled: false }
        ]
      };
    });
    const instanceRef = vue.shallowRef();
    const states = vue.ref({
      styles: {
        popper: {
          position: vue.unref(options).strategy,
          left: "0",
          top: "0"
        },
        arrow: {
          position: "absolute"
        }
      },
      attributes: {}
    });
    const destroy = () => {
      if (!instanceRef.value)
        return;
      instanceRef.value.destroy();
      instanceRef.value = void 0;
    };
    vue.watch(options, (newOptions) => {
      const instance = vue.unref(instanceRef);
      if (instance) {
        instance.setOptions(newOptions);
      }
    }, {
      deep: true
    });
    vue.watch([referenceElementRef, popperElementRef], ([referenceElement, popperElement]) => {
      destroy();
      if (!referenceElement || !popperElement)
        return;
      instanceRef.value = yn(referenceElement, popperElement, vue.unref(options));
    });
    vue.onBeforeUnmount(() => {
      destroy();
    });
    return {
      state: vue.computed(() => {
        var _a;
        return { ...((_a = vue.unref(instanceRef)) == null ? void 0 : _a.state) || {} };
      }),
      styles: vue.computed(() => vue.unref(states).styles),
      attributes: vue.computed(() => vue.unref(states).attributes),
      update: () => {
        var _a;
        return (_a = vue.unref(instanceRef)) == null ? void 0 : _a.update();
      },
      forceUpdate: () => {
        var _a;
        return (_a = vue.unref(instanceRef)) == null ? void 0 : _a.forceUpdate();
      },
      instanceRef: vue.computed(() => vue.unref(instanceRef))
    };
  };
  function deriveState(state) {
    const elements = Object.keys(state.elements);
    const styles = fromPairs(elements.map((element) => [element, state.styles[element] || {}]));
    const attributes = fromPairs(elements.map((element) => [element, state.attributes[element]]));
    return {
      styles,
      attributes
    };
  }

  const useSameTarget = (handleClick) => {
    if (!handleClick) {
      return { onClick: NOOP, onMousedown: NOOP, onMouseup: NOOP };
    }
    let mousedownTarget = false;
    let mouseupTarget = false;
    const onClick = (e) => {
      if (mousedownTarget && mouseupTarget) {
        handleClick(e);
      }
      mousedownTarget = mouseupTarget = false;
    };
    const onMousedown = (e) => {
      mousedownTarget = e.target === e.currentTarget;
    };
    const onMouseup = (e) => {
      mouseupTarget = e.target === e.currentTarget;
    };
    return { onClick, onMousedown, onMouseup };
  };

  const useTeleport = (contentRenderer, appendToBody) => {
    const isTeleportVisible = vue.ref(false);
    if (!isClient) {
      return {
        isTeleportVisible,
        showTeleport: NOOP,
        hideTeleport: NOOP,
        renderTeleport: NOOP
      };
    }
    let $el = null;
    const showTeleport = () => {
      isTeleportVisible.value = true;
      if ($el !== null)
        return;
      $el = createGlobalNode();
    };
    const hideTeleport = () => {
      isTeleportVisible.value = false;
      if ($el !== null) {
        removeGlobalNode($el);
        $el = null;
      }
    };
    const renderTeleport = () => {
      return appendToBody.value !== true ? contentRenderer() : isTeleportVisible.value ? [vue.h(vue.Teleport, { to: $el }, contentRenderer())] : void 0;
    };
    vue.onUnmounted(hideTeleport);
    return {
      isTeleportVisible,
      showTeleport,
      hideTeleport,
      renderTeleport
    };
  };

  const useThrottleRender = (loading, throttle = 0) => {
    if (throttle === 0)
      return loading;
    const initVal = isObject$1(throttle) && Boolean(throttle.initVal);
    const throttled = vue.ref(initVal);
    let timeoutHandle = null;
    const dispatchThrottling = (timer) => {
      if (isUndefined(timer)) {
        throttled.value = loading.value;
        return;
      }
      if (timeoutHandle) {
        clearTimeout(timeoutHandle);
      }
      timeoutHandle = setTimeout(() => {
        throttled.value = loading.value;
      }, timer);
    };
    const dispatcher = (type) => {
      if (type === "leading") {
        if (isNumber(throttle)) {
          dispatchThrottling(throttle);
        } else {
          dispatchThrottling(throttle.leading);
        }
      } else {
        if (isObject$1(throttle)) {
          dispatchThrottling(throttle.trailing);
        } else {
          throttled.value = false;
        }
      }
    };
    vue.onMounted(() => dispatcher("leading"));
    vue.watch(() => loading.value, (val) => {
      dispatcher(val ? "leading" : "trailing");
    });
    return throttled;
  };

  function useTimeout() {
    let timeoutHandle;
    const registerTimeout = (fn, delay) => {
      cancelTimeout();
      timeoutHandle = window.setTimeout(fn, delay);
    };
    const cancelTimeout = () => window.clearTimeout(timeoutHandle);
    tryOnScopeDispose(() => cancelTimeout());
    return {
      registerTimeout,
      cancelTimeout
    };
  }

  const AFTER_APPEAR = "after-appear";
  const AFTER_ENTER = "after-enter";
  const AFTER_LEAVE = "after-leave";
  const APPEAR = "appear";
  const APPEAR_CANCELLED = "appear-cancelled";
  const BEFORE_ENTER = "before-enter";
  const BEFORE_LEAVE = "before-leave";
  const ENTER = "enter";
  const ENTER_CANCELLED = "enter-cancelled";
  const LEAVE = "leave";
  const LEAVE_CANCELLED = "leave-cancelled";
  const useTransitionFallthroughEmits = [
    AFTER_APPEAR,
    AFTER_ENTER,
    AFTER_LEAVE,
    APPEAR,
    APPEAR_CANCELLED,
    BEFORE_ENTER,
    BEFORE_LEAVE,
    ENTER,
    ENTER_CANCELLED,
    LEAVE,
    LEAVE_CANCELLED
  ];
  const useTransitionFallthrough = () => {
    const { emit } = vue.getCurrentInstance();
    return {
      onAfterAppear: () => {
        emit(AFTER_APPEAR);
      },
      onAfterEnter: () => {
        emit(AFTER_ENTER);
      },
      onAfterLeave: () => {
        emit(AFTER_LEAVE);
      },
      onAppearCancelled: () => {
        emit(APPEAR_CANCELLED);
      },
      onBeforeEnter: () => {
        emit(BEFORE_ENTER);
      },
      onBeforeLeave: () => {
        emit(BEFORE_LEAVE);
      },
      onEnter: () => {
        emit(ENTER);
      },
      onEnterCancelled: () => {
        emit(ENTER_CANCELLED);
      },
      onLeave: () => {
        emit(LEAVE);
      },
      onLeaveCancelled: () => {
        emit(LEAVE_CANCELLED);
      }
    };
  };

  const defaultIdInjection = {
    prefix: Math.floor(Math.random() * 1e4),
    current: 0
  };
  const ID_INJECTION_KEY = Symbol("elIdInjection");
  const useIdInjection = () => {
    return vue.getCurrentInstance() ? vue.inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
  };
  const useId = (deterministicId) => {
    const idInjection = useIdInjection();
    if (!isClient && idInjection === defaultIdInjection) {
      debugWarn("IdInjection", `Looks like you are using server rendering, you must provide a id provider to ensure the hydration process to be succeed
usage: app.provide(ID_INJECTION_KEY, {
  prefix: number,
  current: number,
})`);
    }
    const namespace = useGetDerivedNamespace();
    const idRef = computedEager(() => vue.unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
    return idRef;
  };

  let registeredEscapeHandlers = [];
  const cachedHandler = (event) => {
    const code = getEventCode(event);
    if (code === EVENT_CODE.esc) {
      registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event));
    }
  };
  const useEscapeKeydown = (handler) => {
    vue.onMounted(() => {
      if (registeredEscapeHandlers.length === 0) {
        document.addEventListener("keydown", cachedHandler);
      }
      if (isClient)
        registeredEscapeHandlers.push(handler);
    });
    vue.onBeforeUnmount(() => {
      registeredEscapeHandlers = registeredEscapeHandlers.filter((registeredHandler) => registeredHandler !== handler);
      if (registeredEscapeHandlers.length === 0) {
        if (isClient)
          document.removeEventListener("keydown", cachedHandler);
      }
    });
  };

  const usePopperContainerId = () => {
    const namespace = useGetDerivedNamespace();
    const idInjection = useIdInjection();
    const id = vue.computed(() => {
      return `${namespace.value}-popper-container-${idInjection.prefix}`;
    });
    const selector = vue.computed(() => `#${id.value}`);
    return {
      id,
      selector
    };
  };
  const createContainer = (id) => {
    const container = document.createElement("div");
    container.id = id;
    document.body.appendChild(container);
    return container;
  };
  const usePopperContainer = () => {
    const { id, selector } = usePopperContainerId();
    vue.onBeforeMount(() => {
      if (!isClient)
        return;
      if (!document.body.querySelector(selector.value)) {
        createContainer(id.value);
      }
    });
    return {
      id,
      selector
    };
  };

  const useDelayedRender = ({
    indicator,
    intermediateIndicator,
    shouldSetIntermediate = () => true,
    beforeShow,
    afterShow,
    afterHide,
    beforeHide
  }) => {
    vue.watch(() => vue.unref(indicator), (val) => {
      if (val) {
        beforeShow == null ? void 0 : beforeShow();
        vue.nextTick(() => {
          if (!vue.unref(indicator))
            return;
          if (shouldSetIntermediate("show")) {
            intermediateIndicator.value = true;
          }
        });
      } else {
        beforeHide == null ? void 0 : beforeHide();
        vue.nextTick(() => {
          if (vue.unref(indicator))
            return;
          if (shouldSetIntermediate("hide")) {
            intermediateIndicator.value = false;
          }
        });
      }
    });
    vue.watch(() => intermediateIndicator.value, (val) => {
      if (val) {
        afterShow == null ? void 0 : afterShow();
      } else {
        afterHide == null ? void 0 : afterHide();
      }
    });
  };

  const useDelayedToggleProps = buildProps({
    showAfter: {
      type: Number,
      default: 0
    },
    hideAfter: {
      type: Number,
      default: 200
    },
    autoClose: {
      type: Number,
      default: 0
    }
  });
  const useDelayedToggle = ({
    showAfter,
    hideAfter,
    autoClose,
    open,
    close
  }) => {
    const { registerTimeout } = useTimeout();
    const {
      registerTimeout: registerTimeoutForAutoClose,
      cancelTimeout: cancelTimeoutForAutoClose
    } = useTimeout();
    const onOpen = (event, delay = vue.unref(showAfter)) => {
      registerTimeout(() => {
        open(event);
        const _autoClose = vue.unref(autoClose);
        if (isNumber(_autoClose) && _autoClose > 0) {
          registerTimeoutForAutoClose(() => {
            close(event);
          }, _autoClose);
        }
      }, delay);
    };
    const onClose = (event, delay = vue.unref(hideAfter)) => {
      cancelTimeoutForAutoClose();
      registerTimeout(() => {
        close(event);
      }, delay);
    };
    return {
      onOpen,
      onClose
    };
  };

  const FORWARD_REF_INJECTION_KEY = Symbol("elForwardRef");
  const useForwardRef = (forwardRef) => {
    const setForwardRef = (el) => {
      forwardRef.value = el;
    };
    vue.provide(FORWARD_REF_INJECTION_KEY, {
      setForwardRef
    });
  };
  const useForwardRefDirective = (setForwardRef) => {
    return {
      mounted(el) {
        setForwardRef(el);
      },
      updated(el) {
        setForwardRef(el);
      },
      unmounted() {
        setForwardRef(null);
      }
    };
  };

  const initial = {
    current: 0
  };
  const zIndex = vue.ref(0);
  const defaultInitialZIndex = 2e3;
  const ZINDEX_INJECTION_KEY = Symbol("elZIndexContextKey");
  const zIndexContextKey = Symbol("zIndexContextKey");
  const useZIndex = (zIndexOverrides) => {
    const increasingInjection = vue.getCurrentInstance() ? vue.inject(ZINDEX_INJECTION_KEY, initial) : initial;
    const zIndexInjection = zIndexOverrides || (vue.getCurrentInstance() ? vue.inject(zIndexContextKey, void 0) : void 0);
    const initialZIndex = vue.computed(() => {
      const zIndexFromInjection = vue.unref(zIndexInjection);
      return isNumber(zIndexFromInjection) ? zIndexFromInjection : defaultInitialZIndex;
    });
    const currentZIndex = vue.computed(() => initialZIndex.value + zIndex.value);
    const nextZIndex = () => {
      increasingInjection.current++;
      zIndex.value = increasingInjection.current;
      return currentZIndex.value;
    };
    if (!isClient && !vue.inject(ZINDEX_INJECTION_KEY)) {
      debugWarn("ZIndexInjection", `Looks like you are using server rendering, you must provide a z-index provider to ensure the hydration process to be succeed
usage: app.provide(ZINDEX_INJECTION_KEY, { current: 0 })`);
    }
    return {
      initialZIndex,
      currentZIndex,
      nextZIndex
    };
  };

  /**
   * Custom positioning reference element.
   * @see https://floating-ui.com/docs/virtual-elements
   */

  const sides = ['top', 'right', 'bottom', 'left'];
  const alignments = ['start', 'end'];
  const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
  const min$3 = Math.min;
  const max$3 = Math.max;
  const round$1 = Math.round;
  const createCoords = v => ({
    x: v,
    y: v
  });
  const oppositeSideMap = {
    left: 'right',
    right: 'left',
    bottom: 'top',
    top: 'bottom'
  };
  const oppositeAlignmentMap = {
    start: 'end',
    end: 'start'
  };
  function clamp(start, value, end) {
    return max$3(start, min$3(value, end));
  }
  function evaluate(value, param) {
    return typeof value === 'function' ? value(param) : value;
  }
  function getSide$1(placement) {
    return placement.split('-')[0];
  }
  function getAlignment$1(placement) {
    return placement.split('-')[1];
  }
  function getOppositeAxis(axis) {
    return axis === 'x' ? 'y' : 'x';
  }
  function getAxisLength(axis) {
    return axis === 'y' ? 'height' : 'width';
  }
  function getSideAxis(placement) {
    return ['top', 'bottom'].includes(getSide$1(placement)) ? 'y' : 'x';
  }
  function getAlignmentAxis(placement) {
    return getOppositeAxis(getSideAxis(placement));
  }
  function getAlignmentSides$1(placement, rects, rtl) {
    if (rtl === void 0) {
      rtl = false;
    }
    const alignment = getAlignment$1(placement);
    const alignmentAxis = getAlignmentAxis(placement);
    const length = getAxisLength(alignmentAxis);
    let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
    if (rects.reference[length] > rects.floating[length]) {
      mainAlignmentSide = getOppositePlacement$1(mainAlignmentSide);
    }
    return [mainAlignmentSide, getOppositePlacement$1(mainAlignmentSide)];
  }
  function getExpandedPlacements$1(placement) {
    const oppositePlacement = getOppositePlacement$1(placement);
    return [getOppositeAlignmentPlacement$1(placement), oppositePlacement, getOppositeAlignmentPlacement$1(oppositePlacement)];
  }
  function getOppositeAlignmentPlacement$1(placement) {
    return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
  }
  function getSideList(side, isStart, rtl) {
    const lr = ['left', 'right'];
    const rl = ['right', 'left'];
    const tb = ['top', 'bottom'];
    const bt = ['bottom', 'top'];
    switch (side) {
      case 'top':
      case 'bottom':
        if (rtl) return isStart ? rl : lr;
        return isStart ? lr : rl;
      case 'left':
      case 'right':
        return isStart ? tb : bt;
      default:
        return [];
    }
  }
  function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
    const alignment = getAlignment$1(placement);
    let list = getSideList(getSide$1(placement), direction === 'start', rtl);
    if (alignment) {
      list = list.map(side => side + "-" + alignment);
      if (flipAlignment) {
        list = list.concat(list.map(getOppositeAlignmentPlacement$1));
      }
    }
    return list;
  }
  function getOppositePlacement$1(placement) {
    return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
  }
  function expandPaddingObject$1(padding) {
    return {
      top: 0,
      right: 0,
      bottom: 0,
      left: 0,
      ...padding
    };
  }
  function getPaddingObject(padding) {
    return typeof padding !== 'number' ? expandPaddingObject$1(padding) : {
      top: padding,
      right: padding,
      bottom: padding,
      left: padding
    };
  }
  function rectToClientRect$1(rect) {
    const {
      x,
      y,
      width,
      height
    } = rect;
    return {
      width,
      height,
      top: y,
      left: x,
      right: x + width,
      bottom: y + height,
      x,
      y
    };
  }

  function computeCoordsFromPlacement$1(_ref, placement, rtl) {
    let {
      reference,
      floating
    } = _ref;
    const sideAxis = getSideAxis(placement);
    const alignmentAxis = getAlignmentAxis(placement);
    const alignLength = getAxisLength(alignmentAxis);
    const side = getSide$1(placement);
    const isVertical = sideAxis === 'y';
    const commonX = reference.x + reference.width / 2 - floating.width / 2;
    const commonY = reference.y + reference.height / 2 - floating.height / 2;
    const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
    let coords;
    switch (side) {
      case 'top':
        coords = {
          x: commonX,
          y: reference.y - floating.height
        };
        break;
      case 'bottom':
        coords = {
          x: commonX,
          y: reference.y + reference.height
        };
        break;
      case 'right':
        coords = {
          x: reference.x + reference.width,
          y: commonY
        };
        break;
      case 'left':
        coords = {
          x: reference.x - floating.width,
          y: commonY
        };
        break;
      default:
        coords = {
          x: reference.x,
          y: reference.y
        };
    }
    switch (getAlignment$1(placement)) {
      case 'start':
        coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
        break;
      case 'end':
        coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
        break;
    }
    return coords;
  }

  /**
   * Computes the `x` and `y` coordinates that will place the floating element
   * next to a given reference element.
   *
   * This export does not have any `platform` interface logic. You will need to
   * write one for the platform you are using Floating UI with.
   */
  const computePosition$3 = async (reference, floating, config) => {
    const {
      placement = 'bottom',
      strategy = 'absolute',
      middleware = [],
      platform
    } = config;
    const validMiddleware = middleware.filter(Boolean);
    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
    let rects = await platform.getElementRects({
      reference,
      floating,
      strategy
    });
    let {
      x,
      y
    } = computeCoordsFromPlacement$1(rects, placement, rtl);
    let statefulPlacement = placement;
    let middlewareData = {};
    let resetCount = 0;
    for (let i = 0; i < validMiddleware.length; i++) {
      const {
        name,
        fn
      } = validMiddleware[i];
      const {
        x: nextX,
        y: nextY,
        data,
        reset
      } = await fn({
        x,
        y,
        initialPlacement: placement,
        placement: statefulPlacement,
        strategy,
        middlewareData,
        rects,
        platform,
        elements: {
          reference,
          floating
        }
      });
      x = nextX != null ? nextX : x;
      y = nextY != null ? nextY : y;
      middlewareData = {
        ...middlewareData,
        [name]: {
          ...middlewareData[name],
          ...data
        }
      };
      if (reset && resetCount <= 50) {
        resetCount++;
        if (typeof reset === 'object') {
          if (reset.placement) {
            statefulPlacement = reset.placement;
          }
          if (reset.rects) {
            rects = reset.rects === true ? await platform.getElementRects({
              reference,
              floating,
              strategy
            }) : reset.rects;
          }
          ({
            x,
            y
          } = computeCoordsFromPlacement$1(rects, statefulPlacement, rtl));
        }
        i = -1;
      }
    }
    return {
      x,
      y,
      placement: statefulPlacement,
      strategy,
      middlewareData
    };
  };

  /**
   * Resolves with an object of overflow side offsets that determine how much the
   * element is overflowing a given clipping boundary on each side.
   * - positive = overflowing the boundary by that number of pixels
   * - negative = how many pixels left before it will overflow
   * - 0 = lies flush with the boundary
   * @see https://floating-ui.com/docs/detectOverflow
   */
  async function detectOverflow$1(state, options) {
    var _await$platform$isEle;
    if (options === void 0) {
      options = {};
    }
    const {
      x,
      y,
      platform,
      rects,
      elements,
      strategy
    } = state;
    const {
      boundary = 'clippingAncestors',
      rootBoundary = 'viewport',
      elementContext = 'floating',
      altBoundary = false,
      padding = 0
    } = evaluate(options, state);
    const paddingObject = getPaddingObject(padding);
    const altContext = elementContext === 'floating' ? 'reference' : 'floating';
    const element = elements[altBoundary ? altContext : elementContext];
    const clippingClientRect = rectToClientRect$1(await platform.getClippingRect({
      element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
      boundary,
      rootBoundary,
      strategy
    }));
    const rect = elementContext === 'floating' ? {
      x,
      y,
      width: rects.floating.width,
      height: rects.floating.height
    } : rects.reference;
    const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
    const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
      x: 1,
      y: 1
    } : {
      x: 1,
      y: 1
    };
    const elementClientRect = rectToClientRect$1(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
      elements,
      rect,
      offsetParent,
      strategy
    }) : rect);
    return {
      top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
      bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
      left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
      right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
    };
  }

  /**
   * Provides data to position an inner element of the floating element so that it
   * appears centered to the reference element.
   * @see https://floating-ui.com/docs/arrow
   */
  const arrow$2 = options => ({
    name: 'arrow',
    options,
    async fn(state) {
      const {
        x,
        y,
        placement,
        rects,
        platform,
        elements,
        middlewareData
      } = state;
      // Since `element` is required, we don't Partial<> the type.
      const {
        element,
        padding = 0
      } = evaluate(options, state) || {};
      if (element == null) {
        return {};
      }
      const paddingObject = getPaddingObject(padding);
      const coords = {
        x,
        y
      };
      const axis = getAlignmentAxis(placement);
      const length = getAxisLength(axis);
      const arrowDimensions = await platform.getDimensions(element);
      const isYAxis = axis === 'y';
      const minProp = isYAxis ? 'top' : 'left';
      const maxProp = isYAxis ? 'bottom' : 'right';
      const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
      const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
      const startDiff = coords[axis] - rects.reference[axis];
      const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
      let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;

      // DOM platform can return `window` as the `offsetParent`.
      if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {
        clientSize = elements.floating[clientProp] || rects.floating[length];
      }
      const centerToReference = endDiff / 2 - startDiff / 2;

      // If the padding is large enough that it causes the arrow to no longer be
      // centered, modify the padding so that it is centered.
      const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
      const minPadding = min$3(paddingObject[minProp], largestPossiblePadding);
      const maxPadding = min$3(paddingObject[maxProp], largestPossiblePadding);

      // Make sure the arrow doesn't overflow the floating element if the center
      // point is outside the floating element's bounds.
      const min$1 = minPadding;
      const max = clientSize - arrowDimensions[length] - maxPadding;
      const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
      const offset = clamp(min$1, center, max);

      // If the reference is small enough that the arrow's padding causes it to
      // to point to nothing for an aligned placement, adjust the offset of the
      // floating element itself. To ensure `shift()` continues to take action,
      // a single reset is performed when this is true.
      const shouldAddOffset = !middlewareData.arrow && getAlignment$1(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
      const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
      return {
        [axis]: coords[axis] + alignmentOffset,
        data: {
          [axis]: offset,
          centerOffset: center - offset - alignmentOffset,
          ...(shouldAddOffset && {
            alignmentOffset
          })
        },
        reset: shouldAddOffset
      };
    }
  });

  function getPlacementList(alignment, autoAlignment, allowedPlacements) {
    const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment$1(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment$1(placement) !== alignment)] : allowedPlacements.filter(placement => getSide$1(placement) === placement);
    return allowedPlacementsSortedByAlignment.filter(placement => {
      if (alignment) {
        return getAlignment$1(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement$1(placement) !== placement : false);
      }
      return true;
    });
  }
  /**
   * Optimizes the visibility of the floating element by choosing the placement
   * that has the most space available automatically, without needing to specify a
   * preferred placement. Alternative to `flip`.
   * @see https://floating-ui.com/docs/autoPlacement
   */
  const autoPlacement = function (options) {
    if (options === void 0) {
      options = {};
    }
    return {
      name: 'autoPlacement',
      options,
      async fn(state) {
        var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
        const {
          rects,
          middlewareData,
          placement,
          platform,
          elements
        } = state;
        const {
          crossAxis = false,
          alignment,
          allowedPlacements = placements,
          autoAlignment = true,
          ...detectOverflowOptions
        } = evaluate(options, state);
        const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
        const overflow = await detectOverflow$1(state, detectOverflowOptions);
        const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
        const currentPlacement = placements$1[currentIndex];
        if (currentPlacement == null) {
          return {};
        }
        const alignmentSides = getAlignmentSides$1(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));

        // Make `computeCoords` start from the right place.
        if (placement !== currentPlacement) {
          return {
            reset: {
              placement: placements$1[0]
            }
          };
        }
        const currentOverflows = [overflow[getSide$1(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
        const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {
          placement: currentPlacement,
          overflows: currentOverflows
        }];
        const nextPlacement = placements$1[currentIndex + 1];

        // There are more placements to check.
        if (nextPlacement) {
          return {
            data: {
              index: currentIndex + 1,
              overflows: allOverflows
            },
            reset: {
              placement: nextPlacement
            }
          };
        }
        const placementsSortedByMostSpace = allOverflows.map(d => {
          const alignment = getAlignment$1(d.placement);
          return [d.placement, alignment && crossAxis ?
          // Check along the mainAxis and main crossAxis side.
          d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :
          // Check only the mainAxis.
          d.overflows[0], d.overflows];
        }).sort((a, b) => a[1] - b[1]);
        const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,
        // Aligned placements should not check their opposite crossAxis
        // side.
        getAlignment$1(d[0]) ? 2 : 3).every(v => v <= 0));
        const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
        if (resetPlacement !== placement) {
          return {
            data: {
              index: currentIndex + 1,
              overflows: allOverflows
            },
            reset: {
              placement: resetPlacement
            }
          };
        }
        return {};
      }
    };
  };

  /**
   * Optimizes the visibility of the floating element by flipping the `placement`
   * in order to keep it in view when the preferred placement(s) will overflow the
   * clipping boundary. Alternative to `autoPlacement`.
   * @see https://floating-ui.com/docs/flip
   */
  const flip$1 = function (options) {
    if (options === void 0) {
      options = {};
    }
    return {
      name: 'flip',
      options,
      async fn(state) {
        var _middlewareData$arrow, _middlewareData$flip;
        const {
          placement,
          middlewareData,
          rects,
          initialPlacement,
          platform,
          elements
        } = state;
        const {
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = true,
          fallbackPlacements: specifiedFallbackPlacements,
          fallbackStrategy = 'bestFit',
          fallbackAxisSideDirection = 'none',
          flipAlignment = true,
          ...detectOverflowOptions
        } = evaluate(options, state);

        // If a reset by the arrow was caused due to an alignment offset being
        // added, we should skip any logic now since `flip()` has already done its
        // work.
        // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
        if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
          return {};
        }
        const side = getSide$1(placement);
        const initialSideAxis = getSideAxis(initialPlacement);
        const isBasePlacement = getSide$1(initialPlacement) === initialPlacement;
        const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement$1(initialPlacement)] : getExpandedPlacements$1(initialPlacement));
        const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
        if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
          fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
        }
        const placements = [initialPlacement, ...fallbackPlacements];
        const overflow = await detectOverflow$1(state, detectOverflowOptions);
        const overflows = [];
        let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
        if (checkMainAxis) {
          overflows.push(overflow[side]);
        }
        if (checkCrossAxis) {
          const sides = getAlignmentSides$1(placement, rects, rtl);
          overflows.push(overflow[sides[0]], overflow[sides[1]]);
        }
        overflowsData = [...overflowsData, {
          placement,
          overflows
        }];

        // One or more sides is overflowing.
        if (!overflows.every(side => side <= 0)) {
          var _middlewareData$flip2, _overflowsData$filter;
          const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
          const nextPlacement = placements[nextIndex];
          if (nextPlacement) {
            // Try next placement and re-run the lifecycle.
            return {
              data: {
                index: nextIndex,
                overflows: overflowsData
              },
              reset: {
                placement: nextPlacement
              }
            };
          }

          // First, find the candidates that fit on the mainAxis side of overflow,
          // then find the placement that fits the best on the main crossAxis side.
          let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;

          // Otherwise fallback.
          if (!resetPlacement) {
            switch (fallbackStrategy) {
              case 'bestFit':
                {
                  var _overflowsData$filter2;
                  const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
                    if (hasFallbackAxisSideDirection) {
                      const currentSideAxis = getSideAxis(d.placement);
                      return currentSideAxis === initialSideAxis ||
                      // Create a bias to the `y` side axis due to horizontal
                      // reading directions favoring greater width.
                      currentSideAxis === 'y';
                    }
                    return true;
                  }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
                  if (placement) {
                    resetPlacement = placement;
                  }
                  break;
                }
              case 'initialPlacement':
                resetPlacement = initialPlacement;
                break;
            }
          }
          if (placement !== resetPlacement) {
            return {
              reset: {
                placement: resetPlacement
              }
            };
          }
        }
        return {};
      }
    };
  };

  function getSideOffsets(overflow, rect) {
    return {
      top: overflow.top - rect.height,
      right: overflow.right - rect.width,
      bottom: overflow.bottom - rect.height,
      left: overflow.left - rect.width
    };
  }
  function isAnySideFullyClipped(overflow) {
    return sides.some(side => overflow[side] >= 0);
  }
  /**
   * Provides data to hide the floating element in applicable situations, such as
   * when it is not in the same clipping context as the reference element.
   * @see https://floating-ui.com/docs/hide
   */
  const hide = function (options) {
    if (options === void 0) {
      options = {};
    }
    return {
      name: 'hide',
      options,
      async fn(state) {
        const {
          rects
        } = state;
        const {
          strategy = 'referenceHidden',
          ...detectOverflowOptions
        } = evaluate(options, state);
        switch (strategy) {
          case 'referenceHidden':
            {
              const overflow = await detectOverflow$1(state, {
                ...detectOverflowOptions,
                elementContext: 'reference'
              });
              const offsets = getSideOffsets(overflow, rects.reference);
              return {
                data: {
                  referenceHiddenOffsets: offsets,
                  referenceHidden: isAnySideFullyClipped(offsets)
                }
              };
            }
          case 'escaped':
            {
              const overflow = await detectOverflow$1(state, {
                ...detectOverflowOptions,
                altBoundary: true
              });
              const offsets = getSideOffsets(overflow, rects.floating);
              return {
                data: {
                  escapedOffsets: offsets,
                  escaped: isAnySideFullyClipped(offsets)
                }
              };
            }
          default:
            {
              return {};
            }
        }
      }
    };
  };

  function getBoundingRect(rects) {
    const minX = min$3(...rects.map(rect => rect.left));
    const minY = min$3(...rects.map(rect => rect.top));
    const maxX = max$3(...rects.map(rect => rect.right));
    const maxY = max$3(...rects.map(rect => rect.bottom));
    return {
      x: minX,
      y: minY,
      width: maxX - minX,
      height: maxY - minY
    };
  }
  function getRectsByLine(rects) {
    const sortedRects = rects.slice().sort((a, b) => a.y - b.y);
    const groups = [];
    let prevRect = null;
    for (let i = 0; i < sortedRects.length; i++) {
      const rect = sortedRects[i];
      if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {
        groups.push([rect]);
      } else {
        groups[groups.length - 1].push(rect);
      }
      prevRect = rect;
    }
    return groups.map(rect => rectToClientRect$1(getBoundingRect(rect)));
  }
  /**
   * Provides improved positioning for inline reference elements that can span
   * over multiple lines, such as hyperlinks or range selections.
   * @see https://floating-ui.com/docs/inline
   */
  const inline = function (options) {
    if (options === void 0) {
      options = {};
    }
    return {
      name: 'inline',
      options,
      async fn(state) {
        const {
          placement,
          elements,
          rects,
          platform,
          strategy
        } = state;
        // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
        // ClientRect's bounds, despite the event listener being triggered. A
        // padding of 2 seems to handle this issue.
        const {
          padding = 2,
          x,
          y
        } = evaluate(options, state);
        const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);
        const clientRects = getRectsByLine(nativeClientRects);
        const fallback = rectToClientRect$1(getBoundingRect(nativeClientRects));
        const paddingObject = getPaddingObject(padding);
        function getBoundingClientRect() {
          // There are two rects and they are disjoined.
          if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {
            // Find the first rect in which the point is fully inside.
            return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
          }

          // There are 2 or more connected rects.
          if (clientRects.length >= 2) {
            if (getSideAxis(placement) === 'y') {
              const firstRect = clientRects[0];
              const lastRect = clientRects[clientRects.length - 1];
              const isTop = getSide$1(placement) === 'top';
              const top = firstRect.top;
              const bottom = lastRect.bottom;
              const left = isTop ? firstRect.left : lastRect.left;
              const right = isTop ? firstRect.right : lastRect.right;
              const width = right - left;
              const height = bottom - top;
              return {
                top,
                bottom,
                left,
                right,
                width,
                height,
                x: left,
                y: top
              };
            }
            const isLeftSide = getSide$1(placement) === 'left';
            const maxRight = max$3(...clientRects.map(rect => rect.right));
            const minLeft = min$3(...clientRects.map(rect => rect.left));
            const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
            const top = measureRects[0].top;
            const bottom = measureRects[measureRects.length - 1].bottom;
            const left = minLeft;
            const right = maxRight;
            const width = right - left;
            const height = bottom - top;
            return {
              top,
              bottom,
              left,
              right,
              width,
              height,
              x: left,
              y: top
            };
          }
          return fallback;
        }
        const resetRects = await platform.getElementRects({
          reference: {
            getBoundingClientRect
          },
          floating: elements.floating,
          strategy
        });
        if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {
          return {
            reset: {
              rects: resetRects
            }
          };
        }
        return {};
      }
    };
  };

  // For type backwards-compatibility, the `OffsetOptions` type was also
  // Derivable.

  async function convertValueToCoords$1(state, options) {
    const {
      placement,
      platform,
      elements
    } = state;
    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
    const side = getSide$1(placement);
    const alignment = getAlignment$1(placement);
    const isVertical = getSideAxis(placement) === 'y';
    const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
    const crossAxisMulti = rtl && isVertical ? -1 : 1;
    const rawValue = evaluate(options, state);

    // eslint-disable-next-line prefer-const
    let {
      mainAxis,
      crossAxis,
      alignmentAxis
    } = typeof rawValue === 'number' ? {
      mainAxis: rawValue,
      crossAxis: 0,
      alignmentAxis: null
    } : {
      mainAxis: 0,
      crossAxis: 0,
      alignmentAxis: null,
      ...rawValue
    };
    if (alignment && typeof alignmentAxis === 'number') {
      crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
    }
    return isVertical ? {
      x: crossAxis * crossAxisMulti,
      y: mainAxis * mainAxisMulti
    } : {
      x: mainAxis * mainAxisMulti,
      y: crossAxis * crossAxisMulti
    };
  }

  /**
   * Modifies the placement by translating the floating element along the
   * specified axes.
   * A number (shorthand for `mainAxis` or distance), or an axes configuration
   * object may be passed.
   * @see https://floating-ui.com/docs/offset
   */
  const offset$1 = function (options) {
    if (options === void 0) {
      options = 0;
    }
    return {
      name: 'offset',
      options,
      async fn(state) {
        var _middlewareData$offse, _middlewareData$arrow;
        const {
          x,
          y,
          placement,
          middlewareData
        } = state;
        const diffCoords = await convertValueToCoords$1(state, options);

        // If the placement is the same and the arrow caused an alignment offset
        // then we don't need to change the positioning coordinates.
        if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
          return {};
        }
        return {
          x: x + diffCoords.x,
          y: y + diffCoords.y,
          data: {
            ...diffCoords,
            placement
          }
        };
      }
    };
  };

  /**
   * Optimizes the visibility of the floating element by shifting it in order to
   * keep it in view when it will overflow the clipping boundary.
   * @see https://floating-ui.com/docs/shift
   */
  const shift$1 = function (options) {
    if (options === void 0) {
      options = {};
    }
    return {
      name: 'shift',
      options,
      async fn(state) {
        const {
          x,
          y,
          placement
        } = state;
        const {
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = false,
          limiter = {
            fn: _ref => {
              let {
                x,
                y
              } = _ref;
              return {
                x,
                y
              };
            }
          },
          ...detectOverflowOptions
        } = evaluate(options, state);
        const coords = {
          x,
          y
        };
        const overflow = await detectOverflow$1(state, detectOverflowOptions);
        const crossAxis = getSideAxis(getSide$1(placement));
        const mainAxis = getOppositeAxis(crossAxis);
        let mainAxisCoord = coords[mainAxis];
        let crossAxisCoord = coords[crossAxis];
        if (checkMainAxis) {
          const minSide = mainAxis === 'y' ? 'top' : 'left';
          const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
          const min = mainAxisCoord + overflow[minSide];
          const max = mainAxisCoord - overflow[maxSide];
          mainAxisCoord = clamp(min, mainAxisCoord, max);
        }
        if (checkCrossAxis) {
          const minSide = crossAxis === 'y' ? 'top' : 'left';
          const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
          const min = crossAxisCoord + overflow[minSide];
          const max = crossAxisCoord - overflow[maxSide];
          crossAxisCoord = clamp(min, crossAxisCoord, max);
        }
        const limitedCoords = limiter.fn({
          ...state,
          [mainAxis]: mainAxisCoord,
          [crossAxis]: crossAxisCoord
        });
        return {
          ...limitedCoords,
          data: {
            x: limitedCoords.x - x,
            y: limitedCoords.y - y
          }
        };
      }
    };
  };
  /**
   * Built-in `limiter` that will stop `shift()` at a certain point.
   */
  const limitShift = function (options) {
    if (options === void 0) {
      options = {};
    }
    return {
      options,
      fn(state) {
        const {
          x,
          y,
          placement,
          rects,
          middlewareData
        } = state;
        const {
          offset = 0,
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = true
        } = evaluate(options, state);
        const coords = {
          x,
          y
        };
        const crossAxis = getSideAxis(placement);
        const mainAxis = getOppositeAxis(crossAxis);
        let mainAxisCoord = coords[mainAxis];
        let crossAxisCoord = coords[crossAxis];
        const rawOffset = evaluate(offset, state);
        const computedOffset = typeof rawOffset === 'number' ? {
          mainAxis: rawOffset,
          crossAxis: 0
        } : {
          mainAxis: 0,
          crossAxis: 0,
          ...rawOffset
        };
        if (checkMainAxis) {
          const len = mainAxis === 'y' ? 'height' : 'width';
          const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
          const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
          if (mainAxisCoord < limitMin) {
            mainAxisCoord = limitMin;
          } else if (mainAxisCoord > limitMax) {
            mainAxisCoord = limitMax;
          }
        }
        if (checkCrossAxis) {
          var _middlewareData$offse, _middlewareData$offse2;
          const len = mainAxis === 'y' ? 'width' : 'height';
          const isOriginSide = ['top', 'left'].includes(getSide$1(placement));
          const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
          const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
          if (crossAxisCoord < limitMin) {
            crossAxisCoord = limitMin;
          } else if (crossAxisCoord > limitMax) {
            crossAxisCoord = limitMax;
          }
        }
        return {
          [mainAxis]: mainAxisCoord,
          [crossAxis]: crossAxisCoord
        };
      }
    };
  };

  /**
   * Provides data that allows you to change the size of the floating element —
   * for instance, prevent it from overflowing the clipping boundary or match the
   * width of the reference element.
   * @see https://floating-ui.com/docs/size
   */
  const size = function (options) {
    if (options === void 0) {
      options = {};
    }
    return {
      name: 'size',
      options,
      async fn(state) {
        const {
          placement,
          rects,
          platform,
          elements
        } = state;
        const {
          apply = () => {},
          ...detectOverflowOptions
        } = evaluate(options, state);
        const overflow = await detectOverflow$1(state, detectOverflowOptions);
        const side = getSide$1(placement);
        const alignment = getAlignment$1(placement);
        const isYAxis = getSideAxis(placement) === 'y';
        const {
          width,
          height
        } = rects.floating;
        let heightSide;
        let widthSide;
        if (side === 'top' || side === 'bottom') {
          heightSide = side;
          widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';
        } else {
          widthSide = side;
          heightSide = alignment === 'end' ? 'top' : 'bottom';
        }
        const maximumClippingHeight = height - overflow.top - overflow.bottom;
        const maximumClippingWidth = width - overflow.left - overflow.right;
        const overflowAvailableHeight = min$3(height - overflow[heightSide], maximumClippingHeight);
        const overflowAvailableWidth = min$3(width - overflow[widthSide], maximumClippingWidth);
        const noShift = !state.middlewareData.shift;
        let availableHeight = overflowAvailableHeight;
        let availableWidth = overflowAvailableWidth;
        if (isYAxis) {
          availableWidth = alignment || noShift ? min$3(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
        } else {
          availableHeight = alignment || noShift ? min$3(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
        }
        if (noShift && !alignment) {
          const xMin = max$3(overflow.left, 0);
          const xMax = max$3(overflow.right, 0);
          const yMin = max$3(overflow.top, 0);
          const yMax = max$3(overflow.bottom, 0);
          if (isYAxis) {
            availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$3(overflow.left, overflow.right));
          } else {
            availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$3(overflow.top, overflow.bottom));
          }
        }
        await apply({
          ...state,
          availableWidth,
          availableHeight
        });
        const nextDimensions = await platform.getDimensions(elements.floating);
        if (width !== nextDimensions.width || height !== nextDimensions.height) {
          return {
            reset: {
              rects: true
            }
          };
        }
        return {};
      }
    };
  };

  function getNodeName$1(node) {
    if (isNode$1(node)) {
      return (node.nodeName || '').toLowerCase();
    }
    // Mocked nodes in testing environments may not be instances of Node. By
    // returning `#document` an infinite loop won't occur.
    // https://github.com/floating-ui/floating-ui/issues/2317
    return '#document';
  }
  function getWindow$1(node) {
    var _node$ownerDocument;
    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
  }
  function getDocumentElement$1(node) {
    var _ref;
    return (_ref = (isNode$1(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
  }
  function isNode$1(value) {
    return value instanceof Node || value instanceof getWindow$1(value).Node;
  }
  function isElement$1(value) {
    return value instanceof Element || value instanceof getWindow$1(value).Element;
  }
  function isHTMLElement$1(value) {
    return value instanceof HTMLElement || value instanceof getWindow$1(value).HTMLElement;
  }
  function isShadowRoot$1(value) {
    // Browsers without `ShadowRoot` support.
    if (typeof ShadowRoot === 'undefined') {
      return false;
    }
    return value instanceof ShadowRoot || value instanceof getWindow$1(value).ShadowRoot;
  }
  function isOverflowElement$1(element) {
    const {
      overflow,
      overflowX,
      overflowY,
      display
    } = getComputedStyle$2(element);
    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
  }
  function isTableElement$1(element) {
    return ['table', 'td', 'th'].includes(getNodeName$1(element));
  }
  function isTopLayer(element) {
    return [':popover-open', ':modal'].some(selector => {
      try {
        return element.matches(selector);
      } catch (e) {
        return false;
      }
    });
  }
  function isContainingBlock$1(elementOrCss) {
    const webkit = isWebKit();
    const css = isElement$1(elementOrCss) ? getComputedStyle$2(elementOrCss) : elementOrCss;

    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
    return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
  }
  function getContainingBlock$1(element) {
    let currentNode = getParentNode$1(element);
    while (isHTMLElement$1(currentNode) && !isLastTraversableNode(currentNode)) {
      if (isContainingBlock$1(currentNode)) {
        return currentNode;
      } else if (isTopLayer(currentNode)) {
        return null;
      }
      currentNode = getParentNode$1(currentNode);
    }
    return null;
  }
  function isWebKit() {
    if (typeof CSS === 'undefined' || !CSS.supports) return false;
    return CSS.supports('-webkit-backdrop-filter', 'none');
  }
  function isLastTraversableNode(node) {
    return ['html', 'body', '#document'].includes(getNodeName$1(node));
  }
  function getComputedStyle$2(element) {
    return getWindow$1(element).getComputedStyle(element);
  }
  function getNodeScroll$1(element) {
    if (isElement$1(element)) {
      return {
        scrollLeft: element.scrollLeft,
        scrollTop: element.scrollTop
      };
    }
    return {
      scrollLeft: element.scrollX,
      scrollTop: element.scrollY
    };
  }
  function getParentNode$1(node) {
    if (getNodeName$1(node) === 'html') {
      return node;
    }
    const result =
    // Step into the shadow DOM of the parent of a slotted node.
    node.assignedSlot ||
    // DOM Element detected.
    node.parentNode ||
    // ShadowRoot detected.
    isShadowRoot$1(node) && node.host ||
    // Fallback.
    getDocumentElement$1(node);
    return isShadowRoot$1(result) ? result.host : result;
  }
  function getNearestOverflowAncestor$1(node) {
    const parentNode = getParentNode$1(node);
    if (isLastTraversableNode(parentNode)) {
      return node.ownerDocument ? node.ownerDocument.body : node.body;
    }
    if (isHTMLElement$1(parentNode) && isOverflowElement$1(parentNode)) {
      return parentNode;
    }
    return getNearestOverflowAncestor$1(parentNode);
  }
  function getOverflowAncestors$1(node, list, traverseIframes) {
    var _node$ownerDocument2;
    if (list === void 0) {
      list = [];
    }
    if (traverseIframes === void 0) {
      traverseIframes = true;
    }
    const scrollableAncestor = getNearestOverflowAncestor$1(node);
    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
    const win = getWindow$1(scrollableAncestor);
    if (isBody) {
      return list.concat(win, win.visualViewport || [], isOverflowElement$1(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors$1(win.frameElement) : []);
    }
    return list.concat(scrollableAncestor, getOverflowAncestors$1(scrollableAncestor, [], traverseIframes));
  }

  function getCssDimensions(element) {
    const css = getComputedStyle$2(element);
    // In testing environments, the `width` and `height` properties are empty
    // strings for SVG elements, returning NaN. Fallback to `0` in this case.
    let width = parseFloat(css.width) || 0;
    let height = parseFloat(css.height) || 0;
    const hasOffset = isHTMLElement$1(element);
    const offsetWidth = hasOffset ? element.offsetWidth : width;
    const offsetHeight = hasOffset ? element.offsetHeight : height;
    const shouldFallback = round$1(width) !== offsetWidth || round$1(height) !== offsetHeight;
    if (shouldFallback) {
      width = offsetWidth;
      height = offsetHeight;
    }
    return {
      width,
      height,
      $: shouldFallback
    };
  }

  function unwrapElement(element) {
    return !isElement$1(element) ? element.contextElement : element;
  }

  function getScale(element) {
    const domElement = unwrapElement(element);
    if (!isHTMLElement$1(domElement)) {
      return createCoords(1);
    }
    const rect = domElement.getBoundingClientRect();
    const {
      width,
      height,
      $
    } = getCssDimensions(domElement);
    let x = ($ ? round$1(rect.width) : rect.width) / width;
    let y = ($ ? round$1(rect.height) : rect.height) / height;

    // 0, NaN, or Infinity should always fallback to 1.

    if (!x || !Number.isFinite(x)) {
      x = 1;
    }
    if (!y || !Number.isFinite(y)) {
      y = 1;
    }
    return {
      x,
      y
    };
  }

  const noOffsets = /*#__PURE__*/createCoords(0);
  function getVisualOffsets(element) {
    const win = getWindow$1(element);
    if (!isWebKit() || !win.visualViewport) {
      return noOffsets;
    }
    return {
      x: win.visualViewport.offsetLeft,
      y: win.visualViewport.offsetTop
    };
  }
  function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
    if (isFixed === void 0) {
      isFixed = false;
    }
    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow$1(element)) {
      return false;
    }
    return isFixed;
  }

  function getBoundingClientRect$1(element, includeScale, isFixedStrategy, offsetParent) {
    if (includeScale === void 0) {
      includeScale = false;
    }
    if (isFixedStrategy === void 0) {
      isFixedStrategy = false;
    }
    const clientRect = element.getBoundingClientRect();
    const domElement = unwrapElement(element);
    let scale = createCoords(1);
    if (includeScale) {
      if (offsetParent) {
        if (isElement$1(offsetParent)) {
          scale = getScale(offsetParent);
        }
      } else {
        scale = getScale(element);
      }
    }
    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
    let x = (clientRect.left + visualOffsets.x) / scale.x;
    let y = (clientRect.top + visualOffsets.y) / scale.y;
    let width = clientRect.width / scale.x;
    let height = clientRect.height / scale.y;
    if (domElement) {
      const win = getWindow$1(domElement);
      const offsetWin = offsetParent && isElement$1(offsetParent) ? getWindow$1(offsetParent) : offsetParent;
      let currentWin = win;
      let currentIFrame = currentWin.frameElement;
      while (currentIFrame && offsetParent && offsetWin !== currentWin) {
        const iframeScale = getScale(currentIFrame);
        const iframeRect = currentIFrame.getBoundingClientRect();
        const css = getComputedStyle$2(currentIFrame);
        const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
        const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
        x *= iframeScale.x;
        y *= iframeScale.y;
        width *= iframeScale.x;
        height *= iframeScale.y;
        x += left;
        y += top;
        currentWin = getWindow$1(currentIFrame);
        currentIFrame = currentWin.frameElement;
      }
    }
    return rectToClientRect$1({
      width,
      height,
      x,
      y
    });
  }

  function convertOffsetParentRelativeRectToViewportRelativeRect$1(_ref) {
    let {
      elements,
      rect,
      offsetParent,
      strategy
    } = _ref;
    const isFixed = strategy === 'fixed';
    const documentElement = getDocumentElement$1(offsetParent);
    const topLayer = elements ? isTopLayer(elements.floating) : false;
    if (offsetParent === documentElement || topLayer && isFixed) {
      return rect;
    }
    let scroll = {
      scrollLeft: 0,
      scrollTop: 0
    };
    let scale = createCoords(1);
    const offsets = createCoords(0);
    const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
      if (getNodeName$1(offsetParent) !== 'body' || isOverflowElement$1(documentElement)) {
        scroll = getNodeScroll$1(offsetParent);
      }
      if (isHTMLElement$1(offsetParent)) {
        const offsetRect = getBoundingClientRect$1(offsetParent);
        scale = getScale(offsetParent);
        offsets.x = offsetRect.x + offsetParent.clientLeft;
        offsets.y = offsetRect.y + offsetParent.clientTop;
      }
    }
    return {
      width: rect.width * scale.x,
      height: rect.height * scale.y,
      x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
      y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
    };
  }

  function getClientRects(element) {
    return Array.from(element.getClientRects());
  }

  function getWindowScrollBarX$1(element) {
    // If <html> has a CSS width greater than the viewport, then this will be
    // incorrect for RTL.
    return getBoundingClientRect$1(getDocumentElement$1(element)).left + getNodeScroll$1(element).scrollLeft;
  }

  // Gets the entire size of the scrollable document area, even extending outside
  // of the `<html>` and `<body>` rect bounds if horizontally scrollable.
  function getDocumentRect$1(element) {
    const html = getDocumentElement$1(element);
    const scroll = getNodeScroll$1(element);
    const body = element.ownerDocument.body;
    const width = max$3(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
    const height = max$3(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
    let x = -scroll.scrollLeft + getWindowScrollBarX$1(element);
    const y = -scroll.scrollTop;
    if (getComputedStyle$2(body).direction === 'rtl') {
      x += max$3(html.clientWidth, body.clientWidth) - width;
    }
    return {
      width,
      height,
      x,
      y
    };
  }

  function getViewportRect$1(element, strategy) {
    const win = getWindow$1(element);
    const html = getDocumentElement$1(element);
    const visualViewport = win.visualViewport;
    let width = html.clientWidth;
    let height = html.clientHeight;
    let x = 0;
    let y = 0;
    if (visualViewport) {
      width = visualViewport.width;
      height = visualViewport.height;
      const visualViewportBased = isWebKit();
      if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
        x = visualViewport.offsetLeft;
        y = visualViewport.offsetTop;
      }
    }
    return {
      width,
      height,
      x,
      y
    };
  }

  // Returns the inner client rect, subtracting scrollbars if present.
  function getInnerBoundingClientRect$1(element, strategy) {
    const clientRect = getBoundingClientRect$1(element, true, strategy === 'fixed');
    const top = clientRect.top + element.clientTop;
    const left = clientRect.left + element.clientLeft;
    const scale = isHTMLElement$1(element) ? getScale(element) : createCoords(1);
    const width = element.clientWidth * scale.x;
    const height = element.clientHeight * scale.y;
    const x = left * scale.x;
    const y = top * scale.y;
    return {
      width,
      height,
      x,
      y
    };
  }
  function getClientRectFromClippingAncestor$1(element, clippingAncestor, strategy) {
    let rect;
    if (clippingAncestor === 'viewport') {
      rect = getViewportRect$1(element, strategy);
    } else if (clippingAncestor === 'document') {
      rect = getDocumentRect$1(getDocumentElement$1(element));
    } else if (isElement$1(clippingAncestor)) {
      rect = getInnerBoundingClientRect$1(clippingAncestor, strategy);
    } else {
      const visualOffsets = getVisualOffsets(element);
      rect = {
        ...clippingAncestor,
        x: clippingAncestor.x - visualOffsets.x,
        y: clippingAncestor.y - visualOffsets.y
      };
    }
    return rectToClientRect$1(rect);
  }
  function hasFixedPositionAncestor(element, stopNode) {
    const parentNode = getParentNode$1(element);
    if (parentNode === stopNode || !isElement$1(parentNode) || isLastTraversableNode(parentNode)) {
      return false;
    }
    return getComputedStyle$2(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
  }

  // A "clipping ancestor" is an `overflow` element with the characteristic of
  // clipping (or hiding) child elements. This returns all clipping ancestors
  // of the given element up the tree.
  function getClippingElementAncestors(element, cache) {
    const cachedResult = cache.get(element);
    if (cachedResult) {
      return cachedResult;
    }
    let result = getOverflowAncestors$1(element, [], false).filter(el => isElement$1(el) && getNodeName$1(el) !== 'body');
    let currentContainingBlockComputedStyle = null;
    const elementIsFixed = getComputedStyle$2(element).position === 'fixed';
    let currentNode = elementIsFixed ? getParentNode$1(element) : element;

    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
    while (isElement$1(currentNode) && !isLastTraversableNode(currentNode)) {
      const computedStyle = getComputedStyle$2(currentNode);
      const currentNodeIsContaining = isContainingBlock$1(currentNode);
      if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
        currentContainingBlockComputedStyle = null;
      }
      const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement$1(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
      if (shouldDropCurrentNode) {
        // Drop non-containing blocks.
        result = result.filter(ancestor => ancestor !== currentNode);
      } else {
        // Record last containing block for next iteration.
        currentContainingBlockComputedStyle = computedStyle;
      }
      currentNode = getParentNode$1(currentNode);
    }
    cache.set(element, result);
    return result;
  }

  // Gets the maximum area that the element is visible in due to any number of
  // clipping ancestors.
  function getClippingRect$1(_ref) {
    let {
      element,
      boundary,
      rootBoundary,
      strategy
    } = _ref;
    const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
    const clippingAncestors = [...elementClippingAncestors, rootBoundary];
    const firstClippingAncestor = clippingAncestors[0];
    const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
      const rect = getClientRectFromClippingAncestor$1(element, clippingAncestor, strategy);
      accRect.top = max$3(rect.top, accRect.top);
      accRect.right = min$3(rect.right, accRect.right);
      accRect.bottom = min$3(rect.bottom, accRect.bottom);
      accRect.left = max$3(rect.left, accRect.left);
      return accRect;
    }, getClientRectFromClippingAncestor$1(element, firstClippingAncestor, strategy));
    return {
      width: clippingRect.right - clippingRect.left,
      height: clippingRect.bottom - clippingRect.top,
      x: clippingRect.left,
      y: clippingRect.top
    };
  }

  function getDimensions$1(element) {
    const {
      width,
      height
    } = getCssDimensions(element);
    return {
      width,
      height
    };
  }

  function getRectRelativeToOffsetParent$1(element, offsetParent, strategy) {
    const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
    const documentElement = getDocumentElement$1(offsetParent);
    const isFixed = strategy === 'fixed';
    const rect = getBoundingClientRect$1(element, true, isFixed, offsetParent);
    let scroll = {
      scrollLeft: 0,
      scrollTop: 0
    };
    const offsets = createCoords(0);
    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
      if (getNodeName$1(offsetParent) !== 'body' || isOverflowElement$1(documentElement)) {
        scroll = getNodeScroll$1(offsetParent);
      }
      if (isOffsetParentAnElement) {
        const offsetRect = getBoundingClientRect$1(offsetParent, true, isFixed, offsetParent);
        offsets.x = offsetRect.x + offsetParent.clientLeft;
        offsets.y = offsetRect.y + offsetParent.clientTop;
      } else if (documentElement) {
        offsets.x = getWindowScrollBarX$1(documentElement);
      }
    }
    const x = rect.left + scroll.scrollLeft - offsets.x;
    const y = rect.top + scroll.scrollTop - offsets.y;
    return {
      x,
      y,
      width: rect.width,
      height: rect.height
    };
  }

  function isStaticPositioned(element) {
    return getComputedStyle$2(element).position === 'static';
  }

  function getTrueOffsetParent$1(element, polyfill) {
    if (!isHTMLElement$1(element) || getComputedStyle$2(element).position === 'fixed') {
      return null;
    }
    if (polyfill) {
      return polyfill(element);
    }
    return element.offsetParent;
  }

  // Gets the closest ancestor positioned element. Handles some edge cases,
  // such as table ancestors and cross browser bugs.
  function getOffsetParent$1(element, polyfill) {
    const win = getWindow$1(element);
    if (isTopLayer(element)) {
      return win;
    }
    if (!isHTMLElement$1(element)) {
      let svgOffsetParent = getParentNode$1(element);
      while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
        if (isElement$1(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
          return svgOffsetParent;
        }
        svgOffsetParent = getParentNode$1(svgOffsetParent);
      }
      return win;
    }
    let offsetParent = getTrueOffsetParent$1(element, polyfill);
    while (offsetParent && isTableElement$1(offsetParent) && isStaticPositioned(offsetParent)) {
      offsetParent = getTrueOffsetParent$1(offsetParent, polyfill);
    }
    if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock$1(offsetParent)) {
      return win;
    }
    return offsetParent || getContainingBlock$1(element) || win;
  }

  const getElementRects = async function (data) {
    const getOffsetParentFn = this.getOffsetParent || getOffsetParent$1;
    const getDimensionsFn = this.getDimensions;
    const floatingDimensions = await getDimensionsFn(data.floating);
    return {
      reference: getRectRelativeToOffsetParent$1(data.reference, await getOffsetParentFn(data.floating), data.strategy),
      floating: {
        x: 0,
        y: 0,
        width: floatingDimensions.width,
        height: floatingDimensions.height
      }
    };
  };

  function isRTL$1(element) {
    return getComputedStyle$2(element).direction === 'rtl';
  }

  const platform$1 = {
    convertOffsetParentRelativeRectToViewportRelativeRect: convertOffsetParentRelativeRectToViewportRelativeRect$1,
    getDocumentElement: getDocumentElement$1,
    getClippingRect: getClippingRect$1,
    getOffsetParent: getOffsetParent$1,
    getElementRects,
    getClientRects,
    getDimensions: getDimensions$1,
    getScale,
    isElement: isElement$1,
    isRTL: isRTL$1
  };

  /**
   * Modifies the placement by translating the floating element along the
   * specified axes.
   * A number (shorthand for `mainAxis` or distance), or an axes configuration
   * object may be passed.
   * @see https://floating-ui.com/docs/offset
   */
  offset$1;

  /**
   * Optimizes the visibility of the floating element by choosing the placement
   * that has the most space available automatically, without needing to specify a
   * preferred placement. Alternative to `flip`.
   * @see https://floating-ui.com/docs/autoPlacement
   */
  autoPlacement;

  /**
   * Optimizes the visibility of the floating element by shifting it in order to
   * keep it in view when it will overflow the clipping boundary.
   * @see https://floating-ui.com/docs/shift
   */
  shift$1;

  /**
   * Optimizes the visibility of the floating element by flipping the `placement`
   * in order to keep it in view when the preferred placement(s) will overflow the
   * clipping boundary. Alternative to `autoPlacement`.
   * @see https://floating-ui.com/docs/flip
   */
  flip$1;

  /**
   * Provides data that allows you to change the size of the floating element —
   * for instance, prevent it from overflowing the clipping boundary or match the
   * width of the reference element.
   * @see https://floating-ui.com/docs/size
   */
  size;

  /**
   * Provides data to hide the floating element in applicable situations, such as
   * when it is not in the same clipping context as the reference element.
   * @see https://floating-ui.com/docs/hide
   */
  hide;

  /**
   * Provides data to position an inner element of the floating element so that it
   * appears centered to the reference element.
   * @see https://floating-ui.com/docs/arrow
   */
  const arrow$1 = arrow$2;

  /**
   * Provides improved positioning for inline reference elements that can span
   * over multiple lines, such as hyperlinks or range selections.
   * @see https://floating-ui.com/docs/inline
   */
  inline;

  /**
   * Built-in `limiter` that will stop `shift()` at a certain point.
   */
  limitShift;

  /**
   * Computes the `x` and `y` coordinates that will place the floating element
   * next to a given reference element.
   */
  const computePosition$2 = (reference, floating, options) => {
    // This caches the expensive `getClippingElementAncestors` function so that
    // multiple lifecycle resets re-use the same result. It only lives for a
    // single call. If other functions become expensive, we can add them as well.
    const cache = new Map();
    const mergedOptions = {
      platform: platform$1,
      ...options
    };
    const platformWithCache = {
      ...mergedOptions.platform,
      _c: cache
    };
    return computePosition$3(reference, floating, {
      ...mergedOptions,
      platform: platformWithCache
    });
  };

  const useFloatingProps = buildProps({});
  const unrefReference = (elRef) => {
    if (!isClient)
      return;
    if (!elRef)
      return elRef;
    const unrefEl = unrefElement(elRef);
    if (unrefEl)
      return unrefEl;
    return vue.isRef(elRef) ? unrefEl : elRef;
  };
  const getPositionDataWithUnit = (record, key) => {
    const value = record == null ? void 0 : record[key];
    return isNil(value) ? "" : `${value}px`;
  };
  const useFloating$1 = ({
    middleware,
    placement,
    strategy
  }) => {
    const referenceRef = vue.ref();
    const contentRef = vue.ref();
    const x = vue.ref();
    const y = vue.ref();
    const middlewareData = vue.ref({});
    const states = {
      x,
      y,
      placement,
      strategy,
      middlewareData
    };
    const update = async () => {
      if (!isClient)
        return;
      const referenceEl = unrefReference(referenceRef);
      const contentEl = unrefElement(contentRef);
      if (!referenceEl || !contentEl)
        return;
      const data = await computePosition$2(referenceEl, contentEl, {
        placement: vue.unref(placement),
        strategy: vue.unref(strategy),
        middleware: vue.unref(middleware)
      });
      keysOf(states).forEach((key) => {
        states[key].value = data[key];
      });
    };
    vue.onMounted(() => {
      vue.watchEffect(() => {
        update();
      });
    });
    return {
      ...states,
      update,
      referenceRef,
      contentRef
    };
  };
  const arrowMiddleware = ({
    arrowRef,
    padding
  }) => {
    return {
      name: "arrow",
      options: {
        element: arrowRef,
        padding
      },
      fn(args) {
        const arrowEl = vue.unref(arrowRef);
        if (!arrowEl)
          return {};
        return arrow$1({
          element: arrowEl,
          padding
        }).fn(args);
      }
    };
  };

  function useCursor(input) {
    let selectionInfo;
    function recordCursor() {
      if (input.value == void 0)
        return;
      const { selectionStart, selectionEnd, value } = input.value;
      if (selectionStart == null || selectionEnd == null)
        return;
      const beforeTxt = value.slice(0, Math.max(0, selectionStart));
      const afterTxt = value.slice(Math.max(0, selectionEnd));
      selectionInfo = {
        selectionStart,
        selectionEnd,
        value,
        beforeTxt,
        afterTxt
      };
    }
    function setCursor() {
      if (input.value == void 0 || selectionInfo == void 0)
        return;
      const { value } = input.value;
      const { beforeTxt, afterTxt, selectionStart } = selectionInfo;
      if (beforeTxt == void 0 || afterTxt == void 0 || selectionStart == void 0)
        return;
      let startPos = value.length;
      if (value.endsWith(afterTxt)) {
        startPos = value.length - afterTxt.length;
      } else if (value.startsWith(beforeTxt)) {
        startPos = beforeTxt.length;
      } else {
        const beforeLastChar = beforeTxt[selectionStart - 1];
        const newIndex = value.indexOf(beforeLastChar, selectionStart - 1);
        if (newIndex !== -1) {
          startPos = newIndex + 1;
        }
      }
      input.value.setSelectionRange(startPos, startPos);
    }
    return [recordCursor, setCursor];
  }

  const getOrderedChildren = (vm, childComponentName, children) => {
    const nodes = flattedChildren(vm.subTree).filter((n) => {
      var _a;
      return vue.isVNode(n) && ((_a = n.type) == null ? void 0 : _a.name) === childComponentName && !!n.component;
    });
    const uids = nodes.map((n) => n.component.uid);
    return uids.map((uid) => children[uid]).filter((p) => !!p);
  };
  const useOrderedChildren = (vm, childComponentName) => {
    const children = vue.shallowRef({});
    const orderedChildren = vue.shallowRef([]);
    const nodesMap = /* @__PURE__ */ new WeakMap();
    const addChild = (child) => {
      children.value[child.uid] = child;
      vue.triggerRef(children);
      vue.onMounted(() => {
        const childNode = child.getVnode().el;
        const parentNode = childNode.parentNode;
        if (!nodesMap.has(parentNode)) {
          nodesMap.set(parentNode, []);
          const originalFn = parentNode.insertBefore.bind(parentNode);
          parentNode.insertBefore = (node, anchor) => {
            const shouldSortChildren = nodesMap.get(parentNode).some((el) => node === el || anchor === el);
            if (shouldSortChildren)
              vue.triggerRef(children);
            return originalFn(node, anchor);
          };
        }
        nodesMap.get(parentNode).push(childNode);
      });
    };
    const removeChild = (child) => {
      delete children.value[child.uid];
      vue.triggerRef(children);
      const childNode = child.getVnode().el;
      const parentNode = childNode.parentNode;
      const childNodes = nodesMap.get(parentNode);
      const index = childNodes.indexOf(childNode);
      childNodes.splice(index, 1);
    };
    const sortChildren = () => {
      orderedChildren.value = getOrderedChildren(vm, childComponentName, children.value);
    };
    const IsolatedRenderer = (props) => {
      return props.render();
    };
    const ChildrenSorter = vue.defineComponent({
      setup(_, { slots }) {
        return () => {
          sortChildren();
          return slots.default ? vue.h(IsolatedRenderer, {
            render: slots.default
          }) : null;
        };
      }
    });
    return {
      children: orderedChildren,
      addChild,
      removeChild,
      ChildrenSorter
    };
  };

  const useSizeProp = buildProp({
    type: String,
    values: componentSizes,
    required: false
  });
  const useSizeProps = {
    size: useSizeProp
  };
  const SIZE_INJECTION_KEY = Symbol("size");
  const useGlobalSize = () => {
    const injectedSize = vue.inject(SIZE_INJECTION_KEY, {});
    return vue.computed(() => {
      return vue.unref(injectedSize.size) || "";
    });
  };

  function useFocusController(target, {
    disabled,
    beforeFocus,
    afterFocus,
    beforeBlur,
    afterBlur
  } = {}) {
    const instance = vue.getCurrentInstance();
    const { emit } = instance;
    const wrapperRef = vue.shallowRef();
    const isFocused = vue.ref(false);
    const handleFocus = (event) => {
      const cancelFocus = isFunction$1(beforeFocus) ? beforeFocus(event) : false;
      if (vue.unref(disabled) || isFocused.value || cancelFocus)
        return;
      isFocused.value = true;
      emit("focus", event);
      afterFocus == null ? void 0 : afterFocus();
    };
    const handleBlur = (event) => {
      var _a;
      const cancelBlur = isFunction$1(beforeBlur) ? beforeBlur(event) : false;
      if (vue.unref(disabled) || event.relatedTarget && ((_a = wrapperRef.value) == null ? void 0 : _a.contains(event.relatedTarget)) || cancelBlur)
        return;
      isFocused.value = false;
      emit("blur", event);
      afterBlur == null ? void 0 : afterBlur();
    };
    const handleClick = (event) => {
      var _a, _b;
      if (vue.unref(disabled) || isFocusable(event.target) || ((_a = wrapperRef.value) == null ? void 0 : _a.contains(document.activeElement)) && wrapperRef.value !== document.activeElement)
        return;
      (_b = target.value) == null ? void 0 : _b.focus();
    };
    vue.watch([wrapperRef, () => vue.unref(disabled)], ([el, disabled2]) => {
      if (!el)
        return;
      if (disabled2) {
        el.removeAttribute("tabindex");
      } else {
        el.setAttribute("tabindex", "-1");
      }
    });
    useEventListener(wrapperRef, "focus", handleFocus, true);
    useEventListener(wrapperRef, "blur", handleBlur, true);
    useEventListener(wrapperRef, "click", handleClick, true);
    return {
      isFocused,
      wrapperRef,
      handleFocus,
      handleBlur
    };
  }

  function useComposition({
    afterComposition,
    emit
  }) {
    const isComposing = vue.ref(false);
    const handleCompositionStart = (event) => {
      emit == null ? void 0 : emit("compositionstart", event);
      isComposing.value = true;
    };
    const handleCompositionUpdate = (event) => {
      var _a;
      emit == null ? void 0 : emit("compositionupdate", event);
      const text = (_a = event.target) == null ? void 0 : _a.value;
      const lastCharacter = text[text.length - 1] || "";
      isComposing.value = !isKorean(lastCharacter);
    };
    const handleCompositionEnd = (event) => {
      emit == null ? void 0 : emit("compositionend", event);
      if (isComposing.value) {
        isComposing.value = false;
        vue.nextTick(() => afterComposition(event));
      }
    };
    const handleComposition = (event) => {
      event.type === "compositionend" ? handleCompositionEnd(event) : handleCompositionUpdate(event);
    };
    return {
      isComposing,
      handleComposition,
      handleCompositionStart,
      handleCompositionUpdate,
      handleCompositionEnd
    };
  }

  const emptyValuesContextKey = Symbol("emptyValuesContextKey");
  const SCOPE$7 = "use-empty-values";
  const DEFAULT_EMPTY_VALUES = ["", void 0, null];
  const DEFAULT_VALUE_ON_CLEAR = void 0;
  const useEmptyValuesProps = buildProps({
    emptyValues: Array,
    valueOnClear: {
      type: definePropType([
        String,
        Number,
        Boolean,
        Function
      ]),
      default: void 0,
      validator: (val) => {
        val = isFunction$1(val) ? val() : val;
        if (isArray$1(val)) {
          return val.every((item) => !item);
        }
        return !val;
      }
    }
  });
  const useEmptyValues = (props, defaultValue) => {
    const config = vue.getCurrentInstance() ? vue.inject(emptyValuesContextKey, vue.ref({})) : vue.ref({});
    const emptyValues = vue.computed(() => props.emptyValues || config.value.emptyValues || DEFAULT_EMPTY_VALUES);
    const valueOnClear = vue.computed(() => {
      if (isFunction$1(props.valueOnClear)) {
        return props.valueOnClear();
      } else if (props.valueOnClear !== void 0) {
        return props.valueOnClear;
      } else if (isFunction$1(config.value.valueOnClear)) {
        return config.value.valueOnClear();
      } else if (config.value.valueOnClear !== void 0) {
        return config.value.valueOnClear;
      }
      return defaultValue !== void 0 ? defaultValue : DEFAULT_VALUE_ON_CLEAR;
    });
    const isEmptyValue = (value) => {
      let result = true;
      if (isArray$1(value)) {
        result = emptyValues.value.some((emptyValue) => {
          return isEqual$1(value, emptyValue);
        });
      } else {
        result = emptyValues.value.includes(value);
      }
      return result;
    };
    if (!isEmptyValue(valueOnClear.value)) {
      debugWarn(SCOPE$7, "value-on-clear should be a value of empty-values");
    }
    return {
      emptyValues,
      valueOnClear,
      isEmptyValue
    };
  };

  const ariaProps = buildProps({
    ariaLabel: String,
    ariaOrientation: {
      type: String,
      values: ["horizontal", "vertical", "undefined"]
    },
    ariaControls: String
  });
  const useAriaProps = (arias) => {
    return pick(ariaProps, arias);
  };

  const configProviderContextKey = Symbol();

  const globalConfig = vue.ref();
  function useGlobalConfig(key, defaultValue = void 0) {
    const config = vue.getCurrentInstance() ? vue.inject(configProviderContextKey, globalConfig) : globalConfig;
    if (key) {
      return vue.computed(() => {
        var _a, _b;
        return (_b = (_a = config.value) == null ? void 0 : _a[key]) != null ? _b : defaultValue;
      });
    } else {
      return config;
    }
  }
  function useGlobalComponentSettings(block, sizeFallback) {
    const config = useGlobalConfig();
    const ns = useNamespace(block, vue.computed(() => {
      var _a;
      return ((_a = config.value) == null ? void 0 : _a.namespace) || defaultNamespace;
    }));
    const locale = useLocale(vue.computed(() => {
      var _a;
      return (_a = config.value) == null ? void 0 : _a.locale;
    }));
    const zIndex = useZIndex(vue.computed(() => {
      var _a;
      return ((_a = config.value) == null ? void 0 : _a.zIndex) || defaultInitialZIndex;
    }));
    const size = vue.computed(() => {
      var _a;
      return vue.unref(sizeFallback) || ((_a = config.value) == null ? void 0 : _a.size) || "";
    });
    provideGlobalConfig(vue.computed(() => vue.unref(config) || {}));
    return {
      ns,
      locale,
      zIndex,
      size
    };
  }
  const provideGlobalConfig = (config, app, global = false) => {
    var _a;
    const inSetup = !!vue.getCurrentInstance();
    const oldConfig = inSetup ? useGlobalConfig() : void 0;
    const provideFn = (_a = app == null ? void 0 : app.provide) != null ? _a : inSetup ? vue.provide : void 0;
    if (!provideFn) {
      debugWarn("provideGlobalConfig", "provideGlobalConfig() can only be used inside setup().");
      return;
    }
    const context = vue.computed(() => {
      const cfg = vue.unref(config);
      if (!(oldConfig == null ? void 0 : oldConfig.value))
        return cfg;
      return mergeConfig(oldConfig.value, cfg);
    });
    provideFn(configProviderContextKey, context);
    provideFn(localeContextKey, vue.computed(() => context.value.locale));
    provideFn(namespaceContextKey, vue.computed(() => context.value.namespace));
    provideFn(zIndexContextKey, vue.computed(() => context.value.zIndex));
    provideFn(SIZE_INJECTION_KEY, {
      size: vue.computed(() => context.value.size || "")
    });
    provideFn(emptyValuesContextKey, vue.computed(() => ({
      emptyValues: context.value.emptyValues,
      valueOnClear: context.value.valueOnClear
    })));
    if (global || !globalConfig.value) {
      globalConfig.value = context.value;
    }
    return context;
  };
  const mergeConfig = (a, b) => {
    const keys = [.../* @__PURE__ */ new Set([...keysOf(a), ...keysOf(b)])];
    const obj = {};
    for (const key of keys) {
      obj[key] = b[key] !== void 0 ? b[key] : a[key];
    }
    return obj;
  };

  const configProviderProps = buildProps({
    a11y: {
      type: Boolean,
      default: true
    },
    locale: {
      type: definePropType(Object)
    },
    size: useSizeProp,
    button: {
      type: definePropType(Object)
    },
    card: {
      type: definePropType(Object)
    },
    dialog: {
      type: definePropType(Object)
    },
    link: {
      type: definePropType(Object)
    },
    experimentalFeatures: {
      type: definePropType(Object)
    },
    keyboardNavigation: {
      type: Boolean,
      default: true
    },
    message: {
      type: definePropType(Object)
    },
    zIndex: Number,
    namespace: {
      type: String,
      default: "el"
    },
    ...useEmptyValuesProps
  });

  const messageConfig = {
    placement: "top"
  };
  const ConfigProvider = vue.defineComponent({
    name: "ElConfigProvider",
    props: configProviderProps,
    setup(props, { slots }) {
      const config = provideGlobalConfig(props);
      vue.watch(() => props.message, (val) => {
        var _a, _b;
        Object.assign(messageConfig, (_b = (_a = config == null ? void 0 : config.value) == null ? void 0 : _a.message) != null ? _b : {}, val != null ? val : {});
      }, { immediate: true, deep: true });
      return () => vue.renderSlot(slots, "default", { config: config == null ? void 0 : config.value });
    }
  });

  const ElConfigProvider = withInstall(ConfigProvider);

  const version$1 = "2.11.7";

  const makeInstaller = (components = []) => {
    const install = (app, options) => {
      if (app[INSTALLED_KEY])
        return;
      app[INSTALLED_KEY] = true;
      components.forEach((c) => app.use(c));
      if (options)
        provideGlobalConfig(options, app, true);
    };
    return {
      version: version$1,
      install
    };
  };

  const affixProps = buildProps({
    zIndex: {
      type: definePropType([Number, String]),
      default: 100
    },
    target: {
      type: String,
      default: ""
    },
    offset: {
      type: Number,
      default: 0
    },
    position: {
      type: String,
      values: ["top", "bottom"],
      default: "top"
    }
  });
  const affixEmits = {
    scroll: ({ scrollTop, fixed }) => isNumber(scrollTop) && isBoolean(fixed),
    [CHANGE_EVENT]: (fixed) => isBoolean(fixed)
  };

  var _export_sfc = (sfc, props) => {
    const target = sfc.__vccOpts || sfc;
    for (const [key, val] of props) {
      target[key] = val;
    }
    return target;
  };

  const COMPONENT_NAME$p = "ElAffix";
  const __default__$1Y = vue.defineComponent({
    name: COMPONENT_NAME$p
  });
  const _sfc_main$2v = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1Y,
    props: affixProps,
    emits: affixEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("affix");
      const target = vue.shallowRef();
      const root = vue.shallowRef();
      const scrollContainer = vue.shallowRef();
      const { height: windowHeight } = useWindowSize();
      const {
        height: rootHeight,
        width: rootWidth,
        top: rootTop,
        bottom: rootBottom,
        update: updateRoot
      } = useElementBounding(root, { windowScroll: false });
      const targetRect = useElementBounding(target);
      const fixed = vue.ref(false);
      const scrollTop = vue.ref(0);
      const transform = vue.ref(0);
      const rootStyle = vue.computed(() => {
        return {
          height: fixed.value ? `${rootHeight.value}px` : "",
          width: fixed.value ? `${rootWidth.value}px` : ""
        };
      });
      const affixStyle = vue.computed(() => {
        if (!fixed.value)
          return {};
        const offset = props.offset ? addUnit(props.offset) : 0;
        return {
          height: `${rootHeight.value}px`,
          width: `${rootWidth.value}px`,
          top: props.position === "top" ? offset : "",
          bottom: props.position === "bottom" ? offset : "",
          transform: transform.value ? `translateY(${transform.value}px)` : "",
          zIndex: props.zIndex
        };
      });
      const update = () => {
        if (!scrollContainer.value)
          return;
        scrollTop.value = scrollContainer.value instanceof Window ? document.documentElement.scrollTop : scrollContainer.value.scrollTop || 0;
        const { position, target: target2, offset } = props;
        const rootHeightOffset = offset + rootHeight.value;
        if (position === "top") {
          if (target2) {
            const difference = targetRect.bottom.value - rootHeightOffset;
            fixed.value = offset > rootTop.value && targetRect.bottom.value > 0;
            transform.value = difference < 0 ? difference : 0;
          } else {
            fixed.value = offset > rootTop.value;
          }
        } else if (target2) {
          const difference = windowHeight.value - targetRect.top.value - rootHeightOffset;
          fixed.value = windowHeight.value - offset < rootBottom.value && windowHeight.value > targetRect.top.value;
          transform.value = difference < 0 ? -difference : 0;
        } else {
          fixed.value = windowHeight.value - offset < rootBottom.value;
        }
      };
      const updateRootRect = async () => {
        if (!fixed.value) {
          updateRoot();
          return;
        }
        fixed.value = false;
        await vue.nextTick();
        updateRoot();
        fixed.value = true;
      };
      const handleScroll = async () => {
        updateRoot();
        await vue.nextTick();
        emit("scroll", {
          scrollTop: scrollTop.value,
          fixed: fixed.value
        });
      };
      vue.watch(fixed, (val) => emit(CHANGE_EVENT, val));
      vue.onMounted(() => {
        var _a;
        if (props.target) {
          target.value = (_a = document.querySelector(props.target)) != null ? _a : void 0;
          if (!target.value)
            throwError(COMPONENT_NAME$p, `Target does not exist: ${props.target}`);
        } else {
          target.value = document.documentElement;
        }
        scrollContainer.value = getScrollContainer(root.value, true);
        updateRoot();
      });
      useEventListener(scrollContainer, "scroll", handleScroll);
      vue.watchEffect(update);
      expose({
        update,
        updateRoot: updateRootRect
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "root",
          ref: root,
          class: vue.normalizeClass(vue.unref(ns).b()),
          style: vue.normalizeStyle(vue.unref(rootStyle))
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass({ [vue.unref(ns).m("fixed")]: fixed.value }),
            style: vue.normalizeStyle(vue.unref(affixStyle))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 6)
        ], 6);
      };
    }
  });
  var Affix = /* @__PURE__ */ _export_sfc(_sfc_main$2v, [["__file", "affix.vue"]]);

  const ElAffix = withInstall(Affix);

  const iconProps = buildProps({
    size: {
      type: definePropType([Number, String])
    },
    color: {
      type: String
    }
  });

  const __default__$1X = vue.defineComponent({
    name: "ElIcon",
    inheritAttrs: false
  });
  const _sfc_main$2u = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1X,
    props: iconProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("icon");
      const style = vue.computed(() => {
        const { size, color } = props;
        if (!size && !color)
          return {};
        return {
          fontSize: isUndefined(size) ? void 0 : addUnit(size),
          "--color": color
        };
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("i", vue.mergeProps({
          class: vue.unref(ns).b(),
          style: vue.unref(style)
        }, _ctx.$attrs), [
          vue.renderSlot(_ctx.$slots, "default")
        ], 16);
      };
    }
  });
  var Icon = /* @__PURE__ */ _export_sfc(_sfc_main$2u, [["__file", "icon.vue"]]);

  const ElIcon = withInstall(Icon);

  const alertEffects = ["light", "dark"];
  const alertProps = buildProps({
    title: {
      type: String,
      default: ""
    },
    description: {
      type: String,
      default: ""
    },
    type: {
      type: String,
      values: keysOf(TypeComponentsMap),
      default: "info"
    },
    closable: {
      type: Boolean,
      default: true
    },
    closeText: {
      type: String,
      default: ""
    },
    showIcon: Boolean,
    center: Boolean,
    effect: {
      type: String,
      values: alertEffects,
      default: "light"
    },
    ...useDelayedToggleProps,
    showAfter: Number
  });
  const alertEmits = {
    open: () => true,
    close: (evt) => isUndefined(evt) || evt instanceof Event
  };

  const __default__$1W = vue.defineComponent({
    name: "ElAlert"
  });
  const _sfc_main$2t = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1W,
    props: alertProps,
    emits: alertEmits,
    setup(__props, { emit }) {
      const props = __props;
      const { Close } = TypeComponents;
      const slots = vue.useSlots();
      const ns = useNamespace("alert");
      const visible = vue.ref(isUndefined(props.showAfter));
      const iconComponent = vue.computed(() => TypeComponentsMap[props.type]);
      const hasDesc = vue.computed(() => !!(props.description || slots.default));
      const open = () => {
        visible.value = true;
        emit("open");
      };
      const close = (event) => {
        visible.value = false;
        emit("close", event);
      };
      const { onOpen, onClose } = useDelayedToggle({
        showAfter: vue.toRef(props, "showAfter", 0),
        hideAfter: vue.toRef(props, "hideAfter"),
        autoClose: vue.toRef(props, "autoClose"),
        open,
        close
      });
      if (isClient) {
        onOpen();
      }
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, {
          name: vue.unref(ns).b("fade"),
          persisted: ""
        }, {
          default: vue.withCtx(() => [
            vue.withDirectives(vue.createElementVNode("div", {
              class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.type), vue.unref(ns).is("center", _ctx.center), vue.unref(ns).is(_ctx.effect)]),
              role: "alert"
            }, [
              _ctx.showIcon && (_ctx.$slots.icon || vue.unref(iconComponent)) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(ns).is("big", vue.unref(hasDesc))])
              }, {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "icon", {}, () => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
                  ])
                ]),
                _: 3
              }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("content"))
              }, [
                _ctx.title || _ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock("span", {
                  key: 0,
                  class: vue.normalizeClass([vue.unref(ns).e("title"), { "with-description": vue.unref(hasDesc) }])
                }, [
                  vue.renderSlot(_ctx.$slots, "title", {}, () => [
                    vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
                  ])
                ], 2)) : vue.createCommentVNode("v-if", true),
                vue.unref(hasDesc) ? (vue.openBlock(), vue.createElementBlock("p", {
                  key: 1,
                  class: vue.normalizeClass(vue.unref(ns).e("description"))
                }, [
                  vue.renderSlot(_ctx.$slots, "default", {}, () => [
                    vue.createTextVNode(vue.toDisplayString(_ctx.description), 1)
                  ])
                ], 2)) : vue.createCommentVNode("v-if", true),
                _ctx.closable ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
                  _ctx.closeText ? (vue.openBlock(), vue.createElementBlock("div", {
                    key: 0,
                    class: vue.normalizeClass([vue.unref(ns).e("close-btn"), vue.unref(ns).is("customed")]),
                    onClick: close
                  }, vue.toDisplayString(_ctx.closeText), 3)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 1,
                    class: vue.normalizeClass(vue.unref(ns).e("close-btn")),
                    onClick: vue.unref(onClose)
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(Close))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"]))
                ], 64)) : vue.createCommentVNode("v-if", true)
              ], 2)
            ], 2), [
              [vue.vShow, visible.value]
            ])
          ]),
          _: 3
        }, 8, ["name"]);
      };
    }
  });
  var Alert = /* @__PURE__ */ _export_sfc(_sfc_main$2t, [["__file", "alert.vue"]]);

  const ElAlert = withInstall(Alert);

  const formContextKey = Symbol("formContextKey");
  const formItemContextKey = Symbol("formItemContextKey");

  const useFormSize = (fallback, ignore = {}) => {
    const emptyRef = vue.ref(void 0);
    const size = ignore.prop ? emptyRef : useProp("size");
    const globalConfig = ignore.global ? emptyRef : useGlobalSize();
    const form = ignore.form ? { size: void 0 } : vue.inject(formContextKey, void 0);
    const formItem = ignore.formItem ? { size: void 0 } : vue.inject(formItemContextKey, void 0);
    return vue.computed(() => size.value || vue.unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig.value || "");
  };
  const useFormDisabled = (fallback) => {
    const disabled = useProp("disabled");
    const form = vue.inject(formContextKey, void 0);
    return vue.computed(() => disabled.value || vue.unref(fallback) || (form == null ? void 0 : form.disabled) || false);
  };
  const useSize$1 = useFormSize;
  const useDisabled = useFormDisabled;

  const useFormItem = () => {
    const form = vue.inject(formContextKey, void 0);
    const formItem = vue.inject(formItemContextKey, void 0);
    return {
      form,
      formItem
    };
  };
  const useFormItemInputId = (props, {
    formItemContext,
    disableIdGeneration,
    disableIdManagement
  }) => {
    if (!disableIdGeneration) {
      disableIdGeneration = vue.ref(false);
    }
    if (!disableIdManagement) {
      disableIdManagement = vue.ref(false);
    }
    const instance = vue.getCurrentInstance();
    const inLabel = () => {
      let parent = instance == null ? void 0 : instance.parent;
      while (parent) {
        if (parent.type.name === "ElFormItem") {
          return false;
        }
        if (parent.type.name === "ElLabelWrap") {
          return true;
        }
        parent = parent.parent;
      }
      return false;
    };
    const inputId = vue.ref();
    let idUnwatch = void 0;
    const isLabeledByFormItem = vue.computed(() => {
      var _a;
      return !!(!(props.label || props.ariaLabel) && formItemContext && formItemContext.inputIds && ((_a = formItemContext.inputIds) == null ? void 0 : _a.length) <= 1);
    });
    vue.onMounted(() => {
      idUnwatch = vue.watch([vue.toRef(props, "id"), disableIdGeneration], ([id, disableIdGeneration2]) => {
        const newId = id != null ? id : !disableIdGeneration2 ? useId().value : void 0;
        if (newId !== inputId.value) {
          if ((formItemContext == null ? void 0 : formItemContext.removeInputId) && !inLabel()) {
            inputId.value && formItemContext.removeInputId(inputId.value);
            if (!(disableIdManagement == null ? void 0 : disableIdManagement.value) && !disableIdGeneration2 && newId) {
              formItemContext.addInputId(newId);
            }
          }
          inputId.value = newId;
        }
      }, { immediate: true });
    });
    vue.onUnmounted(() => {
      idUnwatch && idUnwatch();
      if (formItemContext == null ? void 0 : formItemContext.removeInputId) {
        inputId.value && formItemContext.removeInputId(inputId.value);
      }
    });
    return {
      isLabeledByFormItem,
      inputId
    };
  };

  const formMetaProps = buildProps({
    size: {
      type: String,
      values: componentSizes
    },
    disabled: Boolean
  });
  const formProps = buildProps({
    ...formMetaProps,
    model: Object,
    rules: {
      type: definePropType(Object)
    },
    labelPosition: {
      type: String,
      values: ["left", "right", "top"],
      default: "right"
    },
    requireAsteriskPosition: {
      type: String,
      values: ["left", "right"],
      default: "left"
    },
    labelWidth: {
      type: [String, Number],
      default: ""
    },
    labelSuffix: {
      type: String,
      default: ""
    },
    inline: Boolean,
    inlineMessage: Boolean,
    statusIcon: Boolean,
    showMessage: {
      type: Boolean,
      default: true
    },
    validateOnRuleChange: {
      type: Boolean,
      default: true
    },
    hideRequiredAsterisk: Boolean,
    scrollToError: Boolean,
    scrollIntoViewOptions: {
      type: definePropType([Object, Boolean]),
      default: true
    }
  });
  const formEmits = {
    validate: (prop, isValid, message) => (isArray$1(prop) || isString$1(prop)) && isBoolean(isValid) && isString$1(message)
  };

  const SCOPE$6 = "ElForm";
  function useFormLabelWidth() {
    const potentialLabelWidthArr = vue.ref([]);
    const autoLabelWidth = vue.computed(() => {
      if (!potentialLabelWidthArr.value.length)
        return "0";
      const max = Math.max(...potentialLabelWidthArr.value);
      return max ? `${max}px` : "";
    });
    function getLabelWidthIndex(width) {
      const index = potentialLabelWidthArr.value.indexOf(width);
      if (index === -1 && autoLabelWidth.value === "0") {
        debugWarn(SCOPE$6, `unexpected width ${width}`);
      }
      return index;
    }
    function registerLabelWidth(val, oldVal) {
      if (val && oldVal) {
        const index = getLabelWidthIndex(oldVal);
        potentialLabelWidthArr.value.splice(index, 1, val);
      } else if (val) {
        potentialLabelWidthArr.value.push(val);
      }
    }
    function deregisterLabelWidth(val) {
      const index = getLabelWidthIndex(val);
      if (index > -1) {
        potentialLabelWidthArr.value.splice(index, 1);
      }
    }
    return {
      autoLabelWidth,
      registerLabelWidth,
      deregisterLabelWidth
    };
  }
  const filterFields = (fields, props) => {
    const normalized = castArray$1(props).map((prop) => isArray$1(prop) ? prop.join(".") : prop);
    return normalized.length > 0 ? fields.filter((field) => field.propString && normalized.includes(field.propString)) : fields;
  };

  const COMPONENT_NAME$o = "ElForm";
  const __default__$1V = vue.defineComponent({
    name: COMPONENT_NAME$o
  });
  const _sfc_main$2s = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1V,
    props: formProps,
    emits: formEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const formRef = vue.ref();
      const fields = vue.reactive([]);
      const formSize = useFormSize();
      const ns = useNamespace("form");
      const formClasses = vue.computed(() => {
        const { labelPosition, inline } = props;
        return [
          ns.b(),
          ns.m(formSize.value || "default"),
          {
            [ns.m(`label-${labelPosition}`)]: labelPosition,
            [ns.m("inline")]: inline
          }
        ];
      });
      const getField = (prop) => {
        return filterFields(fields, [prop])[0];
      };
      const addField = (field) => {
        fields.push(field);
      };
      const removeField = (field) => {
        if (field.prop) {
          fields.splice(fields.indexOf(field), 1);
        }
      };
      const resetFields = (properties = []) => {
        if (!props.model) {
          debugWarn(COMPONENT_NAME$o, "model is required for resetFields to work.");
          return;
        }
        filterFields(fields, properties).forEach((field) => field.resetField());
      };
      const clearValidate = (props2 = []) => {
        filterFields(fields, props2).forEach((field) => field.clearValidate());
      };
      const isValidatable = vue.computed(() => {
        const hasModel = !!props.model;
        if (!hasModel) {
          debugWarn(COMPONENT_NAME$o, "model is required for validate to work.");
        }
        return hasModel;
      });
      const obtainValidateFields = (props2) => {
        if (fields.length === 0)
          return [];
        const filteredFields = filterFields(fields, props2);
        if (!filteredFields.length) {
          debugWarn(COMPONENT_NAME$o, "please pass correct props!");
          return [];
        }
        return filteredFields;
      };
      const validate = async (callback) => validateField(void 0, callback);
      const doValidateField = async (props2 = []) => {
        if (!isValidatable.value)
          return false;
        const fields2 = obtainValidateFields(props2);
        if (fields2.length === 0)
          return true;
        let validationErrors = {};
        for (const field of fields2) {
          try {
            await field.validate("");
            if (field.validateState === "error" && !field.error)
              field.resetField();
          } catch (fields3) {
            validationErrors = {
              ...validationErrors,
              ...fields3
            };
          }
        }
        if (Object.keys(validationErrors).length === 0)
          return true;
        return Promise.reject(validationErrors);
      };
      const validateField = async (modelProps = [], callback) => {
        let result = false;
        const shouldThrow = !isFunction$1(callback);
        try {
          result = await doValidateField(modelProps);
          if (result === true) {
            await (callback == null ? void 0 : callback(result));
          }
          return result;
        } catch (e) {
          if (e instanceof Error)
            throw e;
          const invalidFields = e;
          if (props.scrollToError) {
            if (formRef.value) {
              const formItem = formRef.value.querySelector(`.${ns.b()}-item.is-error`);
              formItem == null ? void 0 : formItem.scrollIntoView(props.scrollIntoViewOptions);
            }
          }
          !result && await (callback == null ? void 0 : callback(false, invalidFields));
          return shouldThrow && Promise.reject(invalidFields);
        }
      };
      const scrollToField = (prop) => {
        var _a;
        const field = getField(prop);
        if (field) {
          (_a = field.$el) == null ? void 0 : _a.scrollIntoView(props.scrollIntoViewOptions);
        }
      };
      vue.watch(() => props.rules, () => {
        if (props.validateOnRuleChange) {
          validate().catch((err) => debugWarn(err));
        }
      }, { deep: true, flush: "post" });
      vue.provide(formContextKey, vue.reactive({
        ...vue.toRefs(props),
        emit,
        resetFields,
        clearValidate,
        validateField,
        getField,
        addField,
        removeField,
        ...useFormLabelWidth()
      }));
      expose({
        validate,
        validateField,
        resetFields,
        clearValidate,
        scrollToField,
        getField,
        fields
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("form", {
          ref_key: "formRef",
          ref: formRef,
          class: vue.normalizeClass(vue.unref(formClasses))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2);
      };
    }
  });
  var Form = /* @__PURE__ */ _export_sfc(_sfc_main$2s, [["__file", "form.vue"]]);

  function _extends() {
    _extends = Object.assign ? Object.assign.bind() : function(target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
      return target;
    };
    return _extends.apply(this, arguments);
  }
  function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;
    _setPrototypeOf(subClass, superClass);
  }
  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
      return o2.__proto__ || Object.getPrototypeOf(o2);
    };
    return _getPrototypeOf(o);
  }
  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
      o2.__proto__ = p2;
      return o2;
    };
    return _setPrototypeOf(o, p);
  }
  function _isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct)
      return false;
    if (Reflect.construct.sham)
      return false;
    if (typeof Proxy === "function")
      return true;
    try {
      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
      }));
      return true;
    } catch (e) {
      return false;
    }
  }
  function _construct(Parent, args, Class) {
    if (_isNativeReflectConstruct()) {
      _construct = Reflect.construct.bind();
    } else {
      _construct = function _construct2(Parent2, args2, Class2) {
        var a = [null];
        a.push.apply(a, args2);
        var Constructor = Function.bind.apply(Parent2, a);
        var instance = new Constructor();
        if (Class2)
          _setPrototypeOf(instance, Class2.prototype);
        return instance;
      };
    }
    return _construct.apply(null, arguments);
  }
  function _isNativeFunction(fn) {
    return Function.toString.call(fn).indexOf("[native code]") !== -1;
  }
  function _wrapNativeSuper(Class) {
    var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
    _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
      if (Class2 === null || !_isNativeFunction(Class2))
        return Class2;
      if (typeof Class2 !== "function") {
        throw new TypeError("Super expression must either be null or a function");
      }
      if (typeof _cache !== "undefined") {
        if (_cache.has(Class2))
          return _cache.get(Class2);
        _cache.set(Class2, Wrapper);
      }
      function Wrapper() {
        return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
      }
      Wrapper.prototype = Object.create(Class2.prototype, {
        constructor: {
          value: Wrapper,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      return _setPrototypeOf(Wrapper, Class2);
    };
    return _wrapNativeSuper(Class);
  }
  var formatRegExp = /%[sdj%]/g;
  var warning = function warning2() {
  };
  if (typeof process !== "undefined" && process.env && false) {
    warning = function warning3(type4, errors) {
      if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
        if (errors.every(function(e) {
          return typeof e === "string";
        })) {
          console.warn(type4, errors);
        }
      }
    };
  }
  function convertFieldsError(errors) {
    if (!errors || !errors.length)
      return null;
    var fields = {};
    errors.forEach(function(error) {
      var field = error.field;
      fields[field] = fields[field] || [];
      fields[field].push(error);
    });
    return fields;
  }
  function format(template) {
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    var i = 0;
    var len = args.length;
    if (typeof template === "function") {
      return template.apply(null, args);
    }
    if (typeof template === "string") {
      var str = template.replace(formatRegExp, function(x) {
        if (x === "%%") {
          return "%";
        }
        if (i >= len) {
          return x;
        }
        switch (x) {
          case "%s":
            return String(args[i++]);
          case "%d":
            return Number(args[i++]);
          case "%j":
            try {
              return JSON.stringify(args[i++]);
            } catch (_) {
              return "[Circular]";
            }
            break;
          default:
            return x;
        }
      });
      return str;
    }
    return template;
  }
  function isNativeStringType(type4) {
    return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
  }
  function isEmptyValue(value, type4) {
    if (value === void 0 || value === null) {
      return true;
    }
    if (type4 === "array" && Array.isArray(value) && !value.length) {
      return true;
    }
    if (isNativeStringType(type4) && typeof value === "string" && !value) {
      return true;
    }
    return false;
  }
  function asyncParallelArray(arr, func, callback) {
    var results = [];
    var total = 0;
    var arrLength = arr.length;
    function count(errors) {
      results.push.apply(results, errors || []);
      total++;
      if (total === arrLength) {
        callback(results);
      }
    }
    arr.forEach(function(a) {
      func(a, count);
    });
  }
  function asyncSerialArray(arr, func, callback) {
    var index = 0;
    var arrLength = arr.length;
    function next(errors) {
      if (errors && errors.length) {
        callback(errors);
        return;
      }
      var original = index;
      index = index + 1;
      if (original < arrLength) {
        func(arr[original], next);
      } else {
        callback([]);
      }
    }
    next([]);
  }
  function flattenObjArr(objArr) {
    var ret = [];
    Object.keys(objArr).forEach(function(k) {
      ret.push.apply(ret, objArr[k] || []);
    });
    return ret;
  }
  var AsyncValidationError = /* @__PURE__ */ function(_Error) {
    _inheritsLoose(AsyncValidationError2, _Error);
    function AsyncValidationError2(errors, fields) {
      var _this;
      _this = _Error.call(this, "Async Validation Error") || this;
      _this.errors = errors;
      _this.fields = fields;
      return _this;
    }
    return AsyncValidationError2;
  }(/* @__PURE__ */ _wrapNativeSuper(Error));
  function asyncMap(objArr, option, func, callback, source) {
    if (option.first) {
      var _pending = new Promise(function(resolve, reject) {
        var next = function next2(errors) {
          callback(errors);
          return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
        };
        var flattenArr = flattenObjArr(objArr);
        asyncSerialArray(flattenArr, func, next);
      });
      _pending["catch"](function(e) {
        return e;
      });
      return _pending;
    }
    var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
    var objArrKeys = Object.keys(objArr);
    var objArrLength = objArrKeys.length;
    var total = 0;
    var results = [];
    var pending = new Promise(function(resolve, reject) {
      var next = function next2(errors) {
        results.push.apply(results, errors);
        total++;
        if (total === objArrLength) {
          callback(results);
          return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
        }
      };
      if (!objArrKeys.length) {
        callback(results);
        resolve(source);
      }
      objArrKeys.forEach(function(key) {
        var arr = objArr[key];
        if (firstFields.indexOf(key) !== -1) {
          asyncSerialArray(arr, func, next);
        } else {
          asyncParallelArray(arr, func, next);
        }
      });
    });
    pending["catch"](function(e) {
      return e;
    });
    return pending;
  }
  function isErrorObj(obj) {
    return !!(obj && obj.message !== void 0);
  }
  function getValue(value, path) {
    var v = value;
    for (var i = 0; i < path.length; i++) {
      if (v == void 0) {
        return v;
      }
      v = v[path[i]];
    }
    return v;
  }
  function complementError(rule, source) {
    return function(oe) {
      var fieldValue;
      if (rule.fullFields) {
        fieldValue = getValue(source, rule.fullFields);
      } else {
        fieldValue = source[oe.field || rule.fullField];
      }
      if (isErrorObj(oe)) {
        oe.field = oe.field || rule.fullField;
        oe.fieldValue = fieldValue;
        return oe;
      }
      return {
        message: typeof oe === "function" ? oe() : oe,
        fieldValue,
        field: oe.field || rule.fullField
      };
    };
  }
  function deepMerge(target, source) {
    if (source) {
      for (var s in source) {
        if (source.hasOwnProperty(s)) {
          var value = source[s];
          if (typeof value === "object" && typeof target[s] === "object") {
            target[s] = _extends({}, target[s], value);
          } else {
            target[s] = value;
          }
        }
      }
    }
    return target;
  }
  var required$1 = function required(rule, value, source, errors, options, type4) {
    if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type4 || rule.type))) {
      errors.push(format(options.messages.required, rule.fullField));
    }
  };
  var whitespace = function whitespace2(rule, value, source, errors, options) {
    if (/^\s+$/.test(value) || value === "") {
      errors.push(format(options.messages.whitespace, rule.fullField));
    }
  };
  var urlReg;
  var getUrlRegex = function() {
    if (urlReg) {
      return urlReg;
    }
    var word = "[a-fA-F\\d:]";
    var b = function b2(options) {
      return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : "";
    };
    var v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
    var v6seg = "[a-fA-F\\d]{1,4}";
    var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n").replace(/\s*\/\/.*$/gm, "").replace(/\n/g, "").trim();
    var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
    var v4exact = new RegExp("^" + v4 + "$");
    var v6exact = new RegExp("^" + v6 + "$");
    var ip = function ip2(options) {
      return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", "g");
    };
    ip.v4 = function(options) {
      return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), "g");
    };
    ip.v6 = function(options) {
      return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), "g");
    };
    var protocol = "(?:(?:[a-z]+:)?//)";
    var auth = "(?:\\S+(?::\\S*)?@)?";
    var ipv4 = ip.v4().source;
    var ipv6 = ip.v6().source;
    var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
    var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
    var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
    var port = "(?::\\d{2,5})?";
    var path = '(?:[/?#][^\\s"]*)?';
    var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
    urlReg = new RegExp("(?:^" + regex + "$)", "i");
    return urlReg;
  };
  var pattern$2 = {
    email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
    hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
  };
  var types = {
    integer: function integer(value) {
      return types.number(value) && parseInt(value, 10) === value;
    },
    "float": function float(value) {
      return types.number(value) && !types.integer(value);
    },
    array: function array(value) {
      return Array.isArray(value);
    },
    regexp: function regexp(value) {
      if (value instanceof RegExp) {
        return true;
      }
      try {
        return !!new RegExp(value);
      } catch (e) {
        return false;
      }
    },
    date: function date(value) {
      return typeof value.getTime === "function" && typeof value.getMonth === "function" && typeof value.getYear === "function" && !isNaN(value.getTime());
    },
    number: function number(value) {
      if (isNaN(value)) {
        return false;
      }
      return typeof value === "number";
    },
    object: function object(value) {
      return typeof value === "object" && !types.array(value);
    },
    method: function method(value) {
      return typeof value === "function";
    },
    email: function email(value) {
      return typeof value === "string" && value.length <= 320 && !!value.match(pattern$2.email);
    },
    url: function url(value) {
      return typeof value === "string" && value.length <= 2048 && !!value.match(getUrlRegex());
    },
    hex: function hex(value) {
      return typeof value === "string" && !!value.match(pattern$2.hex);
    }
  };
  var type$1 = function type(rule, value, source, errors, options) {
    if (rule.required && value === void 0) {
      required$1(rule, value, source, errors, options);
      return;
    }
    var custom = ["integer", "float", "array", "regexp", "object", "method", "email", "number", "date", "url", "hex"];
    var ruleType = rule.type;
    if (custom.indexOf(ruleType) > -1) {
      if (!types[ruleType](value)) {
        errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
      }
    } else if (ruleType && typeof value !== rule.type) {
      errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
    }
  };
  var range = function range2(rule, value, source, errors, options) {
    var len = typeof rule.len === "number";
    var min = typeof rule.min === "number";
    var max = typeof rule.max === "number";
    var val = value;
    var key = null;
    var num = typeof value === "number";
    var str = typeof value === "string";
    var arr = Array.isArray(value);
    if (num) {
      key = "number";
    } else if (str) {
      key = "string";
    } else if (arr) {
      key = "array";
    }
    if (!key) {
      return false;
    }
    if (arr) {
      val = value.length;
    }
    if (str) {
      val = value.length;
    }
    if (len) {
      if (val !== rule.len) {
        errors.push(format(options.messages[key].len, rule.fullField, rule.len));
      }
    } else if (min && !max && val < rule.min) {
      errors.push(format(options.messages[key].min, rule.fullField, rule.min));
    } else if (max && !min && val > rule.max) {
      errors.push(format(options.messages[key].max, rule.fullField, rule.max));
    } else if (min && max && (val < rule.min || val > rule.max)) {
      errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
    }
  };
  var ENUM$1 = "enum";
  var enumerable$1 = function enumerable(rule, value, source, errors, options) {
    rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
    if (rule[ENUM$1].indexOf(value) === -1) {
      errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(", ")));
    }
  };
  var pattern$1 = function pattern(rule, value, source, errors, options) {
    if (rule.pattern) {
      if (rule.pattern instanceof RegExp) {
        rule.pattern.lastIndex = 0;
        if (!rule.pattern.test(value)) {
          errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
        }
      } else if (typeof rule.pattern === "string") {
        var _pattern = new RegExp(rule.pattern);
        if (!_pattern.test(value)) {
          errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
        }
      }
    }
  };
  var rules = {
    required: required$1,
    whitespace,
    type: type$1,
    range,
    "enum": enumerable$1,
    pattern: pattern$1
  };
  var string = function string2(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value, "string") && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options, "string");
      if (!isEmptyValue(value, "string")) {
        rules.type(rule, value, source, errors, options);
        rules.range(rule, value, source, errors, options);
        rules.pattern(rule, value, source, errors, options);
        if (rule.whitespace === true) {
          rules.whitespace(rule, value, source, errors, options);
        }
      }
    }
    callback(errors);
  };
  var method2 = function method3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (value !== void 0) {
        rules.type(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var number2 = function number3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (value === "") {
        value = void 0;
      }
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (value !== void 0) {
        rules.type(rule, value, source, errors, options);
        rules.range(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var _boolean = function _boolean2(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (value !== void 0) {
        rules.type(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var regexp2 = function regexp3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (!isEmptyValue(value)) {
        rules.type(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var integer2 = function integer3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (value !== void 0) {
        rules.type(rule, value, source, errors, options);
        rules.range(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var floatFn = function floatFn2(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (value !== void 0) {
        rules.type(rule, value, source, errors, options);
        rules.range(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var array2 = function array3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if ((value === void 0 || value === null) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options, "array");
      if (value !== void 0 && value !== null) {
        rules.type(rule, value, source, errors, options);
        rules.range(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var object2 = function object3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (value !== void 0) {
        rules.type(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var ENUM = "enum";
  var enumerable2 = function enumerable3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (value !== void 0) {
        rules[ENUM](rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var pattern2 = function pattern3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value, "string") && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (!isEmptyValue(value, "string")) {
        rules.pattern(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var date2 = function date3(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value, "date") && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
      if (!isEmptyValue(value, "date")) {
        var dateObject;
        if (value instanceof Date) {
          dateObject = value;
        } else {
          dateObject = new Date(value);
        }
        rules.type(rule, dateObject, source, errors, options);
        if (dateObject) {
          rules.range(rule, dateObject.getTime(), source, errors, options);
        }
      }
    }
    callback(errors);
  };
  var required2 = function required3(rule, value, callback, source, options) {
    var errors = [];
    var type4 = Array.isArray(value) ? "array" : typeof value;
    rules.required(rule, value, source, errors, options, type4);
    callback(errors);
  };
  var type2 = function type3(rule, value, callback, source, options) {
    var ruleType = rule.type;
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value, ruleType) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options, ruleType);
      if (!isEmptyValue(value, ruleType)) {
        rules.type(rule, value, source, errors, options);
      }
    }
    callback(errors);
  };
  var any = function any2(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
    if (validate) {
      if (isEmptyValue(value) && !rule.required) {
        return callback();
      }
      rules.required(rule, value, source, errors, options);
    }
    callback(errors);
  };
  var validators = {
    string,
    method: method2,
    number: number2,
    "boolean": _boolean,
    regexp: regexp2,
    integer: integer2,
    "float": floatFn,
    array: array2,
    object: object2,
    "enum": enumerable2,
    pattern: pattern2,
    date: date2,
    url: type2,
    hex: type2,
    email: type2,
    required: required2,
    any
  };
  function newMessages() {
    return {
      "default": "Validation error on field %s",
      required: "%s is required",
      "enum": "%s must be one of %s",
      whitespace: "%s cannot be empty",
      date: {
        format: "%s date %s is invalid for format %s",
        parse: "%s date could not be parsed, %s is invalid ",
        invalid: "%s date %s is invalid"
      },
      types: {
        string: "%s is not a %s",
        method: "%s is not a %s (function)",
        array: "%s is not an %s",
        object: "%s is not an %s",
        number: "%s is not a %s",
        date: "%s is not a %s",
        "boolean": "%s is not a %s",
        integer: "%s is not an %s",
        "float": "%s is not a %s",
        regexp: "%s is not a valid %s",
        email: "%s is not a valid %s",
        url: "%s is not a valid %s",
        hex: "%s is not a valid %s"
      },
      string: {
        len: "%s must be exactly %s characters",
        min: "%s must be at least %s characters",
        max: "%s cannot be longer than %s characters",
        range: "%s must be between %s and %s characters"
      },
      number: {
        len: "%s must equal %s",
        min: "%s cannot be less than %s",
        max: "%s cannot be greater than %s",
        range: "%s must be between %s and %s"
      },
      array: {
        len: "%s must be exactly %s in length",
        min: "%s cannot be less than %s in length",
        max: "%s cannot be greater than %s in length",
        range: "%s must be between %s and %s in length"
      },
      pattern: {
        mismatch: "%s value %s does not match pattern %s"
      },
      clone: function clone() {
        var cloned = JSON.parse(JSON.stringify(this));
        cloned.clone = this.clone;
        return cloned;
      }
    };
  }
  var messages = newMessages();
  var Schema = /* @__PURE__ */ function() {
    function Schema2(descriptor) {
      this.rules = null;
      this._messages = messages;
      this.define(descriptor);
    }
    var _proto = Schema2.prototype;
    _proto.define = function define(rules2) {
      var _this = this;
      if (!rules2) {
        throw new Error("Cannot configure a schema with no rules");
      }
      if (typeof rules2 !== "object" || Array.isArray(rules2)) {
        throw new Error("Rules must be an object");
      }
      this.rules = {};
      Object.keys(rules2).forEach(function(name) {
        var item = rules2[name];
        _this.rules[name] = Array.isArray(item) ? item : [item];
      });
    };
    _proto.messages = function messages2(_messages) {
      if (_messages) {
        this._messages = deepMerge(newMessages(), _messages);
      }
      return this._messages;
    };
    _proto.validate = function validate(source_, o, oc) {
      var _this2 = this;
      if (o === void 0) {
        o = {};
      }
      if (oc === void 0) {
        oc = function oc2() {
        };
      }
      var source = source_;
      var options = o;
      var callback = oc;
      if (typeof options === "function") {
        callback = options;
        options = {};
      }
      if (!this.rules || Object.keys(this.rules).length === 0) {
        if (callback) {
          callback(null, source);
        }
        return Promise.resolve(source);
      }
      function complete(results) {
        var errors = [];
        var fields = {};
        function add(e) {
          if (Array.isArray(e)) {
            var _errors;
            errors = (_errors = errors).concat.apply(_errors, e);
          } else {
            errors.push(e);
          }
        }
        for (var i = 0; i < results.length; i++) {
          add(results[i]);
        }
        if (!errors.length) {
          callback(null, source);
        } else {
          fields = convertFieldsError(errors);
          callback(errors, fields);
        }
      }
      if (options.messages) {
        var messages$1 = this.messages();
        if (messages$1 === messages) {
          messages$1 = newMessages();
        }
        deepMerge(messages$1, options.messages);
        options.messages = messages$1;
      } else {
        options.messages = this.messages();
      }
      var series = {};
      var keys = options.keys || Object.keys(this.rules);
      keys.forEach(function(z) {
        var arr = _this2.rules[z];
        var value = source[z];
        arr.forEach(function(r) {
          var rule = r;
          if (typeof rule.transform === "function") {
            if (source === source_) {
              source = _extends({}, source);
            }
            value = source[z] = rule.transform(value);
          }
          if (typeof rule === "function") {
            rule = {
              validator: rule
            };
          } else {
            rule = _extends({}, rule);
          }
          rule.validator = _this2.getValidationMethod(rule);
          if (!rule.validator) {
            return;
          }
          rule.field = z;
          rule.fullField = rule.fullField || z;
          rule.type = _this2.getType(rule);
          series[z] = series[z] || [];
          series[z].push({
            rule,
            value,
            source,
            field: z
          });
        });
      });
      var errorFields = {};
      return asyncMap(series, options, function(data, doIt) {
        var rule = data.rule;
        var deep = (rule.type === "object" || rule.type === "array") && (typeof rule.fields === "object" || typeof rule.defaultField === "object");
        deep = deep && (rule.required || !rule.required && data.value);
        rule.field = data.field;
        function addFullField(key, schema) {
          return _extends({}, schema, {
            fullField: rule.fullField + "." + key,
            fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
          });
        }
        function cb(e) {
          if (e === void 0) {
            e = [];
          }
          var errorList = Array.isArray(e) ? e : [e];
          if (!options.suppressWarning && errorList.length) {
            Schema2.warning("async-validator:", errorList);
          }
          if (errorList.length && rule.message !== void 0) {
            errorList = [].concat(rule.message);
          }
          var filledErrors = errorList.map(complementError(rule, source));
          if (options.first && filledErrors.length) {
            errorFields[rule.field] = 1;
            return doIt(filledErrors);
          }
          if (!deep) {
            doIt(filledErrors);
          } else {
            if (rule.required && !data.value) {
              if (rule.message !== void 0) {
                filledErrors = [].concat(rule.message).map(complementError(rule, source));
              } else if (options.error) {
                filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
              }
              return doIt(filledErrors);
            }
            var fieldsSchema = {};
            if (rule.defaultField) {
              Object.keys(data.value).map(function(key) {
                fieldsSchema[key] = rule.defaultField;
              });
            }
            fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
            var paredFieldsSchema = {};
            Object.keys(fieldsSchema).forEach(function(field) {
              var fieldSchema = fieldsSchema[field];
              var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
              paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
            });
            var schema = new Schema2(paredFieldsSchema);
            schema.messages(options.messages);
            if (data.rule.options) {
              data.rule.options.messages = options.messages;
              data.rule.options.error = options.error;
            }
            schema.validate(data.value, data.rule.options || options, function(errs) {
              var finalErrors = [];
              if (filledErrors && filledErrors.length) {
                finalErrors.push.apply(finalErrors, filledErrors);
              }
              if (errs && errs.length) {
                finalErrors.push.apply(finalErrors, errs);
              }
              doIt(finalErrors.length ? finalErrors : null);
            });
          }
        }
        var res;
        if (rule.asyncValidator) {
          res = rule.asyncValidator(rule, data.value, cb, data.source, options);
        } else if (rule.validator) {
          try {
            res = rule.validator(rule, data.value, cb, data.source, options);
          } catch (error) {
            console.error == null ? void 0 : console.error(error);
            if (!options.suppressValidatorError) {
              setTimeout(function() {
                throw error;
              }, 0);
            }
            cb(error.message);
          }
          if (res === true) {
            cb();
          } else if (res === false) {
            cb(typeof rule.message === "function" ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
          } else if (res instanceof Array) {
            cb(res);
          } else if (res instanceof Error) {
            cb(res.message);
          }
        }
        if (res && res.then) {
          res.then(function() {
            return cb();
          }, function(e) {
            return cb(e);
          });
        }
      }, function(results) {
        complete(results);
      }, source);
    };
    _proto.getType = function getType(rule) {
      if (rule.type === void 0 && rule.pattern instanceof RegExp) {
        rule.type = "pattern";
      }
      if (typeof rule.validator !== "function" && rule.type && !validators.hasOwnProperty(rule.type)) {
        throw new Error(format("Unknown rule type %s", rule.type));
      }
      return rule.type || "string";
    };
    _proto.getValidationMethod = function getValidationMethod(rule) {
      if (typeof rule.validator === "function") {
        return rule.validator;
      }
      var keys = Object.keys(rule);
      var messageIndex = keys.indexOf("message");
      if (messageIndex !== -1) {
        keys.splice(messageIndex, 1);
      }
      if (keys.length === 1 && keys[0] === "required") {
        return validators.required;
      }
      return validators[this.getType(rule)] || void 0;
    };
    return Schema2;
  }();
  Schema.register = function register(type4, validator) {
    if (typeof validator !== "function") {
      throw new Error("Cannot register a validator by type, validator is not a function");
    }
    validators[type4] = validator;
  };
  Schema.warning = warning;
  Schema.messages = messages;
  Schema.validators = validators;

  const formItemValidateStates = [
    "",
    "error",
    "validating",
    "success"
  ];
  const formItemProps = buildProps({
    label: String,
    labelWidth: {
      type: [String, Number],
      default: ""
    },
    labelPosition: {
      type: String,
      values: ["left", "right", "top", ""],
      default: ""
    },
    prop: {
      type: definePropType([String, Array])
    },
    required: {
      type: Boolean,
      default: void 0
    },
    rules: {
      type: definePropType([Object, Array])
    },
    error: String,
    validateStatus: {
      type: String,
      values: formItemValidateStates
    },
    for: String,
    inlineMessage: {
      type: Boolean,
      default: void 0
    },
    showMessage: {
      type: Boolean,
      default: true
    },
    size: {
      type: String,
      values: componentSizes
    }
  });

  const COMPONENT_NAME$n = "ElLabelWrap";
  var FormLabelWrap = vue.defineComponent({
    name: COMPONENT_NAME$n,
    props: {
      isAutoWidth: Boolean,
      updateAll: Boolean
    },
    setup(props, {
      slots
    }) {
      const formContext = vue.inject(formContextKey, void 0);
      const formItemContext = vue.inject(formItemContextKey);
      if (!formItemContext)
        throwError(COMPONENT_NAME$n, "usage: <el-form-item><label-wrap /></el-form-item>");
      const ns = useNamespace("form");
      const el = vue.ref();
      const computedWidth = vue.ref(0);
      const getLabelWidth = () => {
        var _a;
        if ((_a = el.value) == null ? void 0 : _a.firstElementChild) {
          const width = window.getComputedStyle(el.value.firstElementChild).width;
          return Math.ceil(Number.parseFloat(width));
        } else {
          return 0;
        }
      };
      const updateLabelWidth = (action = "update") => {
        vue.nextTick(() => {
          if (slots.default && props.isAutoWidth) {
            if (action === "update") {
              computedWidth.value = getLabelWidth();
            } else if (action === "remove") {
              formContext == null ? void 0 : formContext.deregisterLabelWidth(computedWidth.value);
            }
          }
        });
      };
      const updateLabelWidthFn = () => updateLabelWidth("update");
      vue.onMounted(() => {
        updateLabelWidthFn();
      });
      vue.onBeforeUnmount(() => {
        updateLabelWidth("remove");
      });
      vue.onUpdated(() => updateLabelWidthFn());
      vue.watch(computedWidth, (val, oldVal) => {
        if (props.updateAll) {
          formContext == null ? void 0 : formContext.registerLabelWidth(val, oldVal);
        }
      });
      useResizeObserver(vue.computed(() => {
        var _a, _b;
        return (_b = (_a = el.value) == null ? void 0 : _a.firstElementChild) != null ? _b : null;
      }), updateLabelWidthFn);
      return () => {
        var _a, _b;
        if (!slots)
          return null;
        const {
          isAutoWidth
        } = props;
        if (isAutoWidth) {
          const autoLabelWidth = formContext == null ? void 0 : formContext.autoLabelWidth;
          const hasLabel = formItemContext == null ? void 0 : formItemContext.hasLabel;
          const style = {};
          if (hasLabel && autoLabelWidth && autoLabelWidth !== "auto") {
            const marginWidth = Math.max(0, Number.parseInt(autoLabelWidth, 10) - computedWidth.value);
            const labelPosition = formItemContext.labelPosition || formContext.labelPosition;
            const marginPosition = labelPosition === "left" ? "marginRight" : "marginLeft";
            if (marginWidth) {
              style[marginPosition] = `${marginWidth}px`;
            }
          }
          return vue.createVNode("div", {
            "ref": el,
            "class": [ns.be("item", "label-wrap")],
            "style": style
          }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
        } else {
          return vue.createVNode(vue.Fragment, {
            "ref": el
          }, [(_b = slots.default) == null ? void 0 : _b.call(slots)]);
        }
      };
    }
  });

  const __default__$1U = vue.defineComponent({
    name: "ElFormItem"
  });
  const _sfc_main$2r = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1U,
    props: formItemProps,
    setup(__props, { expose }) {
      const props = __props;
      const slots = vue.useSlots();
      const formContext = vue.inject(formContextKey, void 0);
      const parentFormItemContext = vue.inject(formItemContextKey, void 0);
      const _size = useFormSize(void 0, { formItem: false });
      const ns = useNamespace("form-item");
      const labelId = useId().value;
      const inputIds = vue.ref([]);
      const validateState = vue.ref("");
      const validateStateDebounced = refDebounced(validateState, 100);
      const validateMessage = vue.ref("");
      const formItemRef = vue.ref();
      let initialValue = void 0;
      let isResettingField = false;
      const labelPosition = vue.computed(() => props.labelPosition || (formContext == null ? void 0 : formContext.labelPosition));
      const labelStyle = vue.computed(() => {
        if (labelPosition.value === "top") {
          return {};
        }
        const labelWidth = addUnit(props.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
        if (labelWidth)
          return { width: labelWidth };
        return {};
      });
      const contentStyle = vue.computed(() => {
        if (labelPosition.value === "top" || (formContext == null ? void 0 : formContext.inline)) {
          return {};
        }
        if (!props.label && !props.labelWidth && isNested) {
          return {};
        }
        const labelWidth = addUnit(props.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
        if (!props.label && !slots.label) {
          return { marginLeft: labelWidth };
        }
        return {};
      });
      const formItemClasses = vue.computed(() => [
        ns.b(),
        ns.m(_size.value),
        ns.is("error", validateState.value === "error"),
        ns.is("validating", validateState.value === "validating"),
        ns.is("success", validateState.value === "success"),
        ns.is("required", isRequired.value || props.required),
        ns.is("no-asterisk", formContext == null ? void 0 : formContext.hideRequiredAsterisk),
        (formContext == null ? void 0 : formContext.requireAsteriskPosition) === "right" ? "asterisk-right" : "asterisk-left",
        {
          [ns.m("feedback")]: formContext == null ? void 0 : formContext.statusIcon,
          [ns.m(`label-${labelPosition.value}`)]: labelPosition.value
        }
      ]);
      const _inlineMessage = vue.computed(() => isBoolean(props.inlineMessage) ? props.inlineMessage : (formContext == null ? void 0 : formContext.inlineMessage) || false);
      const validateClasses = vue.computed(() => [
        ns.e("error"),
        { [ns.em("error", "inline")]: _inlineMessage.value }
      ]);
      const propString = vue.computed(() => {
        if (!props.prop)
          return "";
        return isArray$1(props.prop) ? props.prop.join(".") : props.prop;
      });
      const hasLabel = vue.computed(() => {
        return !!(props.label || slots.label);
      });
      const labelFor = vue.computed(() => {
        var _a;
        return (_a = props.for) != null ? _a : inputIds.value.length === 1 ? inputIds.value[0] : void 0;
      });
      const isGroup = vue.computed(() => {
        return !labelFor.value && hasLabel.value;
      });
      const isNested = !!parentFormItemContext;
      const fieldValue = vue.computed(() => {
        const model = formContext == null ? void 0 : formContext.model;
        if (!model || !props.prop) {
          return;
        }
        return getProp(model, props.prop).value;
      });
      const normalizedRules = vue.computed(() => {
        const { required } = props;
        const rules = [];
        if (props.rules) {
          rules.push(...castArray$1(props.rules));
        }
        const formRules = formContext == null ? void 0 : formContext.rules;
        if (formRules && props.prop) {
          const _rules = getProp(formRules, props.prop).value;
          if (_rules) {
            rules.push(...castArray$1(_rules));
          }
        }
        if (required !== void 0) {
          const requiredRules = rules.map((rule, i) => [rule, i]).filter(([rule]) => "required" in rule);
          if (requiredRules.length > 0) {
            for (const [rule, i] of requiredRules) {
              if (rule.required === required)
                continue;
              rules[i] = { ...rule, required };
            }
          } else {
            rules.push({ required });
          }
        }
        return rules;
      });
      const validateEnabled = vue.computed(() => normalizedRules.value.length > 0);
      const getFilteredRule = (trigger) => {
        const rules = normalizedRules.value;
        return rules.filter((rule) => {
          if (!rule.trigger || !trigger)
            return true;
          if (isArray$1(rule.trigger)) {
            return rule.trigger.includes(trigger);
          } else {
            return rule.trigger === trigger;
          }
        }).map(({ trigger: trigger2, ...rule }) => rule);
      };
      const isRequired = vue.computed(() => normalizedRules.value.some((rule) => rule.required));
      const shouldShowError = vue.computed(() => {
        var _a;
        return validateStateDebounced.value === "error" && props.showMessage && ((_a = formContext == null ? void 0 : formContext.showMessage) != null ? _a : true);
      });
      const currentLabel = vue.computed(() => `${props.label || ""}${(formContext == null ? void 0 : formContext.labelSuffix) || ""}`);
      const setValidationState = (state) => {
        validateState.value = state;
      };
      const onValidationFailed = (error) => {
        var _a, _b;
        const { errors, fields } = error;
        if (!errors || !fields) {
          console.error(error);
        }
        setValidationState("error");
        validateMessage.value = errors ? (_b = (_a = errors == null ? void 0 : errors[0]) == null ? void 0 : _a.message) != null ? _b : `${props.prop} is required` : "";
        formContext == null ? void 0 : formContext.emit("validate", props.prop, false, validateMessage.value);
      };
      const onValidationSucceeded = () => {
        setValidationState("success");
        formContext == null ? void 0 : formContext.emit("validate", props.prop, true, "");
      };
      const doValidate = async (rules) => {
        const modelName = propString.value;
        const validator = new Schema({
          [modelName]: rules
        });
        return validator.validate({ [modelName]: fieldValue.value }, { firstFields: true }).then(() => {
          onValidationSucceeded();
          return true;
        }).catch((err) => {
          onValidationFailed(err);
          return Promise.reject(err);
        });
      };
      const validate = async (trigger, callback) => {
        if (isResettingField || !props.prop) {
          return false;
        }
        const hasCallback = isFunction$1(callback);
        if (!validateEnabled.value) {
          callback == null ? void 0 : callback(false);
          return false;
        }
        const rules = getFilteredRule(trigger);
        if (rules.length === 0) {
          callback == null ? void 0 : callback(true);
          return true;
        }
        setValidationState("validating");
        return doValidate(rules).then(() => {
          callback == null ? void 0 : callback(true);
          return true;
        }).catch((err) => {
          const { fields } = err;
          callback == null ? void 0 : callback(false, fields);
          return hasCallback ? false : Promise.reject(fields);
        });
      };
      const clearValidate = () => {
        setValidationState("");
        validateMessage.value = "";
        isResettingField = false;
      };
      const resetField = async () => {
        const model = formContext == null ? void 0 : formContext.model;
        if (!model || !props.prop)
          return;
        const computedValue = getProp(model, props.prop);
        isResettingField = true;
        computedValue.value = clone(initialValue);
        await vue.nextTick();
        clearValidate();
        isResettingField = false;
      };
      const addInputId = (id) => {
        if (!inputIds.value.includes(id)) {
          inputIds.value.push(id);
        }
      };
      const removeInputId = (id) => {
        inputIds.value = inputIds.value.filter((listId) => listId !== id);
      };
      vue.watch(() => props.error, (val) => {
        validateMessage.value = val || "";
        setValidationState(val ? "error" : "");
      }, { immediate: true });
      vue.watch(() => props.validateStatus, (val) => setValidationState(val || ""));
      const context = vue.reactive({
        ...vue.toRefs(props),
        $el: formItemRef,
        size: _size,
        validateMessage,
        validateState,
        labelId,
        inputIds,
        isGroup,
        hasLabel,
        fieldValue,
        addInputId,
        removeInputId,
        resetField,
        clearValidate,
        validate,
        propString
      });
      vue.provide(formItemContextKey, context);
      vue.onMounted(() => {
        if (props.prop) {
          formContext == null ? void 0 : formContext.addField(context);
          initialValue = clone(fieldValue.value);
        }
      });
      vue.onBeforeUnmount(() => {
        formContext == null ? void 0 : formContext.removeField(context);
      });
      expose({
        size: _size,
        validateMessage,
        validateState,
        validate,
        clearValidate,
        resetField
      });
      return (_ctx, _cache) => {
        var _a;
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "formItemRef",
          ref: formItemRef,
          class: vue.normalizeClass(vue.unref(formItemClasses)),
          role: vue.unref(isGroup) ? "group" : void 0,
          "aria-labelledby": vue.unref(isGroup) ? vue.unref(labelId) : void 0
        }, [
          vue.createVNode(vue.unref(FormLabelWrap), {
            "is-auto-width": vue.unref(labelStyle).width === "auto",
            "update-all": ((_a = vue.unref(formContext)) == null ? void 0 : _a.labelWidth) === "auto"
          }, {
            default: vue.withCtx(() => [
              !!(_ctx.label || _ctx.$slots.label) ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(labelFor) ? "label" : "div"), {
                key: 0,
                id: vue.unref(labelId),
                for: vue.unref(labelFor),
                class: vue.normalizeClass(vue.unref(ns).e("label")),
                style: vue.normalizeStyle(vue.unref(labelStyle))
              }, {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "label", { label: vue.unref(currentLabel) }, () => [
                    vue.createTextVNode(vue.toDisplayString(vue.unref(currentLabel)), 1)
                  ])
                ]),
                _: 3
              }, 8, ["id", "for", "class", "style"])) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["is-auto-width", "update-all"]),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("content")),
            style: vue.normalizeStyle(vue.unref(contentStyle))
          }, [
            vue.renderSlot(_ctx.$slots, "default"),
            vue.createVNode(vue.TransitionGroup, {
              name: `${vue.unref(ns).namespace.value}-zoom-in-top`
            }, {
              default: vue.withCtx(() => [
                vue.unref(shouldShowError) ? vue.renderSlot(_ctx.$slots, "error", {
                  key: 0,
                  error: validateMessage.value
                }, () => [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(validateClasses))
                  }, vue.toDisplayString(validateMessage.value), 3)
                ]) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["name"])
          ], 6)
        ], 10, ["role", "aria-labelledby"]);
      };
    }
  });
  var FormItem = /* @__PURE__ */ _export_sfc(_sfc_main$2r, [["__file", "form-item.vue"]]);

  const ElForm = withInstall(Form, {
    FormItem
  });
  const ElFormItem = withNoopInstall(FormItem);

  let hiddenTextarea = void 0;
  const HIDDEN_STYLE = {
    height: "0",
    visibility: "hidden",
    overflow: isFirefox() ? "" : "hidden",
    position: "absolute",
    "z-index": "-1000",
    top: "0",
    right: "0"
  };
  const CONTEXT_STYLE = [
    "letter-spacing",
    "line-height",
    "padding-top",
    "padding-bottom",
    "font-family",
    "font-weight",
    "font-size",
    "text-rendering",
    "text-transform",
    "width",
    "text-indent",
    "padding-left",
    "padding-right",
    "border-width",
    "box-sizing",
    "word-break"
  ];
  const looseToNumber = (val) => {
    const n = Number.parseFloat(val);
    return Number.isNaN(n) ? val : n;
  };
  function calculateNodeStyling(targetElement) {
    const style = window.getComputedStyle(targetElement);
    const boxSizing = style.getPropertyValue("box-sizing");
    const paddingSize = Number.parseFloat(style.getPropertyValue("padding-bottom")) + Number.parseFloat(style.getPropertyValue("padding-top"));
    const borderSize = Number.parseFloat(style.getPropertyValue("border-bottom-width")) + Number.parseFloat(style.getPropertyValue("border-top-width"));
    const contextStyle = CONTEXT_STYLE.map((name) => [
      name,
      style.getPropertyValue(name)
    ]);
    return { contextStyle, paddingSize, borderSize, boxSizing };
  }
  function calcTextareaHeight(targetElement, minRows = 1, maxRows) {
    var _a, _b;
    if (!hiddenTextarea) {
      hiddenTextarea = document.createElement("textarea");
      ((_a = targetElement.parentNode) != null ? _a : document.body).appendChild(hiddenTextarea);
    }
    const { paddingSize, borderSize, boxSizing, contextStyle } = calculateNodeStyling(targetElement);
    contextStyle.forEach(([key, value]) => hiddenTextarea == null ? void 0 : hiddenTextarea.style.setProperty(key, value));
    Object.entries(HIDDEN_STYLE).forEach(([key, value]) => hiddenTextarea == null ? void 0 : hiddenTextarea.style.setProperty(key, value, "important"));
    hiddenTextarea.value = targetElement.value || targetElement.placeholder || "";
    let height = hiddenTextarea.scrollHeight;
    const result = {};
    if (boxSizing === "border-box") {
      height = height + borderSize;
    } else if (boxSizing === "content-box") {
      height = height - paddingSize;
    }
    hiddenTextarea.value = "";
    const singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
    if (isNumber(minRows)) {
      let minHeight = singleRowHeight * minRows;
      if (boxSizing === "border-box") {
        minHeight = minHeight + paddingSize + borderSize;
      }
      height = Math.max(minHeight, height);
      result.minHeight = `${minHeight}px`;
    }
    if (isNumber(maxRows)) {
      let maxHeight = singleRowHeight * maxRows;
      if (boxSizing === "border-box") {
        maxHeight = maxHeight + paddingSize + borderSize;
      }
      height = Math.min(maxHeight, height);
    }
    result.height = `${height}px`;
    (_b = hiddenTextarea.parentNode) == null ? void 0 : _b.removeChild(hiddenTextarea);
    hiddenTextarea = void 0;
    return result;
  }

  const inputProps = buildProps({
    id: {
      type: String,
      default: void 0
    },
    size: useSizeProp,
    disabled: Boolean,
    modelValue: {
      type: definePropType([
        String,
        Number,
        Object
      ]),
      default: ""
    },
    modelModifiers: {
      type: definePropType(Object),
      default: () => ({})
    },
    maxlength: {
      type: [String, Number]
    },
    minlength: {
      type: [String, Number]
    },
    type: {
      type: String,
      default: "text"
    },
    resize: {
      type: String,
      values: ["none", "both", "horizontal", "vertical"]
    },
    autosize: {
      type: definePropType([Boolean, Object]),
      default: false
    },
    autocomplete: {
      type: definePropType(String),
      default: "off"
    },
    formatter: {
      type: Function
    },
    parser: {
      type: Function
    },
    placeholder: {
      type: String
    },
    form: {
      type: String
    },
    readonly: Boolean,
    clearable: Boolean,
    clearIcon: {
      type: iconPropType,
      default: circle_close_default
    },
    showPassword: Boolean,
    showWordLimit: Boolean,
    wordLimitPosition: {
      type: String,
      values: ["inside", "outside"],
      default: "inside"
    },
    suffixIcon: {
      type: iconPropType
    },
    prefixIcon: {
      type: iconPropType
    },
    containerRole: {
      type: String,
      default: void 0
    },
    tabindex: {
      type: [String, Number],
      default: 0
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    inputStyle: {
      type: definePropType([Object, Array, String]),
      default: () => mutable({})
    },
    autofocus: Boolean,
    rows: {
      type: Number,
      default: 2
    },
    ...useAriaProps(["ariaLabel"]),
    inputmode: {
      type: definePropType(String),
      default: void 0
    },
    name: String
  });
  const inputEmits = {
    [UPDATE_MODEL_EVENT]: (value) => isString$1(value),
    input: (value) => isString$1(value),
    change: (value) => isString$1(value),
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent,
    clear: () => true,
    mouseleave: (evt) => evt instanceof MouseEvent,
    mouseenter: (evt) => evt instanceof MouseEvent,
    keydown: (evt) => evt instanceof Event,
    compositionstart: (evt) => evt instanceof CompositionEvent,
    compositionupdate: (evt) => evt instanceof CompositionEvent,
    compositionend: (evt) => evt instanceof CompositionEvent
  };

  const COMPONENT_NAME$m = "ElInput";
  const __default__$1T = vue.defineComponent({
    name: COMPONENT_NAME$m,
    inheritAttrs: false
  });
  const _sfc_main$2q = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1T,
    props: inputProps,
    emits: inputEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const rawAttrs = vue.useAttrs();
      const attrs = useAttrs();
      const slots = vue.useSlots();
      const containerKls = vue.computed(() => [
        props.type === "textarea" ? nsTextarea.b() : nsInput.b(),
        nsInput.m(inputSize.value),
        nsInput.is("disabled", inputDisabled.value),
        nsInput.is("exceed", inputExceed.value),
        {
          [nsInput.b("group")]: slots.prepend || slots.append,
          [nsInput.m("prefix")]: slots.prefix || props.prefixIcon,
          [nsInput.m("suffix")]: slots.suffix || props.suffixIcon || props.clearable || props.showPassword,
          [nsInput.bm("suffix", "password-clear")]: showClear.value && showPwdVisible.value,
          [nsInput.b("hidden")]: props.type === "hidden"
        },
        rawAttrs.class
      ]);
      const wrapperKls = vue.computed(() => [
        nsInput.e("wrapper"),
        nsInput.is("focus", isFocused.value)
      ]);
      const { form: elForm, formItem: elFormItem } = useFormItem();
      const { inputId } = useFormItemInputId(props, {
        formItemContext: elFormItem
      });
      const inputSize = useFormSize();
      const inputDisabled = useFormDisabled();
      const nsInput = useNamespace("input");
      const nsTextarea = useNamespace("textarea");
      const input = vue.shallowRef();
      const textarea = vue.shallowRef();
      const hovering = vue.ref(false);
      const passwordVisible = vue.ref(false);
      const countStyle = vue.ref();
      const textareaCalcStyle = vue.shallowRef(props.inputStyle);
      const _ref = vue.computed(() => input.value || textarea.value);
      const { wrapperRef, isFocused, handleFocus, handleBlur } = useFocusController(_ref, {
        disabled: inputDisabled,
        afterBlur() {
          var _a;
          if (props.validateEvent) {
            (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "blur").catch((err) => debugWarn(err));
          }
        }
      });
      const needStatusIcon = vue.computed(() => {
        var _a;
        return (_a = elForm == null ? void 0 : elForm.statusIcon) != null ? _a : false;
      });
      const validateState = vue.computed(() => (elFormItem == null ? void 0 : elFormItem.validateState) || "");
      const validateIcon = vue.computed(() => validateState.value && ValidateComponentsMap[validateState.value]);
      const passwordIcon = vue.computed(() => passwordVisible.value ? view_default : hide_default);
      const containerStyle = vue.computed(() => [
        rawAttrs.style
      ]);
      const textareaStyle = vue.computed(() => [
        props.inputStyle,
        textareaCalcStyle.value,
        { resize: props.resize }
      ]);
      const nativeInputValue = vue.computed(() => isNil(props.modelValue) ? "" : String(props.modelValue));
      const showClear = vue.computed(() => props.clearable && !inputDisabled.value && !props.readonly && !!nativeInputValue.value && (isFocused.value || hovering.value));
      const showPwdVisible = vue.computed(() => props.showPassword && !inputDisabled.value && !!nativeInputValue.value);
      const isWordLimitVisible = vue.computed(() => props.showWordLimit && !!props.maxlength && (props.type === "text" || props.type === "textarea") && !inputDisabled.value && !props.readonly && !props.showPassword);
      const textLength = vue.computed(() => nativeInputValue.value.length);
      const inputExceed = vue.computed(() => !!isWordLimitVisible.value && textLength.value > Number(props.maxlength));
      const suffixVisible = vue.computed(() => !!slots.suffix || !!props.suffixIcon || showClear.value || props.showPassword || isWordLimitVisible.value || !!validateState.value && needStatusIcon.value);
      const hasModelModifiers = vue.computed(() => !!Object.keys(props.modelModifiers).length);
      const [recordCursor, setCursor] = useCursor(input);
      useResizeObserver(textarea, (entries) => {
        onceInitSizeTextarea();
        if (!isWordLimitVisible.value || props.resize !== "both")
          return;
        const entry = entries[0];
        const { width } = entry.contentRect;
        countStyle.value = {
          right: `calc(100% - ${width + 15 + 6}px)`
        };
      });
      const resizeTextarea = () => {
        const { type, autosize } = props;
        if (!isClient || type !== "textarea" || !textarea.value)
          return;
        if (autosize) {
          const minRows = isObject$1(autosize) ? autosize.minRows : void 0;
          const maxRows = isObject$1(autosize) ? autosize.maxRows : void 0;
          const textareaStyle2 = calcTextareaHeight(textarea.value, minRows, maxRows);
          textareaCalcStyle.value = {
            overflowY: "hidden",
            ...textareaStyle2
          };
          vue.nextTick(() => {
            textarea.value.offsetHeight;
            textareaCalcStyle.value = textareaStyle2;
          });
        } else {
          textareaCalcStyle.value = {
            minHeight: calcTextareaHeight(textarea.value).minHeight
          };
        }
      };
      const createOnceInitResize = (resizeTextarea2) => {
        let isInit = false;
        return () => {
          var _a;
          if (isInit || !props.autosize)
            return;
          const isElHidden = ((_a = textarea.value) == null ? void 0 : _a.offsetParent) === null;
          if (!isElHidden) {
            setTimeout(resizeTextarea2);
            isInit = true;
          }
        };
      };
      const onceInitSizeTextarea = createOnceInitResize(resizeTextarea);
      const setNativeInputValue = () => {
        const input2 = _ref.value;
        const formatterValue = props.formatter ? props.formatter(nativeInputValue.value) : nativeInputValue.value;
        if (!input2 || input2.value === formatterValue)
          return;
        input2.value = formatterValue;
      };
      const formatValue = (value) => {
        const { trim, number } = props.modelModifiers;
        if (trim) {
          value = value.trim();
        }
        if (number) {
          value = `${looseToNumber(value)}`;
        }
        if (props.formatter && props.parser) {
          value = props.parser(value);
        }
        return value;
      };
      const handleInput = async (event) => {
        if (isComposing.value)
          return;
        const { lazy } = props.modelModifiers;
        let { value } = event.target;
        if (lazy) {
          emit(INPUT_EVENT, value);
          return;
        }
        value = formatValue(value);
        if (String(value) === nativeInputValue.value) {
          if (props.formatter) {
            setNativeInputValue();
          }
          return;
        }
        recordCursor();
        emit(UPDATE_MODEL_EVENT, value);
        emit(INPUT_EVENT, value);
        await vue.nextTick();
        if (props.formatter && props.parser || !hasModelModifiers.value) {
          setNativeInputValue();
        }
        setCursor();
      };
      const handleChange = async (event) => {
        let { value } = event.target;
        value = formatValue(value);
        if (props.modelModifiers.lazy) {
          emit(UPDATE_MODEL_EVENT, value);
        }
        emit(CHANGE_EVENT, value);
        await vue.nextTick();
        setNativeInputValue();
      };
      const {
        isComposing,
        handleCompositionStart,
        handleCompositionUpdate,
        handleCompositionEnd
      } = useComposition({ emit, afterComposition: handleInput });
      const handlePasswordVisible = () => {
        passwordVisible.value = !passwordVisible.value;
      };
      const focus = () => {
        var _a;
        return (_a = _ref.value) == null ? void 0 : _a.focus();
      };
      const blur = () => {
        var _a;
        return (_a = _ref.value) == null ? void 0 : _a.blur();
      };
      const handleMouseLeave = (evt) => {
        hovering.value = false;
        emit("mouseleave", evt);
      };
      const handleMouseEnter = (evt) => {
        hovering.value = true;
        emit("mouseenter", evt);
      };
      const handleKeydown = (evt) => {
        emit("keydown", evt);
      };
      const select = () => {
        var _a;
        (_a = _ref.value) == null ? void 0 : _a.select();
      };
      const clear = () => {
        emit(UPDATE_MODEL_EVENT, "");
        emit(CHANGE_EVENT, "");
        emit("clear");
        emit(INPUT_EVENT, "");
      };
      vue.watch(() => props.modelValue, () => {
        var _a;
        vue.nextTick(() => resizeTextarea());
        if (props.validateEvent) {
          (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => debugWarn(err));
        }
      });
      vue.watch(nativeInputValue, (newValue) => {
        if (!_ref.value) {
          return;
        }
        const { trim, number } = props.modelModifiers;
        const elValue = _ref.value.value;
        const displayValue = (number || props.type === "number") && !/^0\d/.test(elValue) ? `${looseToNumber(elValue)}` : elValue;
        if (displayValue === newValue) {
          return;
        }
        if (document.activeElement === _ref.value && _ref.value.type !== "range") {
          if (trim && displayValue.trim() === newValue) {
            return;
          }
        }
        setNativeInputValue();
      });
      vue.watch(() => props.type, async () => {
        await vue.nextTick();
        setNativeInputValue();
        resizeTextarea();
      });
      vue.onMounted(() => {
        if (!props.formatter && props.parser) {
          debugWarn(COMPONENT_NAME$m, "If you set the parser, you also need to set the formatter.");
        }
        setNativeInputValue();
        vue.nextTick(resizeTextarea);
      });
      expose({
        input,
        textarea,
        ref: _ref,
        textareaStyle,
        autosize: vue.toRef(props, "autosize"),
        isComposing,
        focus,
        blur,
        select,
        clear,
        resizeTextarea
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(containerKls),
            {
              [vue.unref(nsInput).bm("group", "append")]: _ctx.$slots.append,
              [vue.unref(nsInput).bm("group", "prepend")]: _ctx.$slots.prepend
            }
          ]),
          style: vue.normalizeStyle(vue.unref(containerStyle)),
          onMouseenter: handleMouseEnter,
          onMouseleave: handleMouseLeave
        }, [
          vue.createCommentVNode(" input "),
          _ctx.type !== "textarea" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
            vue.createCommentVNode(" prepend slot "),
            _ctx.$slots.prepend ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(nsInput).be("group", "prepend"))
            }, [
              vue.renderSlot(_ctx.$slots, "prepend")
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              ref_key: "wrapperRef",
              ref: wrapperRef,
              class: vue.normalizeClass(vue.unref(wrapperKls))
            }, [
              vue.createCommentVNode(" prefix slot "),
              _ctx.$slots.prefix || _ctx.prefixIcon ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 0,
                class: vue.normalizeClass(vue.unref(nsInput).e("prefix"))
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(nsInput).e("prefix-inner"))
                }, [
                  vue.renderSlot(_ctx.$slots, "prefix"),
                  _ctx.prefixIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(nsInput).e("icon"))
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.prefixIcon)))
                    ]),
                    _: 1
                  }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                ], 2)
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("input", vue.mergeProps({
                id: vue.unref(inputId),
                ref_key: "input",
                ref: input,
                class: vue.unref(nsInput).e("inner")
              }, vue.unref(attrs), {
                name: _ctx.name,
                minlength: _ctx.minlength,
                maxlength: _ctx.maxlength,
                type: _ctx.showPassword ? passwordVisible.value ? "text" : "password" : _ctx.type,
                disabled: vue.unref(inputDisabled),
                readonly: _ctx.readonly,
                autocomplete: _ctx.autocomplete,
                tabindex: _ctx.tabindex,
                "aria-label": _ctx.ariaLabel,
                placeholder: _ctx.placeholder,
                style: _ctx.inputStyle,
                form: _ctx.form,
                autofocus: _ctx.autofocus,
                role: _ctx.containerRole,
                inputmode: _ctx.inputmode,
                onCompositionstart: vue.unref(handleCompositionStart),
                onCompositionupdate: vue.unref(handleCompositionUpdate),
                onCompositionend: vue.unref(handleCompositionEnd),
                onInput: handleInput,
                onChange: handleChange,
                onKeydown: handleKeydown
              }), null, 16, ["id", "name", "minlength", "maxlength", "type", "disabled", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder", "form", "autofocus", "role", "inputmode", "onCompositionstart", "onCompositionupdate", "onCompositionend"]),
              vue.createCommentVNode(" suffix slot "),
              vue.unref(suffixVisible) ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 1,
                class: vue.normalizeClass(vue.unref(nsInput).e("suffix"))
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(nsInput).e("suffix-inner"))
                }, [
                  !vue.unref(showClear) || !vue.unref(showPwdVisible) || !vue.unref(isWordLimitVisible) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                    vue.renderSlot(_ctx.$slots, "suffix"),
                    _ctx.suffixIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 0,
                      class: vue.normalizeClass(vue.unref(nsInput).e("icon"))
                    }, {
                      default: vue.withCtx(() => [
                        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.suffixIcon)))
                      ]),
                      _: 1
                    }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                  ], 64)) : vue.createCommentVNode("v-if", true),
                  vue.unref(showClear) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 1,
                    class: vue.normalizeClass([vue.unref(nsInput).e("icon"), vue.unref(nsInput).e("clear")]),
                    onMousedown: vue.withModifiers(vue.unref(NOOP), ["prevent"]),
                    onClick: clear
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                    ]),
                    _: 1
                  }, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true),
                  vue.unref(showPwdVisible) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 2,
                    class: vue.normalizeClass([vue.unref(nsInput).e("icon"), vue.unref(nsInput).e("password")]),
                    onClick: handlePasswordVisible,
                    onMousedown: vue.withModifiers(vue.unref(NOOP), ["prevent"]),
                    onMouseup: vue.withModifiers(vue.unref(NOOP), ["prevent"])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(passwordIcon))))
                    ]),
                    _: 1
                  }, 8, ["class", "onMousedown", "onMouseup"])) : vue.createCommentVNode("v-if", true),
                  vue.unref(isWordLimitVisible) ? (vue.openBlock(), vue.createElementBlock("span", {
                    key: 3,
                    class: vue.normalizeClass([
                      vue.unref(nsInput).e("count"),
                      vue.unref(nsInput).is("outside", _ctx.wordLimitPosition === "outside")
                    ])
                  }, [
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass(vue.unref(nsInput).e("count-inner"))
                    }, vue.toDisplayString(vue.unref(textLength)) + " / " + vue.toDisplayString(_ctx.maxlength), 3)
                  ], 2)) : vue.createCommentVNode("v-if", true),
                  vue.unref(validateState) && vue.unref(validateIcon) && vue.unref(needStatusIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 4,
                    class: vue.normalizeClass([
                      vue.unref(nsInput).e("icon"),
                      vue.unref(nsInput).e("validateIcon"),
                      vue.unref(nsInput).is("loading", vue.unref(validateState) === "validating")
                    ])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(validateIcon))))
                    ]),
                    _: 1
                  }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                ], 2)
              ], 2)) : vue.createCommentVNode("v-if", true)
            ], 2),
            vue.createCommentVNode(" append slot "),
            _ctx.$slots.append ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(nsInput).be("group", "append"))
            }, [
              vue.renderSlot(_ctx.$slots, "append")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
            vue.createCommentVNode(" textarea "),
            vue.createElementVNode("textarea", vue.mergeProps({
              id: vue.unref(inputId),
              ref_key: "textarea",
              ref: textarea,
              class: [vue.unref(nsTextarea).e("inner"), vue.unref(nsInput).is("focus", vue.unref(isFocused))]
            }, vue.unref(attrs), {
              minlength: _ctx.minlength,
              maxlength: _ctx.maxlength,
              tabindex: _ctx.tabindex,
              disabled: vue.unref(inputDisabled),
              readonly: _ctx.readonly,
              autocomplete: _ctx.autocomplete,
              style: vue.unref(textareaStyle),
              "aria-label": _ctx.ariaLabel,
              placeholder: _ctx.placeholder,
              form: _ctx.form,
              autofocus: _ctx.autofocus,
              rows: _ctx.rows,
              role: _ctx.containerRole,
              onCompositionstart: vue.unref(handleCompositionStart),
              onCompositionupdate: vue.unref(handleCompositionUpdate),
              onCompositionend: vue.unref(handleCompositionEnd),
              onInput: handleInput,
              onFocus: vue.unref(handleFocus),
              onBlur: vue.unref(handleBlur),
              onChange: handleChange,
              onKeydown: handleKeydown
            }), null, 16, ["id", "minlength", "maxlength", "tabindex", "disabled", "readonly", "autocomplete", "aria-label", "placeholder", "form", "autofocus", "rows", "role", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onFocus", "onBlur"]),
            vue.unref(isWordLimitVisible) ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 0,
              style: vue.normalizeStyle(countStyle.value),
              class: vue.normalizeClass([
                vue.unref(nsInput).e("count"),
                vue.unref(nsInput).is("outside", _ctx.wordLimitPosition === "outside")
              ])
            }, vue.toDisplayString(vue.unref(textLength)) + " / " + vue.toDisplayString(_ctx.maxlength), 7)) : vue.createCommentVNode("v-if", true)
          ], 64))
        ], 38);
      };
    }
  });
  var Input = /* @__PURE__ */ _export_sfc(_sfc_main$2q, [["__file", "input.vue"]]);

  const ElInput = withInstall(Input);

  const GAP = 4;
  const BAR_MAP = {
    vertical: {
      offset: "offsetHeight",
      scroll: "scrollTop",
      scrollSize: "scrollHeight",
      size: "height",
      key: "vertical",
      axis: "Y",
      client: "clientY",
      direction: "top"
    },
    horizontal: {
      offset: "offsetWidth",
      scroll: "scrollLeft",
      scrollSize: "scrollWidth",
      size: "width",
      key: "horizontal",
      axis: "X",
      client: "clientX",
      direction: "left"
    }
  };
  const renderThumbStyle$1 = ({
    move,
    size,
    bar
  }) => ({
    [bar.size]: size,
    transform: `translate${bar.axis}(${move}%)`
  });

  const scrollbarContextKey = Symbol("scrollbarContextKey");

  const thumbProps = buildProps({
    vertical: Boolean,
    size: String,
    move: Number,
    ratio: {
      type: Number,
      required: true
    },
    always: Boolean
  });

  const COMPONENT_NAME$l = "Thumb";
  const _sfc_main$2p = /* @__PURE__ */ vue.defineComponent({
    __name: "thumb",
    props: thumbProps,
    setup(__props) {
      const props = __props;
      const scrollbar = vue.inject(scrollbarContextKey);
      const ns = useNamespace("scrollbar");
      if (!scrollbar)
        throwError(COMPONENT_NAME$l, "can not inject scrollbar context");
      const instance = vue.ref();
      const thumb = vue.ref();
      const thumbState = vue.ref({});
      const visible = vue.ref(false);
      let cursorDown = false;
      let cursorLeave = false;
      let baseScrollHeight = 0;
      let baseScrollWidth = 0;
      let originalOnSelectStart = isClient ? document.onselectstart : null;
      const bar = vue.computed(() => BAR_MAP[props.vertical ? "vertical" : "horizontal"]);
      const thumbStyle = vue.computed(() => renderThumbStyle$1({
        size: props.size,
        move: props.move,
        bar: bar.value
      }));
      const offsetRatio = vue.computed(() => instance.value[bar.value.offset] ** 2 / scrollbar.wrapElement[bar.value.scrollSize] / props.ratio / thumb.value[bar.value.offset]);
      const clickThumbHandler = (e) => {
        var _a;
        e.stopPropagation();
        if (e.ctrlKey || [1, 2].includes(e.button))
          return;
        (_a = window.getSelection()) == null ? void 0 : _a.removeAllRanges();
        startDrag(e);
        const el = e.currentTarget;
        if (!el)
          return;
        thumbState.value[bar.value.axis] = el[bar.value.offset] - (e[bar.value.client] - el.getBoundingClientRect()[bar.value.direction]);
      };
      const clickTrackHandler = (e) => {
        if (!thumb.value || !instance.value || !scrollbar.wrapElement)
          return;
        const offset = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
        const thumbHalf = thumb.value[bar.value.offset] / 2;
        const thumbPositionPercentage = (offset - thumbHalf) * 100 * offsetRatio.value / instance.value[bar.value.offset];
        scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize] / 100;
      };
      const startDrag = (e) => {
        e.stopImmediatePropagation();
        cursorDown = true;
        baseScrollHeight = scrollbar.wrapElement.scrollHeight;
        baseScrollWidth = scrollbar.wrapElement.scrollWidth;
        document.addEventListener("mousemove", mouseMoveDocumentHandler);
        document.addEventListener("mouseup", mouseUpDocumentHandler);
        originalOnSelectStart = document.onselectstart;
        document.onselectstart = () => false;
      };
      const mouseMoveDocumentHandler = (e) => {
        if (!instance.value || !thumb.value)
          return;
        if (cursorDown === false)
          return;
        const prevPage = thumbState.value[bar.value.axis];
        if (!prevPage)
          return;
        const offset = (instance.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
        const thumbClickPosition = thumb.value[bar.value.offset] - prevPage;
        const thumbPositionPercentage = (offset - thumbClickPosition) * 100 * offsetRatio.value / instance.value[bar.value.offset];
        if (bar.value.scroll === "scrollLeft") {
          scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * baseScrollWidth / 100;
        } else {
          scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * baseScrollHeight / 100;
        }
      };
      const mouseUpDocumentHandler = () => {
        cursorDown = false;
        thumbState.value[bar.value.axis] = 0;
        document.removeEventListener("mousemove", mouseMoveDocumentHandler);
        document.removeEventListener("mouseup", mouseUpDocumentHandler);
        restoreOnselectstart();
        if (cursorLeave)
          visible.value = false;
      };
      const mouseMoveScrollbarHandler = () => {
        cursorLeave = false;
        visible.value = !!props.size;
      };
      const mouseLeaveScrollbarHandler = () => {
        cursorLeave = true;
        visible.value = cursorDown;
      };
      vue.onBeforeUnmount(() => {
        restoreOnselectstart();
        document.removeEventListener("mouseup", mouseUpDocumentHandler);
      });
      const restoreOnselectstart = () => {
        if (document.onselectstart !== originalOnSelectStart)
          document.onselectstart = originalOnSelectStart;
      };
      useEventListener(vue.toRef(scrollbar, "scrollbarElement"), "mousemove", mouseMoveScrollbarHandler);
      useEventListener(vue.toRef(scrollbar, "scrollbarElement"), "mouseleave", mouseLeaveScrollbarHandler);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, {
          name: vue.unref(ns).b("fade"),
          persisted: ""
        }, {
          default: vue.withCtx(() => [
            vue.withDirectives(vue.createElementVNode("div", {
              ref_key: "instance",
              ref: instance,
              class: vue.normalizeClass([vue.unref(ns).e("bar"), vue.unref(ns).is(vue.unref(bar).key)]),
              onMousedown: clickTrackHandler,
              onClick: vue.withModifiers(() => {
              }, ["stop"])
            }, [
              vue.createElementVNode("div", {
                ref_key: "thumb",
                ref: thumb,
                class: vue.normalizeClass(vue.unref(ns).e("thumb")),
                style: vue.normalizeStyle(vue.unref(thumbStyle)),
                onMousedown: clickThumbHandler
              }, null, 38)
            ], 42, ["onClick"]), [
              [vue.vShow, _ctx.always || visible.value]
            ])
          ]),
          _: 1
        }, 8, ["name"]);
      };
    }
  });
  var Thumb = /* @__PURE__ */ _export_sfc(_sfc_main$2p, [["__file", "thumb.vue"]]);

  const barProps = buildProps({
    always: {
      type: Boolean,
      default: true
    },
    minSize: {
      type: Number,
      required: true
    }
  });

  const _sfc_main$2o = /* @__PURE__ */ vue.defineComponent({
    __name: "bar",
    props: barProps,
    setup(__props, { expose }) {
      const props = __props;
      const scrollbar = vue.inject(scrollbarContextKey);
      const moveX = vue.ref(0);
      const moveY = vue.ref(0);
      const sizeWidth = vue.ref("");
      const sizeHeight = vue.ref("");
      const ratioY = vue.ref(1);
      const ratioX = vue.ref(1);
      const handleScroll = (wrap) => {
        if (wrap) {
          const offsetHeight = wrap.offsetHeight - GAP;
          const offsetWidth = wrap.offsetWidth - GAP;
          moveY.value = wrap.scrollTop * 100 / offsetHeight * ratioY.value;
          moveX.value = wrap.scrollLeft * 100 / offsetWidth * ratioX.value;
        }
      };
      const update = () => {
        const wrap = scrollbar == null ? void 0 : scrollbar.wrapElement;
        if (!wrap)
          return;
        const offsetHeight = wrap.offsetHeight - GAP;
        const offsetWidth = wrap.offsetWidth - GAP;
        const originalHeight = offsetHeight ** 2 / wrap.scrollHeight;
        const originalWidth = offsetWidth ** 2 / wrap.scrollWidth;
        const height = Math.max(originalHeight, props.minSize);
        const width = Math.max(originalWidth, props.minSize);
        ratioY.value = originalHeight / (offsetHeight - originalHeight) / (height / (offsetHeight - height));
        ratioX.value = originalWidth / (offsetWidth - originalWidth) / (width / (offsetWidth - width));
        sizeHeight.value = height + GAP < offsetHeight ? `${height}px` : "";
        sizeWidth.value = width + GAP < offsetWidth ? `${width}px` : "";
      };
      expose({
        handleScroll,
        update
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
          vue.createVNode(Thumb, {
            move: moveX.value,
            ratio: ratioX.value,
            size: sizeWidth.value,
            always: _ctx.always
          }, null, 8, ["move", "ratio", "size", "always"]),
          vue.createVNode(Thumb, {
            move: moveY.value,
            ratio: ratioY.value,
            size: sizeHeight.value,
            vertical: "",
            always: _ctx.always
          }, null, 8, ["move", "ratio", "size", "always"])
        ], 64);
      };
    }
  });
  var Bar = /* @__PURE__ */ _export_sfc(_sfc_main$2o, [["__file", "bar.vue"]]);

  const scrollbarProps = buildProps({
    distance: {
      type: Number,
      default: 0
    },
    height: {
      type: [String, Number],
      default: ""
    },
    maxHeight: {
      type: [String, Number],
      default: ""
    },
    native: Boolean,
    wrapStyle: {
      type: definePropType([String, Object, Array]),
      default: ""
    },
    wrapClass: {
      type: [String, Array],
      default: ""
    },
    viewClass: {
      type: [String, Array],
      default: ""
    },
    viewStyle: {
      type: [String, Array, Object],
      default: ""
    },
    noresize: Boolean,
    tag: {
      type: String,
      default: "div"
    },
    always: Boolean,
    minSize: {
      type: Number,
      default: 20
    },
    tabindex: {
      type: [String, Number],
      default: void 0
    },
    id: String,
    role: String,
    ...useAriaProps(["ariaLabel", "ariaOrientation"])
  });
  const scrollbarEmits = {
    "end-reached": (direction) => ["left", "right", "top", "bottom"].includes(direction),
    scroll: ({
      scrollTop,
      scrollLeft
    }) => [scrollTop, scrollLeft].every(isNumber)
  };

  const COMPONENT_NAME$k = "ElScrollbar";
  const __default__$1S = vue.defineComponent({
    name: COMPONENT_NAME$k
  });
  const _sfc_main$2n = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1S,
    props: scrollbarProps,
    emits: scrollbarEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("scrollbar");
      let stopResizeObserver = void 0;
      let stopWrapResizeObserver = void 0;
      let stopResizeListener = void 0;
      let wrapScrollTop = 0;
      let wrapScrollLeft = 0;
      let direction = "";
      const distanceScrollState = {
        bottom: false,
        top: false,
        right: false,
        left: false
      };
      const scrollbarRef = vue.ref();
      const wrapRef = vue.ref();
      const resizeRef = vue.ref();
      const barRef = vue.ref();
      const wrapStyle = vue.computed(() => {
        const style = {};
        if (props.height)
          style.height = addUnit(props.height);
        if (props.maxHeight)
          style.maxHeight = addUnit(props.maxHeight);
        return [props.wrapStyle, style];
      });
      const wrapKls = vue.computed(() => {
        return [
          props.wrapClass,
          ns.e("wrap"),
          { [ns.em("wrap", "hidden-default")]: !props.native }
        ];
      });
      const resizeKls = vue.computed(() => {
        return [ns.e("view"), props.viewClass];
      });
      const shouldSkipDirection = (direction2) => {
        var _a;
        return (_a = distanceScrollState[direction2]) != null ? _a : false;
      };
      const DIRECTION_PAIRS = {
        top: "bottom",
        bottom: "top",
        left: "right",
        right: "left"
      };
      const updateTriggerStatus = (arrivedStates) => {
        const oppositeDirection = DIRECTION_PAIRS[direction];
        if (!oppositeDirection)
          return;
        const arrived = arrivedStates[direction];
        const oppositeArrived = arrivedStates[oppositeDirection];
        if (arrived && !distanceScrollState[direction]) {
          distanceScrollState[direction] = true;
        }
        if (!oppositeArrived && distanceScrollState[oppositeDirection]) {
          distanceScrollState[oppositeDirection] = false;
        }
      };
      const handleScroll = () => {
        var _a;
        if (wrapRef.value) {
          (_a = barRef.value) == null ? void 0 : _a.handleScroll(wrapRef.value);
          const prevTop = wrapScrollTop;
          const prevLeft = wrapScrollLeft;
          wrapScrollTop = wrapRef.value.scrollTop;
          wrapScrollLeft = wrapRef.value.scrollLeft;
          const arrivedStates = {
            bottom: wrapScrollTop + wrapRef.value.clientHeight >= wrapRef.value.scrollHeight - props.distance,
            top: wrapScrollTop <= props.distance && prevTop !== 0,
            right: wrapScrollLeft + wrapRef.value.clientWidth >= wrapRef.value.scrollWidth - props.distance && prevLeft !== wrapScrollLeft,
            left: wrapScrollLeft <= props.distance && prevLeft !== 0
          };
          emit("scroll", {
            scrollTop: wrapScrollTop,
            scrollLeft: wrapScrollLeft
          });
          if (prevTop !== wrapScrollTop) {
            direction = wrapScrollTop > prevTop ? "bottom" : "top";
          }
          if (prevLeft !== wrapScrollLeft) {
            direction = wrapScrollLeft > prevLeft ? "right" : "left";
          }
          if (props.distance > 0) {
            if (shouldSkipDirection(direction)) {
              return;
            }
            updateTriggerStatus(arrivedStates);
          }
          if (arrivedStates[direction])
            emit("end-reached", direction);
        }
      };
      function scrollTo(arg1, arg2) {
        if (isObject$1(arg1)) {
          wrapRef.value.scrollTo(arg1);
        } else if (isNumber(arg1) && isNumber(arg2)) {
          wrapRef.value.scrollTo(arg1, arg2);
        }
      }
      const setScrollTop = (value) => {
        if (!isNumber(value)) {
          debugWarn(COMPONENT_NAME$k, "value must be a number");
          return;
        }
        wrapRef.value.scrollTop = value;
      };
      const setScrollLeft = (value) => {
        if (!isNumber(value)) {
          debugWarn(COMPONENT_NAME$k, "value must be a number");
          return;
        }
        wrapRef.value.scrollLeft = value;
      };
      const update = () => {
        var _a;
        (_a = barRef.value) == null ? void 0 : _a.update();
        distanceScrollState[direction] = false;
      };
      vue.watch(() => props.noresize, (noresize) => {
        if (noresize) {
          stopResizeObserver == null ? void 0 : stopResizeObserver();
          stopWrapResizeObserver == null ? void 0 : stopWrapResizeObserver();
          stopResizeListener == null ? void 0 : stopResizeListener();
        } else {
          ({ stop: stopResizeObserver } = useResizeObserver(resizeRef, update));
          ({ stop: stopWrapResizeObserver } = useResizeObserver(wrapRef, update));
          stopResizeListener = useEventListener("resize", update);
        }
      }, { immediate: true });
      vue.watch(() => [props.maxHeight, props.height], () => {
        if (!props.native)
          vue.nextTick(() => {
            var _a;
            update();
            if (wrapRef.value) {
              (_a = barRef.value) == null ? void 0 : _a.handleScroll(wrapRef.value);
            }
          });
      });
      vue.provide(scrollbarContextKey, vue.reactive({
        scrollbarElement: scrollbarRef,
        wrapElement: wrapRef
      }));
      vue.onActivated(() => {
        if (wrapRef.value) {
          wrapRef.value.scrollTop = wrapScrollTop;
          wrapRef.value.scrollLeft = wrapScrollLeft;
        }
      });
      vue.onMounted(() => {
        if (!props.native)
          vue.nextTick(() => {
            update();
          });
      });
      vue.onUpdated(() => update());
      expose({
        wrapRef,
        update,
        scrollTo,
        setScrollTop,
        setScrollLeft,
        handleScroll
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "scrollbarRef",
          ref: scrollbarRef,
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.createElementVNode("div", {
            ref_key: "wrapRef",
            ref: wrapRef,
            class: vue.normalizeClass(vue.unref(wrapKls)),
            style: vue.normalizeStyle(vue.unref(wrapStyle)),
            tabindex: _ctx.tabindex,
            onScroll: handleScroll
          }, [
            (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
              id: _ctx.id,
              ref_key: "resizeRef",
              ref: resizeRef,
              class: vue.normalizeClass(vue.unref(resizeKls)),
              style: vue.normalizeStyle(_ctx.viewStyle),
              role: _ctx.role,
              "aria-label": _ctx.ariaLabel,
              "aria-orientation": _ctx.ariaOrientation
            }, {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 8, ["id", "class", "style", "role", "aria-label", "aria-orientation"]))
          ], 46, ["tabindex"]),
          !_ctx.native ? (vue.openBlock(), vue.createBlock(Bar, {
            key: 0,
            ref_key: "barRef",
            ref: barRef,
            always: _ctx.always,
            "min-size": _ctx.minSize
          }, null, 8, ["always", "min-size"])) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var Scrollbar$1 = /* @__PURE__ */ _export_sfc(_sfc_main$2n, [["__file", "scrollbar.vue"]]);

  const ElScrollbar = withInstall(Scrollbar$1);

  const POPPER_INJECTION_KEY = Symbol("popper");
  const POPPER_CONTENT_INJECTION_KEY = Symbol("popperContent");

  const Effect = {
    LIGHT: "light",
    DARK: "dark"
  };
  const roleTypes = [
    "dialog",
    "grid",
    "group",
    "listbox",
    "menu",
    "navigation",
    "tooltip",
    "tree"
  ];
  const popperProps = buildProps({
    role: {
      type: String,
      values: roleTypes,
      default: "tooltip"
    }
  });
  const usePopperProps = popperProps;

  const __default__$1R = vue.defineComponent({
    name: "ElPopper",
    inheritAttrs: false
  });
  const _sfc_main$2m = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1R,
    props: popperProps,
    setup(__props, { expose }) {
      const props = __props;
      const triggerRef = vue.ref();
      const popperInstanceRef = vue.ref();
      const contentRef = vue.ref();
      const referenceRef = vue.ref();
      const role = vue.computed(() => props.role);
      const popperProvides = {
        triggerRef,
        popperInstanceRef,
        contentRef,
        referenceRef,
        role
      };
      expose(popperProvides);
      vue.provide(POPPER_INJECTION_KEY, popperProvides);
      return (_ctx, _cache) => {
        return vue.renderSlot(_ctx.$slots, "default");
      };
    }
  });
  var Popper = /* @__PURE__ */ _export_sfc(_sfc_main$2m, [["__file", "popper.vue"]]);

  const __default__$1Q = vue.defineComponent({
    name: "ElPopperArrow",
    inheritAttrs: false
  });
  const _sfc_main$2l = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1Q,
    setup(__props, { expose }) {
      const ns = useNamespace("popper");
      const { arrowRef, arrowStyle } = vue.inject(POPPER_CONTENT_INJECTION_KEY, void 0);
      vue.onBeforeUnmount(() => {
        arrowRef.value = void 0;
      });
      expose({
        arrowRef
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("span", {
          ref_key: "arrowRef",
          ref: arrowRef,
          class: vue.normalizeClass(vue.unref(ns).e("arrow")),
          style: vue.normalizeStyle(vue.unref(arrowStyle)),
          "data-popper-arrow": ""
        }, null, 6);
      };
    }
  });
  var ElPopperArrow = /* @__PURE__ */ _export_sfc(_sfc_main$2l, [["__file", "arrow.vue"]]);

  const NAME = "ElOnlyChild";
  const OnlyChild = vue.defineComponent({
    name: NAME,
    setup(_, {
      slots,
      attrs
    }) {
      var _a;
      const forwardRefInjection = vue.inject(FORWARD_REF_INJECTION_KEY);
      const forwardRefDirective = useForwardRefDirective((_a = forwardRefInjection == null ? void 0 : forwardRefInjection.setForwardRef) != null ? _a : NOOP);
      return () => {
        var _a2;
        const defaultSlot = (_a2 = slots.default) == null ? void 0 : _a2.call(slots, attrs);
        if (!defaultSlot)
          return null;
        const [firstLegitNode, length] = findFirstLegitChild(defaultSlot);
        if (!firstLegitNode) {
          debugWarn(NAME, "no valid child node found");
          return null;
        }
        if (length > 1) {
          debugWarn(NAME, "requires exact only one valid child.");
        }
        return vue.withDirectives(vue.cloneVNode(firstLegitNode, attrs), [[forwardRefDirective]]);
      };
    }
  });
  function findFirstLegitChild(node) {
    if (!node)
      return [null, 0];
    const children = node;
    const len = children.filter((c) => c.type !== vue.Comment).length;
    for (const child of children) {
      if (isObject$1(child)) {
        switch (child.type) {
          case vue.Comment:
            continue;
          case vue.Text:
          case "svg":
            return [wrapTextContent(child), len];
          case vue.Fragment:
            return findFirstLegitChild(child.children);
          default:
            return [child, len];
        }
      }
      return [wrapTextContent(child), len];
    }
    return [null, 0];
  }
  function wrapTextContent(s) {
    const ns = useNamespace("only-child");
    return vue.createVNode("span", {
      "class": ns.e("content")
    }, [s]);
  }

  const popperTriggerProps = buildProps({
    virtualRef: {
      type: definePropType(Object)
    },
    virtualTriggering: Boolean,
    onMouseenter: {
      type: definePropType(Function)
    },
    onMouseleave: {
      type: definePropType(Function)
    },
    onClick: {
      type: definePropType(Function)
    },
    onKeydown: {
      type: definePropType(Function)
    },
    onFocus: {
      type: definePropType(Function)
    },
    onBlur: {
      type: definePropType(Function)
    },
    onContextmenu: {
      type: definePropType(Function)
    },
    id: String,
    open: Boolean
  });
  const usePopperTriggerProps = popperTriggerProps;

  const __default__$1P = vue.defineComponent({
    name: "ElPopperTrigger",
    inheritAttrs: false
  });
  const _sfc_main$2k = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1P,
    props: popperTriggerProps,
    setup(__props, { expose }) {
      const props = __props;
      const { role, triggerRef } = vue.inject(POPPER_INJECTION_KEY, void 0);
      useForwardRef(triggerRef);
      const ariaControls = vue.computed(() => {
        return ariaHaspopup.value ? props.id : void 0;
      });
      const ariaDescribedby = vue.computed(() => {
        if (role && role.value === "tooltip") {
          return props.open && props.id ? props.id : void 0;
        }
        return void 0;
      });
      const ariaHaspopup = vue.computed(() => {
        if (role && role.value !== "tooltip") {
          return role.value;
        }
        return void 0;
      });
      const ariaExpanded = vue.computed(() => {
        return ariaHaspopup.value ? `${props.open}` : void 0;
      });
      let virtualTriggerAriaStopWatch = void 0;
      const TRIGGER_ELE_EVENTS = [
        "onMouseenter",
        "onMouseleave",
        "onClick",
        "onKeydown",
        "onFocus",
        "onBlur",
        "onContextmenu"
      ];
      vue.onMounted(() => {
        vue.watch(() => props.virtualRef, (virtualEl) => {
          if (virtualEl) {
            triggerRef.value = unrefElement(virtualEl);
          }
        }, {
          immediate: true
        });
        vue.watch(triggerRef, (el, prevEl) => {
          virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
          virtualTriggerAriaStopWatch = void 0;
          if (isElement$2(el)) {
            TRIGGER_ELE_EVENTS.forEach((eventName) => {
              var _a;
              const handler = props[eventName];
              if (handler) {
                el.addEventListener(eventName.slice(2).toLowerCase(), handler, ["onFocus", "onBlur"].includes(eventName));
                (_a = prevEl == null ? void 0 : prevEl.removeEventListener) == null ? void 0 : _a.call(prevEl, eventName.slice(2).toLowerCase(), handler, ["onFocus", "onBlur"].includes(eventName));
              }
            });
            if (isFocusable(el)) {
              virtualTriggerAriaStopWatch = vue.watch([ariaControls, ariaDescribedby, ariaHaspopup, ariaExpanded], (watches) => {
                [
                  "aria-controls",
                  "aria-describedby",
                  "aria-haspopup",
                  "aria-expanded"
                ].forEach((key, idx) => {
                  isNil(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
                });
              }, { immediate: true });
            }
          }
          if (isElement$2(prevEl) && isFocusable(prevEl)) {
            [
              "aria-controls",
              "aria-describedby",
              "aria-haspopup",
              "aria-expanded"
            ].forEach((key) => prevEl.removeAttribute(key));
          }
        }, {
          immediate: true
        });
      });
      vue.onBeforeUnmount(() => {
        virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
        virtualTriggerAriaStopWatch = void 0;
        if (triggerRef.value && isElement$2(triggerRef.value)) {
          const el = triggerRef.value;
          TRIGGER_ELE_EVENTS.forEach((eventName) => {
            const handler = props[eventName];
            if (handler) {
              el.removeEventListener(eventName.slice(2).toLowerCase(), handler, ["onFocus", "onBlur"].includes(eventName));
            }
          });
          triggerRef.value = void 0;
        }
      });
      expose({
        triggerRef
      });
      return (_ctx, _cache) => {
        return !_ctx.virtualTriggering ? (vue.openBlock(), vue.createBlock(vue.unref(OnlyChild), vue.mergeProps({ key: 0 }, _ctx.$attrs, {
          "aria-controls": vue.unref(ariaControls),
          "aria-describedby": vue.unref(ariaDescribedby),
          "aria-expanded": vue.unref(ariaExpanded),
          "aria-haspopup": vue.unref(ariaHaspopup)
        }), {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 16, ["aria-controls", "aria-describedby", "aria-expanded", "aria-haspopup"])) : vue.createCommentVNode("v-if", true);
      };
    }
  });
  var ElPopperTrigger = /* @__PURE__ */ _export_sfc(_sfc_main$2k, [["__file", "trigger.vue"]]);

  const FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
  const FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
  const FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
  const FOCUS_AFTER_TRAPPED_OPTS = {
    cancelable: true,
    bubbles: false
  };
  const FOCUSOUT_PREVENTED_OPTS = {
    cancelable: true,
    bubbles: false
  };
  const ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
  const ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
  const FOCUS_TRAP_INJECTION_KEY = Symbol("elFocusTrap");

  const focusReason = vue.ref();
  const lastUserFocusTimestamp = vue.ref(0);
  const lastAutomatedFocusTimestamp = vue.ref(0);
  let focusReasonUserCount = 0;
  const obtainAllFocusableElements = (element) => {
    const nodes = [];
    const walker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT, {
      acceptNode: (node) => {
        const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
        if (node.disabled || node.hidden || isHiddenInput)
          return NodeFilter.FILTER_SKIP;
        return node.tabIndex >= 0 || node === document.activeElement ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
      }
    });
    while (walker.nextNode())
      nodes.push(walker.currentNode);
    return nodes;
  };
  const getVisibleElement = (elements, container) => {
    for (const element of elements) {
      if (!isHidden(element, container))
        return element;
    }
  };
  const isHidden = (element, container) => {
    if (getComputedStyle(element).visibility === "hidden")
      return true;
    while (element) {
      if (container && element === container)
        return false;
      if (getComputedStyle(element).display === "none")
        return true;
      element = element.parentElement;
    }
    return false;
  };
  const getEdges = (container) => {
    const focusable = obtainAllFocusableElements(container);
    const first = getVisibleElement(focusable, container);
    const last = getVisibleElement(focusable.reverse(), container);
    return [first, last];
  };
  const isSelectable = (element) => {
    return element instanceof HTMLInputElement && "select" in element;
  };
  const tryFocus = (element, shouldSelect) => {
    if (element) {
      const prevFocusedElement = document.activeElement;
      focusElement(element, { preventScroll: true });
      lastAutomatedFocusTimestamp.value = window.performance.now();
      if (element !== prevFocusedElement && isSelectable(element) && shouldSelect) {
        element.select();
      }
    }
  };
  function removeFromStack(list, item) {
    const copy = [...list];
    const idx = list.indexOf(item);
    if (idx !== -1) {
      copy.splice(idx, 1);
    }
    return copy;
  }
  const createFocusableStack = () => {
    let stack = [];
    const push = (layer) => {
      const currentLayer = stack[0];
      if (currentLayer && layer !== currentLayer) {
        currentLayer.pause();
      }
      stack = removeFromStack(stack, layer);
      stack.unshift(layer);
    };
    const remove = (layer) => {
      var _a, _b;
      stack = removeFromStack(stack, layer);
      (_b = (_a = stack[0]) == null ? void 0 : _a.resume) == null ? void 0 : _b.call(_a);
    };
    return {
      push,
      remove
    };
  };
  const focusFirstDescendant = (elements, shouldSelect = false) => {
    const prevFocusedElement = document.activeElement;
    for (const element of elements) {
      tryFocus(element, shouldSelect);
      if (document.activeElement !== prevFocusedElement)
        return;
    }
  };
  const focusableStack = createFocusableStack();
  const isFocusCausedByUserEvent = () => {
    return lastUserFocusTimestamp.value > lastAutomatedFocusTimestamp.value;
  };
  const notifyFocusReasonPointer = () => {
    focusReason.value = "pointer";
    lastUserFocusTimestamp.value = window.performance.now();
  };
  const notifyFocusReasonKeydown = () => {
    focusReason.value = "keyboard";
    lastUserFocusTimestamp.value = window.performance.now();
  };
  const useFocusReason = () => {
    vue.onMounted(() => {
      if (focusReasonUserCount === 0) {
        document.addEventListener("mousedown", notifyFocusReasonPointer);
        document.addEventListener("touchstart", notifyFocusReasonPointer);
        document.addEventListener("keydown", notifyFocusReasonKeydown);
      }
      focusReasonUserCount++;
    });
    vue.onBeforeUnmount(() => {
      focusReasonUserCount--;
      if (focusReasonUserCount <= 0) {
        document.removeEventListener("mousedown", notifyFocusReasonPointer);
        document.removeEventListener("touchstart", notifyFocusReasonPointer);
        document.removeEventListener("keydown", notifyFocusReasonKeydown);
      }
    });
    return {
      focusReason,
      lastUserFocusTimestamp,
      lastAutomatedFocusTimestamp
    };
  };
  const createFocusOutPreventedEvent = (detail) => {
    return new CustomEvent(FOCUSOUT_PREVENTED, {
      ...FOCUSOUT_PREVENTED_OPTS,
      detail
    });
  };

  const _sfc_main$2j = vue.defineComponent({
    name: "ElFocusTrap",
    inheritAttrs: false,
    props: {
      loop: Boolean,
      trapped: Boolean,
      focusTrapEl: Object,
      focusStartEl: {
        type: [Object, String],
        default: "first"
      }
    },
    emits: [
      ON_TRAP_FOCUS_EVT,
      ON_RELEASE_FOCUS_EVT,
      "focusin",
      "focusout",
      "focusout-prevented",
      "release-requested"
    ],
    setup(props, { emit }) {
      const forwardRef = vue.ref();
      let lastFocusBeforeTrapped;
      let lastFocusAfterTrapped;
      const { focusReason } = useFocusReason();
      useEscapeKeydown((event) => {
        if (props.trapped && !focusLayer.paused) {
          emit("release-requested", event);
        }
      });
      const focusLayer = {
        paused: false,
        pause() {
          this.paused = true;
        },
        resume() {
          this.paused = false;
        }
      };
      const onKeydown = (e) => {
        if (!props.loop && !props.trapped)
          return;
        if (focusLayer.paused)
          return;
        const { altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
        const { loop } = props;
        const code = getEventCode(e);
        const isTabbing = code === EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
        const currentFocusingEl = document.activeElement;
        if (isTabbing && currentFocusingEl) {
          const container = currentTarget;
          const [first, last] = getEdges(container);
          const isTabbable = first && last;
          if (!isTabbable) {
            if (currentFocusingEl === container) {
              const focusoutPreventedEvent = createFocusOutPreventedEvent({
                focusReason: focusReason.value
              });
              emit("focusout-prevented", focusoutPreventedEvent);
              if (!focusoutPreventedEvent.defaultPrevented) {
                e.preventDefault();
              }
            }
          } else {
            if (!shiftKey && currentFocusingEl === last) {
              const focusoutPreventedEvent = createFocusOutPreventedEvent({
                focusReason: focusReason.value
              });
              emit("focusout-prevented", focusoutPreventedEvent);
              if (!focusoutPreventedEvent.defaultPrevented) {
                e.preventDefault();
                if (loop)
                  tryFocus(first, true);
              }
            } else if (shiftKey && [first, container].includes(currentFocusingEl)) {
              const focusoutPreventedEvent = createFocusOutPreventedEvent({
                focusReason: focusReason.value
              });
              emit("focusout-prevented", focusoutPreventedEvent);
              if (!focusoutPreventedEvent.defaultPrevented) {
                e.preventDefault();
                if (loop)
                  tryFocus(last, true);
              }
            }
          }
        }
      };
      vue.provide(FOCUS_TRAP_INJECTION_KEY, {
        focusTrapRef: forwardRef,
        onKeydown
      });
      vue.watch(() => props.focusTrapEl, (focusTrapEl) => {
        if (focusTrapEl) {
          forwardRef.value = focusTrapEl;
        }
      }, { immediate: true });
      vue.watch([forwardRef], ([forwardRef2], [oldForwardRef]) => {
        if (forwardRef2) {
          forwardRef2.addEventListener("keydown", onKeydown);
          forwardRef2.addEventListener("focusin", onFocusIn);
          forwardRef2.addEventListener("focusout", onFocusOut);
        }
        if (oldForwardRef) {
          oldForwardRef.removeEventListener("keydown", onKeydown);
          oldForwardRef.removeEventListener("focusin", onFocusIn);
          oldForwardRef.removeEventListener("focusout", onFocusOut);
        }
      });
      const trapOnFocus = (e) => {
        emit(ON_TRAP_FOCUS_EVT, e);
      };
      const releaseOnFocus = (e) => emit(ON_RELEASE_FOCUS_EVT, e);
      const onFocusIn = (e) => {
        const trapContainer = vue.unref(forwardRef);
        if (!trapContainer)
          return;
        const target = e.target;
        const relatedTarget = e.relatedTarget;
        const isFocusedInTrap = target && trapContainer.contains(target);
        if (!props.trapped) {
          const isPrevFocusedInTrap = relatedTarget && trapContainer.contains(relatedTarget);
          if (!isPrevFocusedInTrap) {
            lastFocusBeforeTrapped = relatedTarget;
          }
        }
        if (isFocusedInTrap)
          emit("focusin", e);
        if (focusLayer.paused)
          return;
        if (props.trapped) {
          if (isFocusedInTrap) {
            lastFocusAfterTrapped = target;
          } else {
            tryFocus(lastFocusAfterTrapped, true);
          }
        }
      };
      const onFocusOut = (e) => {
        const trapContainer = vue.unref(forwardRef);
        if (focusLayer.paused || !trapContainer)
          return;
        if (props.trapped) {
          const relatedTarget = e.relatedTarget;
          if (!isNil(relatedTarget) && !trapContainer.contains(relatedTarget)) {
            setTimeout(() => {
              if (!focusLayer.paused && props.trapped) {
                const focusoutPreventedEvent = createFocusOutPreventedEvent({
                  focusReason: focusReason.value
                });
                emit("focusout-prevented", focusoutPreventedEvent);
                if (!focusoutPreventedEvent.defaultPrevented) {
                  tryFocus(lastFocusAfterTrapped, true);
                }
              }
            }, 0);
          }
        } else {
          const target = e.target;
          const isFocusedInTrap = target && trapContainer.contains(target);
          if (!isFocusedInTrap)
            emit("focusout", e);
        }
      };
      async function startTrap() {
        await vue.nextTick();
        const trapContainer = vue.unref(forwardRef);
        if (trapContainer) {
          focusableStack.push(focusLayer);
          const prevFocusedElement = trapContainer.contains(document.activeElement) ? lastFocusBeforeTrapped : document.activeElement;
          lastFocusBeforeTrapped = prevFocusedElement;
          const isPrevFocusContained = trapContainer.contains(prevFocusedElement);
          if (!isPrevFocusContained) {
            const focusEvent = new Event(FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS);
            trapContainer.addEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
            trapContainer.dispatchEvent(focusEvent);
            if (!focusEvent.defaultPrevented) {
              vue.nextTick(() => {
                let focusStartEl = props.focusStartEl;
                if (!isString$1(focusStartEl)) {
                  tryFocus(focusStartEl);
                  if (document.activeElement !== focusStartEl) {
                    focusStartEl = "first";
                  }
                }
                if (focusStartEl === "first") {
                  focusFirstDescendant(obtainAllFocusableElements(trapContainer), true);
                }
                if (document.activeElement === prevFocusedElement || focusStartEl === "container") {
                  tryFocus(trapContainer);
                }
              });
            }
          }
        }
      }
      function stopTrap() {
        const trapContainer = vue.unref(forwardRef);
        if (trapContainer) {
          trapContainer.removeEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
          const releasedEvent = new CustomEvent(FOCUS_AFTER_RELEASED, {
            ...FOCUS_AFTER_TRAPPED_OPTS,
            detail: {
              focusReason: focusReason.value
            }
          });
          trapContainer.addEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
          trapContainer.dispatchEvent(releasedEvent);
          if (!releasedEvent.defaultPrevented && (focusReason.value == "keyboard" || !isFocusCausedByUserEvent() || trapContainer.contains(document.activeElement))) {
            tryFocus(lastFocusBeforeTrapped != null ? lastFocusBeforeTrapped : document.body);
          }
          trapContainer.removeEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
          focusableStack.remove(focusLayer);
          lastFocusBeforeTrapped = null;
          lastFocusAfterTrapped = null;
        }
      }
      vue.onMounted(() => {
        if (props.trapped) {
          startTrap();
        }
        vue.watch(() => props.trapped, (trapped) => {
          if (trapped) {
            startTrap();
          } else {
            stopTrap();
          }
        });
      });
      vue.onBeforeUnmount(() => {
        if (props.trapped) {
          stopTrap();
        }
        if (forwardRef.value) {
          forwardRef.value.removeEventListener("keydown", onKeydown);
          forwardRef.value.removeEventListener("focusin", onFocusIn);
          forwardRef.value.removeEventListener("focusout", onFocusOut);
          forwardRef.value = void 0;
        }
      });
      return {
        onKeydown
      };
    }
  });
  function _sfc_render$l(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.renderSlot(_ctx.$slots, "default", { handleKeydown: _ctx.onKeydown });
  }
  var ElFocusTrap = /* @__PURE__ */ _export_sfc(_sfc_main$2j, [["render", _sfc_render$l], ["__file", "focus-trap.vue"]]);

  const popperArrowProps = buildProps({
    arrowOffset: {
      type: Number,
      default: 5
    }
  });
  const usePopperArrowProps = popperArrowProps;

  const POSITIONING_STRATEGIES = ["fixed", "absolute"];
  const popperCoreConfigProps = buildProps({
    boundariesPadding: {
      type: Number,
      default: 0
    },
    fallbackPlacements: {
      type: definePropType(Array),
      default: void 0
    },
    gpuAcceleration: {
      type: Boolean,
      default: true
    },
    offset: {
      type: Number,
      default: 12
    },
    placement: {
      type: String,
      values: Ee,
      default: "bottom"
    },
    popperOptions: {
      type: definePropType(Object),
      default: () => ({})
    },
    strategy: {
      type: String,
      values: POSITIONING_STRATEGIES,
      default: "absolute"
    }
  });
  const popperContentProps = buildProps({
    ...popperCoreConfigProps,
    ...popperArrowProps,
    id: String,
    style: {
      type: definePropType([String, Array, Object])
    },
    className: {
      type: definePropType([String, Array, Object])
    },
    effect: {
      type: definePropType(String),
      default: "dark"
    },
    visible: Boolean,
    enterable: {
      type: Boolean,
      default: true
    },
    pure: Boolean,
    focusOnShow: Boolean,
    trapping: Boolean,
    popperClass: {
      type: definePropType([String, Array, Object])
    },
    popperStyle: {
      type: definePropType([String, Array, Object])
    },
    referenceEl: {
      type: definePropType(Object)
    },
    triggerTargetEl: {
      type: definePropType(Object)
    },
    stopPopperMouseEvent: {
      type: Boolean,
      default: true
    },
    virtualTriggering: Boolean,
    zIndex: Number,
    ...useAriaProps(["ariaLabel"]),
    loop: Boolean
  });
  const popperContentEmits = {
    mouseenter: (evt) => evt instanceof MouseEvent,
    mouseleave: (evt) => evt instanceof MouseEvent,
    focus: () => true,
    blur: () => true,
    close: () => true
  };
  const usePopperCoreConfigProps = popperCoreConfigProps;
  const usePopperContentProps = popperContentProps;
  const usePopperContentEmits = popperContentEmits;

  const buildPopperOptions = (props, modifiers = []) => {
    const { placement, strategy, popperOptions } = props;
    const options = {
      placement,
      strategy,
      ...popperOptions,
      modifiers: [...genModifiers(props), ...modifiers]
    };
    deriveExtraModifiers(options, popperOptions == null ? void 0 : popperOptions.modifiers);
    return options;
  };
  const unwrapMeasurableEl = ($el) => {
    if (!isClient)
      return;
    return unrefElement($el);
  };
  function genModifiers(options) {
    const { offset, gpuAcceleration, fallbackPlacements } = options;
    return [
      {
        name: "offset",
        options: {
          offset: [0, offset != null ? offset : 12]
        }
      },
      {
        name: "preventOverflow",
        options: {
          padding: {
            top: 0,
            bottom: 0,
            left: 0,
            right: 0
          }
        }
      },
      {
        name: "flip",
        options: {
          padding: 5,
          fallbackPlacements
        }
      },
      {
        name: "computeStyles",
        options: {
          gpuAcceleration
        }
      }
    ];
  }
  function deriveExtraModifiers(options, modifiers) {
    if (modifiers) {
      options.modifiers = [...options.modifiers, ...modifiers != null ? modifiers : []];
    }
  }

  const DEFAULT_ARROW_OFFSET = 0;
  const usePopperContent = (props) => {
    const { popperInstanceRef, contentRef, triggerRef, role } = vue.inject(POPPER_INJECTION_KEY, void 0);
    const arrowRef = vue.ref();
    const arrowOffset = vue.computed(() => props.arrowOffset);
    const eventListenerModifier = vue.computed(() => {
      return {
        name: "eventListeners",
        enabled: !!props.visible
      };
    });
    const arrowModifier = vue.computed(() => {
      var _a;
      const arrowEl = vue.unref(arrowRef);
      const offset = (_a = vue.unref(arrowOffset)) != null ? _a : DEFAULT_ARROW_OFFSET;
      return {
        name: "arrow",
        enabled: !isUndefined$1(arrowEl),
        options: {
          element: arrowEl,
          padding: offset
        }
      };
    });
    const options = vue.computed(() => {
      return {
        onFirstUpdate: () => {
          update();
        },
        ...buildPopperOptions(props, [
          vue.unref(arrowModifier),
          vue.unref(eventListenerModifier)
        ])
      };
    });
    const computedReference = vue.computed(() => unwrapMeasurableEl(props.referenceEl) || vue.unref(triggerRef));
    const { attributes, state, styles, update, forceUpdate, instanceRef } = usePopper(computedReference, contentRef, options);
    vue.watch(instanceRef, (instance) => popperInstanceRef.value = instance, {
      flush: "sync"
    });
    vue.onMounted(() => {
      vue.watch(() => {
        var _a, _b;
        return (_b = (_a = vue.unref(computedReference)) == null ? void 0 : _a.getBoundingClientRect) == null ? void 0 : _b.call(_a);
      }, () => {
        update();
      });
    });
    return {
      attributes,
      arrowRef,
      contentRef,
      instanceRef,
      state,
      styles,
      role,
      forceUpdate,
      update
    };
  };

  const usePopperContentDOM = (props, {
    attributes,
    styles,
    role
  }) => {
    const { nextZIndex } = useZIndex();
    const ns = useNamespace("popper");
    const contentAttrs = vue.computed(() => vue.unref(attributes).popper);
    const contentZIndex = vue.ref(isNumber(props.zIndex) ? props.zIndex : nextZIndex());
    const contentClass = vue.computed(() => [
      ns.b(),
      ns.is("pure", props.pure),
      ns.is(props.effect),
      props.popperClass
    ]);
    const contentStyle = vue.computed(() => {
      return [
        { zIndex: vue.unref(contentZIndex) },
        vue.unref(styles).popper,
        props.popperStyle || {}
      ];
    });
    const ariaModal = vue.computed(() => role.value === "dialog" ? "false" : void 0);
    const arrowStyle = vue.computed(() => vue.unref(styles).arrow || {});
    const updateZIndex = () => {
      contentZIndex.value = isNumber(props.zIndex) ? props.zIndex : nextZIndex();
    };
    return {
      ariaModal,
      arrowStyle,
      contentAttrs,
      contentClass,
      contentStyle,
      contentZIndex,
      updateZIndex
    };
  };

  const usePopperContentFocusTrap = (props, emit) => {
    const trapped = vue.ref(false);
    const focusStartRef = vue.ref();
    const onFocusAfterTrapped = () => {
      emit("focus");
    };
    const onFocusAfterReleased = (event) => {
      var _a;
      if (((_a = event.detail) == null ? void 0 : _a.focusReason) !== "pointer") {
        focusStartRef.value = "first";
        emit("blur");
      }
    };
    const onFocusInTrap = (event) => {
      if (props.visible && !trapped.value) {
        if (event.target) {
          focusStartRef.value = event.target;
        }
        trapped.value = true;
      }
    };
    const onFocusoutPrevented = (event) => {
      if (!props.trapping) {
        if (event.detail.focusReason === "pointer") {
          event.preventDefault();
        }
        trapped.value = false;
      }
    };
    const onReleaseRequested = () => {
      trapped.value = false;
      emit("close");
    };
    return {
      focusStartRef,
      trapped,
      onFocusAfterReleased,
      onFocusAfterTrapped,
      onFocusInTrap,
      onFocusoutPrevented,
      onReleaseRequested
    };
  };

  const __default__$1O = vue.defineComponent({
    name: "ElPopperContent"
  });
  const _sfc_main$2i = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1O,
    props: popperContentProps,
    emits: popperContentEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const {
        focusStartRef,
        trapped,
        onFocusAfterReleased,
        onFocusAfterTrapped,
        onFocusInTrap,
        onFocusoutPrevented,
        onReleaseRequested
      } = usePopperContentFocusTrap(props, emit);
      const { attributes, arrowRef, contentRef, styles, instanceRef, role, update } = usePopperContent(props);
      const {
        ariaModal,
        arrowStyle,
        contentAttrs,
        contentClass,
        contentStyle,
        updateZIndex
      } = usePopperContentDOM(props, {
        styles,
        attributes,
        role
      });
      const formItemContext = vue.inject(formItemContextKey, void 0);
      vue.provide(POPPER_CONTENT_INJECTION_KEY, {
        arrowStyle,
        arrowRef
      });
      if (formItemContext) {
        vue.provide(formItemContextKey, {
          ...formItemContext,
          addInputId: NOOP,
          removeInputId: NOOP
        });
      }
      let triggerTargetAriaStopWatch = void 0;
      const updatePopper = (shouldUpdateZIndex = true) => {
        update();
        shouldUpdateZIndex && updateZIndex();
      };
      const togglePopperAlive = () => {
        updatePopper(false);
        if (props.visible && props.focusOnShow) {
          trapped.value = true;
        } else if (props.visible === false) {
          trapped.value = false;
        }
      };
      vue.onMounted(() => {
        vue.watch(() => props.triggerTargetEl, (triggerTargetEl, prevTriggerTargetEl) => {
          triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
          triggerTargetAriaStopWatch = void 0;
          const el = vue.unref(triggerTargetEl || contentRef.value);
          const prevEl = vue.unref(prevTriggerTargetEl || contentRef.value);
          if (isElement$2(el)) {
            triggerTargetAriaStopWatch = vue.watch([role, () => props.ariaLabel, ariaModal, () => props.id], (watches) => {
              ["role", "aria-label", "aria-modal", "id"].forEach((key, idx) => {
                isNil(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
              });
            }, { immediate: true });
          }
          if (prevEl !== el && isElement$2(prevEl)) {
            ["role", "aria-label", "aria-modal", "id"].forEach((key) => {
              prevEl.removeAttribute(key);
            });
          }
        }, { immediate: true });
        vue.watch(() => props.visible, togglePopperAlive, { immediate: true });
      });
      vue.onBeforeUnmount(() => {
        triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
        triggerTargetAriaStopWatch = void 0;
      });
      expose({
        popperContentRef: contentRef,
        popperInstanceRef: instanceRef,
        updatePopper,
        contentStyle
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
          ref_key: "contentRef",
          ref: contentRef
        }, vue.unref(contentAttrs), {
          style: vue.unref(contentStyle),
          class: vue.unref(contentClass),
          tabindex: "-1",
          onMouseenter: (e) => _ctx.$emit("mouseenter", e),
          onMouseleave: (e) => _ctx.$emit("mouseleave", e)
        }), [
          vue.createVNode(vue.unref(ElFocusTrap), {
            loop: _ctx.loop,
            trapped: vue.unref(trapped),
            "trap-on-focus-in": true,
            "focus-trap-el": vue.unref(contentRef),
            "focus-start-el": vue.unref(focusStartRef),
            onFocusAfterTrapped: vue.unref(onFocusAfterTrapped),
            onFocusAfterReleased: vue.unref(onFocusAfterReleased),
            onFocusin: vue.unref(onFocusInTrap),
            onFocusoutPrevented: vue.unref(onFocusoutPrevented),
            onReleaseRequested: vue.unref(onReleaseRequested)
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["loop", "trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
        ], 16, ["onMouseenter", "onMouseleave"]);
      };
    }
  });
  var ElPopperContent = /* @__PURE__ */ _export_sfc(_sfc_main$2i, [["__file", "content.vue"]]);

  const ElPopper = withInstall(Popper);

  const TOOLTIP_INJECTION_KEY = Symbol("elTooltip");

  const teleportProps = buildProps({
    to: {
      type: definePropType([String, Object]),
      required: true
    },
    disabled: Boolean
  });

  const _sfc_main$2h = /* @__PURE__ */ vue.defineComponent({
    __name: "teleport",
    props: teleportProps,
    setup(__props) {
      return (_ctx, _cache) => {
        return _ctx.disabled ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }) : (vue.openBlock(), vue.createBlock(vue.Teleport, {
          key: 1,
          to: _ctx.to
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 8, ["to"]));
      };
    }
  });
  var Teleport = /* @__PURE__ */ _export_sfc(_sfc_main$2h, [["__file", "teleport.vue"]]);

  const ElTeleport = withInstall(Teleport);
  var ElTeleport$1 = ElTeleport;

  const useTooltipContentProps = buildProps({
    ...useDelayedToggleProps,
    ...popperContentProps,
    appendTo: {
      type: teleportProps.to.type
    },
    content: {
      type: String,
      default: ""
    },
    rawContent: Boolean,
    persistent: Boolean,
    visible: {
      type: definePropType(Boolean),
      default: null
    },
    transition: String,
    teleported: {
      type: Boolean,
      default: true
    },
    disabled: Boolean,
    ...useAriaProps(["ariaLabel"])
  });

  const useTooltipTriggerProps = buildProps({
    ...popperTriggerProps,
    disabled: Boolean,
    trigger: {
      type: definePropType([String, Array]),
      default: "hover"
    },
    triggerKeys: {
      type: definePropType(Array),
      default: () => [EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space]
    },
    focusOnTarget: Boolean
  });

  const {
    useModelToggleProps: useTooltipModelToggleProps,
    useModelToggleEmits: useTooltipModelToggleEmits,
    useModelToggle: useTooltipModelToggle
  } = createModelToggleComposable("visible");
  const useTooltipProps = buildProps({
    ...popperProps,
    ...useTooltipModelToggleProps,
    ...useTooltipContentProps,
    ...useTooltipTriggerProps,
    ...popperArrowProps,
    showArrow: {
      type: Boolean,
      default: true
    }
  });
  const tooltipEmits = [
    ...useTooltipModelToggleEmits,
    "before-show",
    "before-hide",
    "show",
    "hide",
    "open",
    "close"
  ];

  const isTriggerType = (trigger, type) => {
    if (isArray$1(trigger)) {
      return trigger.includes(type);
    }
    return trigger === type;
  };
  const whenTrigger = (trigger, type, handler) => {
    return (e) => {
      isTriggerType(vue.unref(trigger), type) && handler(e);
    };
  };

  const __default__$1N = vue.defineComponent({
    name: "ElTooltipTrigger"
  });
  const _sfc_main$2g = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1N,
    props: useTooltipTriggerProps,
    setup(__props, { expose }) {
      const props = __props;
      const ns = useNamespace("tooltip");
      const { controlled, id, open, onOpen, onClose, onToggle } = vue.inject(TOOLTIP_INJECTION_KEY, void 0);
      const triggerRef = vue.ref(null);
      const stopWhenControlledOrDisabled = () => {
        if (vue.unref(controlled) || props.disabled) {
          return true;
        }
      };
      const trigger = vue.toRef(props, "trigger");
      const onMouseenter = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "hover", (e) => {
        onOpen(e);
        if (props.focusOnTarget && e.target) {
          vue.nextTick(() => {
            focusElement(e.target, { preventScroll: true });
          });
        }
      }));
      const onMouseleave = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "hover", onClose));
      const onClick = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "click", (e) => {
        if (e.button === 0) {
          onToggle(e);
        }
      }));
      const onFocus = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "focus", onOpen));
      const onBlur = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "focus", onClose));
      const onContextMenu = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "contextmenu", (e) => {
        e.preventDefault();
        onToggle(e);
      }));
      const onKeydown = composeEventHandlers(stopWhenControlledOrDisabled, (e) => {
        const code = getEventCode(e);
        if (props.triggerKeys.includes(code)) {
          e.preventDefault();
          onToggle(e);
        }
      });
      expose({
        triggerRef
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElPopperTrigger), {
          id: vue.unref(id),
          "virtual-ref": _ctx.virtualRef,
          open: vue.unref(open),
          "virtual-triggering": _ctx.virtualTriggering,
          class: vue.normalizeClass(vue.unref(ns).e("trigger")),
          onBlur: vue.unref(onBlur),
          onClick: vue.unref(onClick),
          onContextmenu: vue.unref(onContextMenu),
          onFocus: vue.unref(onFocus),
          onMouseenter: vue.unref(onMouseenter),
          onMouseleave: vue.unref(onMouseleave),
          onKeydown: vue.unref(onKeydown)
        }, {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]);
      };
    }
  });
  var ElTooltipTrigger = /* @__PURE__ */ _export_sfc(_sfc_main$2g, [["__file", "trigger.vue"]]);

  const __default__$1M = vue.defineComponent({
    name: "ElTooltipContent",
    inheritAttrs: false
  });
  const _sfc_main$2f = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1M,
    props: useTooltipContentProps,
    setup(__props, { expose }) {
      const props = __props;
      const { selector } = usePopperContainerId();
      const ns = useNamespace("tooltip");
      const contentRef = vue.ref();
      const popperContentRef = computedEager(() => {
        var _a;
        return (_a = contentRef.value) == null ? void 0 : _a.popperContentRef;
      });
      let stopHandle;
      const {
        controlled,
        id,
        open,
        trigger,
        onClose,
        onOpen,
        onShow,
        onHide,
        onBeforeShow,
        onBeforeHide
      } = vue.inject(TOOLTIP_INJECTION_KEY, void 0);
      const transitionClass = vue.computed(() => {
        return props.transition || `${ns.namespace.value}-fade-in-linear`;
      });
      const persistentRef = vue.computed(() => {
        return props.persistent;
      });
      vue.onBeforeUnmount(() => {
        stopHandle == null ? void 0 : stopHandle();
      });
      const shouldRender = vue.computed(() => {
        return vue.unref(persistentRef) ? true : vue.unref(open);
      });
      const shouldShow = vue.computed(() => {
        return props.disabled ? false : vue.unref(open);
      });
      const appendTo = vue.computed(() => {
        return props.appendTo || selector.value;
      });
      const contentStyle = vue.computed(() => {
        var _a;
        return (_a = props.style) != null ? _a : {};
      });
      const ariaHidden = vue.ref(true);
      const onTransitionLeave = () => {
        onHide();
        isFocusInsideContent() && focusElement(document.body, { preventScroll: true });
        ariaHidden.value = true;
      };
      const stopWhenControlled = () => {
        if (vue.unref(controlled))
          return true;
      };
      const onContentEnter = composeEventHandlers(stopWhenControlled, () => {
        if (props.enterable && isTriggerType(vue.unref(trigger), "hover")) {
          onOpen();
        }
      });
      const onContentLeave = composeEventHandlers(stopWhenControlled, () => {
        if (isTriggerType(vue.unref(trigger), "hover")) {
          onClose();
        }
      });
      const onBeforeEnter = () => {
        var _a, _b;
        (_b = (_a = contentRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
        onBeforeShow == null ? void 0 : onBeforeShow();
      };
      const onBeforeLeave = () => {
        onBeforeHide == null ? void 0 : onBeforeHide();
      };
      const onAfterShow = () => {
        onShow();
      };
      const onBlur = () => {
        if (!props.virtualTriggering) {
          onClose();
        }
      };
      const isFocusInsideContent = (event) => {
        var _a;
        const popperContent = (_a = contentRef.value) == null ? void 0 : _a.popperContentRef;
        const activeElement = (event == null ? void 0 : event.relatedTarget) || document.activeElement;
        return popperContent == null ? void 0 : popperContent.contains(activeElement);
      };
      vue.watch(() => vue.unref(open), (val) => {
        if (!val) {
          stopHandle == null ? void 0 : stopHandle();
        } else {
          ariaHidden.value = false;
          stopHandle = onClickOutside(popperContentRef, () => {
            if (vue.unref(controlled))
              return;
            const needClose = castArray(vue.unref(trigger)).every((item) => {
              return item !== "hover" && item !== "focus";
            });
            if (needClose) {
              onClose();
            }
          }, { detectIframe: true });
        }
      }, {
        flush: "post"
      });
      vue.watch(() => props.content, () => {
        var _a, _b;
        (_b = (_a = contentRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
      });
      expose({
        contentRef,
        isFocusInsideContent
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTeleport$1), {
          disabled: !_ctx.teleported,
          to: vue.unref(appendTo)
        }, {
          default: vue.withCtx(() => [
            vue.unref(shouldRender) || !ariaHidden.value ? (vue.openBlock(), vue.createBlock(vue.Transition, {
              key: 0,
              name: vue.unref(transitionClass),
              appear: !vue.unref(persistentRef),
              onAfterLeave: onTransitionLeave,
              onBeforeEnter,
              onAfterEnter: onAfterShow,
              onBeforeLeave,
              persisted: ""
            }, {
              default: vue.withCtx(() => [
                vue.withDirectives(vue.createVNode(vue.unref(ElPopperContent), vue.mergeProps({
                  id: vue.unref(id),
                  ref_key: "contentRef",
                  ref: contentRef
                }, _ctx.$attrs, {
                  "aria-label": _ctx.ariaLabel,
                  "aria-hidden": ariaHidden.value,
                  "boundaries-padding": _ctx.boundariesPadding,
                  "fallback-placements": _ctx.fallbackPlacements,
                  "gpu-acceleration": _ctx.gpuAcceleration,
                  offset: _ctx.offset,
                  placement: _ctx.placement,
                  "popper-options": _ctx.popperOptions,
                  "arrow-offset": _ctx.arrowOffset,
                  strategy: _ctx.strategy,
                  effect: _ctx.effect,
                  enterable: _ctx.enterable,
                  pure: _ctx.pure,
                  "popper-class": _ctx.popperClass,
                  "popper-style": [_ctx.popperStyle, vue.unref(contentStyle)],
                  "reference-el": _ctx.referenceEl,
                  "trigger-target-el": _ctx.triggerTargetEl,
                  visible: vue.unref(shouldShow),
                  "z-index": _ctx.zIndex,
                  loop: _ctx.loop,
                  onMouseenter: vue.unref(onContentEnter),
                  onMouseleave: vue.unref(onContentLeave),
                  onBlur,
                  onClose: vue.unref(onClose)
                }), {
                  default: vue.withCtx(() => [
                    vue.renderSlot(_ctx.$slots, "default")
                  ]),
                  _: 3
                }, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "arrow-offset", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "loop", "onMouseenter", "onMouseleave", "onClose"]), [
                  [vue.vShow, vue.unref(shouldShow)]
                ])
              ]),
              _: 3
            }, 8, ["name", "appear"])) : vue.createCommentVNode("v-if", true)
          ]),
          _: 3
        }, 8, ["disabled", "to"]);
      };
    }
  });
  var ElTooltipContent = /* @__PURE__ */ _export_sfc(_sfc_main$2f, [["__file", "content.vue"]]);

  const __default__$1L = vue.defineComponent({
    name: "ElTooltip"
  });
  const _sfc_main$2e = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1L,
    props: useTooltipProps,
    emits: tooltipEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      usePopperContainer();
      const ns = useNamespace("tooltip");
      const id = useId();
      const popperRef = vue.ref();
      const contentRef = vue.ref();
      const updatePopper = () => {
        var _a;
        const popperComponent = vue.unref(popperRef);
        if (popperComponent) {
          (_a = popperComponent.popperInstanceRef) == null ? void 0 : _a.update();
        }
      };
      const open = vue.ref(false);
      const toggleReason = vue.ref();
      const { show, hide, hasUpdateHandler } = useTooltipModelToggle({
        indicator: open,
        toggleReason
      });
      const { onOpen, onClose } = useDelayedToggle({
        showAfter: vue.toRef(props, "showAfter"),
        hideAfter: vue.toRef(props, "hideAfter"),
        autoClose: vue.toRef(props, "autoClose"),
        open: show,
        close: hide
      });
      const controlled = vue.computed(() => isBoolean(props.visible) && !hasUpdateHandler.value);
      const kls = vue.computed(() => {
        return [ns.b(), props.popperClass];
      });
      vue.provide(TOOLTIP_INJECTION_KEY, {
        controlled,
        id,
        open: vue.readonly(open),
        trigger: vue.toRef(props, "trigger"),
        onOpen,
        onClose,
        onToggle: (event) => {
          if (vue.unref(open)) {
            onClose(event);
          } else {
            onOpen(event);
          }
        },
        onShow: () => {
          emit("show", toggleReason.value);
        },
        onHide: () => {
          emit("hide", toggleReason.value);
        },
        onBeforeShow: () => {
          emit("before-show", toggleReason.value);
        },
        onBeforeHide: () => {
          emit("before-hide", toggleReason.value);
        },
        updatePopper
      });
      vue.watch(() => props.disabled, (disabled) => {
        if (disabled && open.value) {
          open.value = false;
        }
      });
      const isFocusInsideContent = (event) => {
        var _a;
        return (_a = contentRef.value) == null ? void 0 : _a.isFocusInsideContent(event);
      };
      vue.onDeactivated(() => open.value && hide());
      expose({
        popperRef,
        contentRef,
        isFocusInsideContent,
        updatePopper,
        onOpen,
        onClose,
        hide
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElPopper), {
          ref_key: "popperRef",
          ref: popperRef,
          role: _ctx.role
        }, {
          default: vue.withCtx(() => [
            vue.createVNode(ElTooltipTrigger, {
              disabled: _ctx.disabled,
              trigger: _ctx.trigger,
              "trigger-keys": _ctx.triggerKeys,
              "virtual-ref": _ctx.virtualRef,
              "virtual-triggering": _ctx.virtualTriggering,
              "focus-on-target": _ctx.focusOnTarget
            }, {
              default: vue.withCtx(() => [
                _ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering", "focus-on-target"]),
            vue.createVNode(ElTooltipContent, {
              ref_key: "contentRef",
              ref: contentRef,
              "aria-label": _ctx.ariaLabel,
              "boundaries-padding": _ctx.boundariesPadding,
              content: _ctx.content,
              disabled: _ctx.disabled,
              effect: _ctx.effect,
              enterable: _ctx.enterable,
              "fallback-placements": _ctx.fallbackPlacements,
              "hide-after": _ctx.hideAfter,
              "gpu-acceleration": _ctx.gpuAcceleration,
              offset: _ctx.offset,
              persistent: _ctx.persistent,
              "popper-class": vue.unref(kls),
              "popper-style": _ctx.popperStyle,
              placement: _ctx.placement,
              "popper-options": _ctx.popperOptions,
              "arrow-offset": _ctx.arrowOffset,
              pure: _ctx.pure,
              "raw-content": _ctx.rawContent,
              "reference-el": _ctx.referenceEl,
              "trigger-target-el": _ctx.triggerTargetEl,
              "show-after": _ctx.showAfter,
              strategy: _ctx.strategy,
              teleported: _ctx.teleported,
              transition: _ctx.transition,
              "virtual-triggering": _ctx.virtualTriggering,
              "z-index": _ctx.zIndex,
              "append-to": _ctx.appendTo,
              loop: _ctx.loop
            }, {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "content", {}, () => [
                  _ctx.rawContent ? (vue.openBlock(), vue.createElementBlock("span", {
                    key: 0,
                    innerHTML: _ctx.content
                  }, null, 8, ["innerHTML"])) : (vue.openBlock(), vue.createElementBlock("span", { key: 1 }, vue.toDisplayString(_ctx.content), 1))
                ]),
                _ctx.showArrow ? (vue.openBlock(), vue.createBlock(vue.unref(ElPopperArrow), { key: 0 })) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "arrow-offset", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to", "loop"])
          ]),
          _: 3
        }, 8, ["role"]);
      };
    }
  });
  var Tooltip = /* @__PURE__ */ _export_sfc(_sfc_main$2e, [["__file", "tooltip.vue"]]);

  const ElTooltip = withInstall(Tooltip);

  const autocompleteProps = buildProps({
    ...inputProps,
    valueKey: {
      type: String,
      default: "value"
    },
    modelValue: {
      type: [String, Number],
      default: ""
    },
    debounce: {
      type: Number,
      default: 300
    },
    placement: {
      type: definePropType(String),
      values: [
        "top",
        "top-start",
        "top-end",
        "bottom",
        "bottom-start",
        "bottom-end"
      ],
      default: "bottom-start"
    },
    fetchSuggestions: {
      type: definePropType([Function, Array]),
      default: NOOP
    },
    popperClass: useTooltipContentProps.popperClass,
    popperStyle: useTooltipContentProps.popperStyle,
    triggerOnFocus: {
      type: Boolean,
      default: true
    },
    selectWhenUnmatched: Boolean,
    hideLoading: Boolean,
    teleported: useTooltipContentProps.teleported,
    appendTo: useTooltipContentProps.appendTo,
    highlightFirstItem: Boolean,
    fitInputWidth: Boolean,
    loopNavigation: {
      type: Boolean,
      default: true
    }
  });
  const autocompleteEmits = {
    [UPDATE_MODEL_EVENT]: (value) => isString$1(value) || isNumber(value),
    [INPUT_EVENT]: (value) => isString$1(value) || isNumber(value),
    [CHANGE_EVENT]: (value) => isString$1(value) || isNumber(value),
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent,
    clear: () => true,
    select: (item) => isObject$1(item)
  };

  const COMPONENT_NAME$j = "ElAutocomplete";
  const __default__$1K = vue.defineComponent({
    name: COMPONENT_NAME$j,
    inheritAttrs: false
  });
  const _sfc_main$2d = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1K,
    props: autocompleteProps,
    emits: autocompleteEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const passInputProps = vue.computed(() => pick(props, Object.keys(inputProps)));
      const rawAttrs = vue.useAttrs();
      const disabled = useFormDisabled();
      const ns = useNamespace("autocomplete");
      const inputRef = vue.ref();
      const regionRef = vue.ref();
      const popperRef = vue.ref();
      const listboxRef = vue.ref();
      let readonly = false;
      let ignoreFocusEvent = false;
      const suggestions = vue.ref([]);
      const highlightedIndex = vue.ref(-1);
      const dropdownWidth = vue.ref("");
      const activated = vue.ref(false);
      const suggestionDisabled = vue.ref(false);
      const loading = vue.ref(false);
      const listboxId = useId();
      const styles = vue.computed(() => rawAttrs.style);
      const suggestionVisible = vue.computed(() => {
        const isValidData = suggestions.value.length > 0;
        return (isValidData || loading.value) && activated.value;
      });
      const suggestionLoading = vue.computed(() => !props.hideLoading && loading.value);
      const refInput = vue.computed(() => {
        if (inputRef.value) {
          return Array.from(inputRef.value.$el.querySelectorAll("input"));
        }
        return [];
      });
      const onSuggestionShow = () => {
        if (suggestionVisible.value) {
          dropdownWidth.value = `${inputRef.value.$el.offsetWidth}px`;
        }
      };
      const onHide = () => {
        highlightedIndex.value = -1;
      };
      const getData = async (queryString) => {
        if (suggestionDisabled.value)
          return;
        const cb = (suggestionList) => {
          loading.value = false;
          if (suggestionDisabled.value)
            return;
          if (isArray$1(suggestionList)) {
            suggestions.value = suggestionList;
            highlightedIndex.value = props.highlightFirstItem ? 0 : -1;
          } else {
            throwError(COMPONENT_NAME$j, "autocomplete suggestions must be an array");
          }
        };
        loading.value = true;
        if (isArray$1(props.fetchSuggestions)) {
          cb(props.fetchSuggestions);
        } else {
          const result = await props.fetchSuggestions(queryString, cb);
          if (isArray$1(result))
            cb(result);
        }
      };
      const debounce = vue.computed(() => props.debounce);
      const debouncedGetData = useDebounceFn(getData, debounce);
      const handleInput = (value) => {
        const valuePresented = !!value;
        emit(INPUT_EVENT, value);
        emit(UPDATE_MODEL_EVENT, value);
        suggestionDisabled.value = false;
        activated.value || (activated.value = valuePresented);
        if (!props.triggerOnFocus && !value) {
          suggestionDisabled.value = true;
          suggestions.value = [];
          return;
        }
        debouncedGetData(value);
      };
      const handleMouseDown = (event) => {
        var _a;
        if (disabled.value)
          return;
        if (((_a = event.target) == null ? void 0 : _a.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
          activated.value = true;
        }
      };
      const handleChange = (value) => {
        emit(CHANGE_EVENT, value);
      };
      const handleFocus = (evt) => {
        var _a;
        if (!ignoreFocusEvent) {
          activated.value = true;
          emit("focus", evt);
          const queryString = (_a = props.modelValue) != null ? _a : "";
          if (props.triggerOnFocus && !readonly) {
            debouncedGetData(String(queryString));
          }
        } else {
          ignoreFocusEvent = false;
        }
      };
      const handleBlur = (evt) => {
        setTimeout(() => {
          var _a;
          if ((_a = popperRef.value) == null ? void 0 : _a.isFocusInsideContent()) {
            ignoreFocusEvent = true;
            return;
          }
          activated.value && close();
          emit("blur", evt);
        });
      };
      const handleClear = () => {
        activated.value = false;
        emit(UPDATE_MODEL_EVENT, "");
        emit("clear");
      };
      const handleKeyEnter = async () => {
        var _a;
        if ((_a = inputRef.value) == null ? void 0 : _a.isComposing) {
          return;
        }
        if (suggestionVisible.value && highlightedIndex.value >= 0 && highlightedIndex.value < suggestions.value.length) {
          handleSelect(suggestions.value[highlightedIndex.value]);
        } else {
          if (props.selectWhenUnmatched) {
            emit("select", { value: props.modelValue });
            suggestions.value = [];
            highlightedIndex.value = -1;
          }
          activated.value = true;
          debouncedGetData(String(props.modelValue));
        }
      };
      const handleKeyEscape = (evt) => {
        if (suggestionVisible.value) {
          evt.preventDefault();
          evt.stopPropagation();
          close();
        }
      };
      const close = () => {
        activated.value = false;
      };
      const focus = () => {
        var _a;
        (_a = inputRef.value) == null ? void 0 : _a.focus();
      };
      const blur = () => {
        var _a;
        (_a = inputRef.value) == null ? void 0 : _a.blur();
      };
      const handleSelect = async (item) => {
        emit(INPUT_EVENT, item[props.valueKey]);
        emit(UPDATE_MODEL_EVENT, item[props.valueKey]);
        emit("select", item);
        suggestions.value = [];
        highlightedIndex.value = -1;
      };
      const highlight = (index) => {
        var _a, _b;
        if (!suggestionVisible.value || loading.value)
          return;
        if (index < 0) {
          if (!props.loopNavigation) {
            highlightedIndex.value = -1;
            return;
          }
          index = suggestions.value.length - 1;
        }
        if (index >= suggestions.value.length) {
          index = props.loopNavigation ? 0 : suggestions.value.length - 1;
        }
        const [suggestion, suggestionList] = getSuggestionContext();
        const highlightItem = suggestionList[index];
        const scrollTop = suggestion.scrollTop;
        const { offsetTop, scrollHeight } = highlightItem;
        if (offsetTop + scrollHeight > scrollTop + suggestion.clientHeight) {
          suggestion.scrollTop = offsetTop + scrollHeight - suggestion.clientHeight;
        }
        if (offsetTop < scrollTop) {
          suggestion.scrollTop = offsetTop;
        }
        highlightedIndex.value = index;
        (_b = (_a = inputRef.value) == null ? void 0 : _a.ref) == null ? void 0 : _b.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
      };
      const getSuggestionContext = () => {
        const suggestion = regionRef.value.querySelector(`.${ns.be("suggestion", "wrap")}`);
        const suggestionList = suggestion.querySelectorAll(`.${ns.be("suggestion", "list")} li`);
        return [suggestion, suggestionList];
      };
      const stopHandle = onClickOutside(listboxRef, () => {
        var _a;
        if ((_a = popperRef.value) == null ? void 0 : _a.isFocusInsideContent())
          return;
        suggestionVisible.value && close();
      });
      const handleKeydown = (e) => {
        const code = getEventCode(e);
        switch (code) {
          case EVENT_CODE.up:
            e.preventDefault();
            highlight(highlightedIndex.value - 1);
            break;
          case EVENT_CODE.down:
            e.preventDefault();
            highlight(highlightedIndex.value + 1);
            break;
          case EVENT_CODE.enter:
            e.preventDefault();
            handleKeyEnter();
            break;
          case EVENT_CODE.tab:
            close();
            break;
          case EVENT_CODE.esc:
            handleKeyEscape(e);
            break;
          case EVENT_CODE.home:
            e.preventDefault();
            highlight(0);
            break;
          case EVENT_CODE.end:
            e.preventDefault();
            highlight(suggestions.value.length - 1);
            break;
          case EVENT_CODE.pageUp:
            e.preventDefault();
            highlight(Math.max(0, highlightedIndex.value - 10));
            break;
          case EVENT_CODE.pageDown:
            e.preventDefault();
            highlight(Math.min(suggestions.value.length - 1, highlightedIndex.value + 10));
            break;
        }
      };
      vue.onBeforeUnmount(() => {
        stopHandle == null ? void 0 : stopHandle();
      });
      vue.onMounted(() => {
        var _a;
        const inputElement = (_a = inputRef.value) == null ? void 0 : _a.ref;
        if (!inputElement)
          return;
        [
          { key: "role", value: "textbox" },
          { key: "aria-autocomplete", value: "list" },
          { key: "aria-controls", value: "id" },
          {
            key: "aria-activedescendant",
            value: `${listboxId.value}-item-${highlightedIndex.value}`
          }
        ].forEach(({ key, value }) => inputElement.setAttribute(key, value));
        readonly = inputElement.hasAttribute("readonly");
      });
      expose({
        highlightedIndex,
        activated,
        loading,
        inputRef,
        popperRef,
        suggestions,
        handleSelect,
        handleKeyEnter,
        focus,
        blur,
        close,
        highlight,
        getData
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
          ref_key: "popperRef",
          ref: popperRef,
          visible: vue.unref(suggestionVisible),
          placement: _ctx.placement,
          "fallback-placements": ["bottom-start", "top-start"],
          "popper-class": [vue.unref(ns).e("popper"), _ctx.popperClass],
          "popper-style": _ctx.popperStyle,
          teleported: _ctx.teleported,
          "append-to": _ctx.appendTo,
          "gpu-acceleration": false,
          pure: "",
          "manual-mode": "",
          effect: "light",
          trigger: "click",
          transition: `${vue.unref(ns).namespace.value}-zoom-in-top`,
          persistent: "",
          role: "listbox",
          onBeforeShow: onSuggestionShow,
          onHide
        }, {
          content: vue.withCtx(() => [
            vue.createElementVNode("div", {
              ref_key: "regionRef",
              ref: regionRef,
              class: vue.normalizeClass([vue.unref(ns).b("suggestion"), vue.unref(ns).is("loading", vue.unref(suggestionLoading))]),
              style: vue.normalizeStyle({
                [_ctx.fitInputWidth ? "width" : "minWidth"]: dropdownWidth.value,
                outline: "none"
              }),
              role: "region"
            }, [
              _ctx.$slots.header ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).be("suggestion", "header")),
                onClick: vue.withModifiers(() => {
                }, ["stop"])
              }, [
                vue.renderSlot(_ctx.$slots, "header")
              ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true),
              vue.createVNode(vue.unref(ElScrollbar), {
                id: vue.unref(listboxId),
                tag: "ul",
                "wrap-class": vue.unref(ns).be("suggestion", "wrap"),
                "view-class": vue.unref(ns).be("suggestion", "list"),
                role: "listbox"
              }, {
                default: vue.withCtx(() => [
                  vue.unref(suggestionLoading) ? (vue.openBlock(), vue.createElementBlock("li", { key: 0 }, [
                    vue.renderSlot(_ctx.$slots, "loading", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), {
                        class: vue.normalizeClass(vue.unref(ns).is("loading"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(loading_default))
                        ]),
                        _: 1
                      }, 8, ["class"])
                    ])
                  ])) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(suggestions.value, (item, index) => {
                    return vue.openBlock(), vue.createElementBlock("li", {
                      id: `${vue.unref(listboxId)}-item-${index}`,
                      key: index,
                      class: vue.normalizeClass({ highlighted: highlightedIndex.value === index }),
                      role: "option",
                      "aria-selected": highlightedIndex.value === index,
                      onClick: ($event) => handleSelect(item)
                    }, [
                      vue.renderSlot(_ctx.$slots, "default", { item }, () => [
                        vue.createTextVNode(vue.toDisplayString(item[_ctx.valueKey]), 1)
                      ])
                    ], 10, ["id", "aria-selected", "onClick"]);
                  }), 128))
                ]),
                _: 3
              }, 8, ["id", "wrap-class", "view-class"]),
              _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                class: vue.normalizeClass(vue.unref(ns).be("suggestion", "footer")),
                onClick: vue.withModifiers(() => {
                }, ["stop"])
              }, [
                vue.renderSlot(_ctx.$slots, "footer")
              ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true)
            ], 6)
          ]),
          default: vue.withCtx(() => [
            vue.createElementVNode("div", {
              ref_key: "listboxRef",
              ref: listboxRef,
              class: vue.normalizeClass([vue.unref(ns).b(), _ctx.$attrs.class]),
              style: vue.normalizeStyle(vue.unref(styles)),
              role: "combobox",
              "aria-haspopup": "listbox",
              "aria-expanded": vue.unref(suggestionVisible),
              "aria-owns": vue.unref(listboxId)
            }, [
              vue.createVNode(vue.unref(ElInput), vue.mergeProps({
                ref_key: "inputRef",
                ref: inputRef
              }, vue.mergeProps(vue.unref(passInputProps), _ctx.$attrs), {
                "model-value": _ctx.modelValue,
                disabled: vue.unref(disabled),
                onInput: handleInput,
                onChange: handleChange,
                onFocus: handleFocus,
                onBlur: handleBlur,
                onClear: handleClear,
                onKeydown: handleKeydown,
                onMousedown: handleMouseDown
              }), vue.createSlots({
                _: 2
              }, [
                _ctx.$slots.prepend ? {
                  name: "prepend",
                  fn: vue.withCtx(() => [
                    vue.renderSlot(_ctx.$slots, "prepend")
                  ])
                } : void 0,
                _ctx.$slots.append ? {
                  name: "append",
                  fn: vue.withCtx(() => [
                    vue.renderSlot(_ctx.$slots, "append")
                  ])
                } : void 0,
                _ctx.$slots.prefix ? {
                  name: "prefix",
                  fn: vue.withCtx(() => [
                    vue.renderSlot(_ctx.$slots, "prefix")
                  ])
                } : void 0,
                _ctx.$slots.suffix ? {
                  name: "suffix",
                  fn: vue.withCtx(() => [
                    vue.renderSlot(_ctx.$slots, "suffix")
                  ])
                } : void 0
              ]), 1040, ["model-value", "disabled"])
            ], 14, ["aria-expanded", "aria-owns"])
          ]),
          _: 3
        }, 8, ["visible", "placement", "popper-class", "popper-style", "teleported", "append-to", "transition"]);
      };
    }
  });
  var Autocomplete = /* @__PURE__ */ _export_sfc(_sfc_main$2d, [["__file", "autocomplete.vue"]]);

  const ElAutocomplete = withInstall(Autocomplete);

  const avatarProps = buildProps({
    size: {
      type: [Number, String],
      values: componentSizes,
      default: "",
      validator: (val) => isNumber(val)
    },
    shape: {
      type: String,
      values: ["circle", "square"],
      default: "circle"
    },
    icon: {
      type: iconPropType
    },
    src: {
      type: String,
      default: ""
    },
    alt: String,
    srcSet: String,
    fit: {
      type: definePropType(String),
      default: "cover"
    }
  });
  const avatarEmits = {
    error: (evt) => evt instanceof Event
  };

  const __default__$1J = vue.defineComponent({
    name: "ElAvatar"
  });
  const _sfc_main$2c = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1J,
    props: avatarProps,
    emits: avatarEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("avatar");
      const hasLoadError = vue.ref(false);
      const avatarClass = vue.computed(() => {
        const { size, icon, shape } = props;
        const classList = [ns.b()];
        if (isString$1(size))
          classList.push(ns.m(size));
        if (icon)
          classList.push(ns.m("icon"));
        if (shape)
          classList.push(ns.m(shape));
        return classList;
      });
      const sizeStyle = vue.computed(() => {
        const { size } = props;
        return isNumber(size) ? ns.cssVarBlock({
          size: addUnit(size) || ""
        }) : void 0;
      });
      const fitStyle = vue.computed(() => ({
        objectFit: props.fit
      }));
      vue.watch(() => props.src, () => hasLoadError.value = false);
      function handleError(e) {
        hasLoadError.value = true;
        emit("error", e);
      }
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("span", {
          class: vue.normalizeClass(vue.unref(avatarClass)),
          style: vue.normalizeStyle(vue.unref(sizeStyle))
        }, [
          (_ctx.src || _ctx.srcSet) && !hasLoadError.value ? (vue.openBlock(), vue.createElementBlock("img", {
            key: 0,
            src: _ctx.src,
            alt: _ctx.alt,
            srcset: _ctx.srcSet,
            style: vue.normalizeStyle(vue.unref(fitStyle)),
            onError: handleError
          }, null, 44, ["src", "alt", "srcset"])) : _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
            default: vue.withCtx(() => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
            ]),
            _: 1
          })) : vue.renderSlot(_ctx.$slots, "default", { key: 2 })
        ], 6);
      };
    }
  });
  var Avatar = /* @__PURE__ */ _export_sfc(_sfc_main$2c, [["__file", "avatar.vue"]]);

  const ElAvatar = withInstall(Avatar);

  const backtopProps = {
    visibilityHeight: {
      type: Number,
      default: 200
    },
    target: {
      type: String,
      default: ""
    },
    right: {
      type: Number,
      default: 40
    },
    bottom: {
      type: Number,
      default: 40
    }
  };
  const backtopEmits = {
    click: (evt) => evt instanceof MouseEvent
  };

  const useBackTop = (props, emit, componentName) => {
    const el = vue.shallowRef();
    const container = vue.shallowRef();
    const visible = vue.ref(false);
    const handleScroll = () => {
      if (el.value)
        visible.value = el.value.scrollTop >= props.visibilityHeight;
    };
    const handleClick = (event) => {
      var _a;
      (_a = el.value) == null ? void 0 : _a.scrollTo({ top: 0, behavior: "smooth" });
      emit("click", event);
    };
    const handleScrollThrottled = useThrottleFn(handleScroll, 300, true);
    useEventListener(container, "scroll", handleScrollThrottled);
    vue.onMounted(() => {
      var _a;
      container.value = document;
      el.value = document.documentElement;
      if (props.target) {
        el.value = (_a = document.querySelector(props.target)) != null ? _a : void 0;
        if (!el.value) {
          throwError(componentName, `target does not exist: ${props.target}`);
        }
        container.value = el.value;
      }
      handleScroll();
    });
    return {
      visible,
      handleClick
    };
  };

  const COMPONENT_NAME$i = "ElBacktop";
  const __default__$1I = vue.defineComponent({
    name: COMPONENT_NAME$i
  });
  const _sfc_main$2b = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1I,
    props: backtopProps,
    emits: backtopEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("backtop");
      const { handleClick, visible } = useBackTop(props, emit, COMPONENT_NAME$i);
      const backTopStyle = vue.computed(() => ({
        right: `${props.right}px`,
        bottom: `${props.bottom}px`
      }));
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, {
          name: `${vue.unref(ns).namespace.value}-fade-in`
        }, {
          default: vue.withCtx(() => [
            vue.unref(visible) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              style: vue.normalizeStyle(vue.unref(backTopStyle)),
              class: vue.normalizeClass(vue.unref(ns).b()),
              onClick: vue.withModifiers(vue.unref(handleClick), ["stop"])
            }, [
              vue.renderSlot(_ctx.$slots, "default", {}, () => [
                vue.createVNode(vue.unref(ElIcon), {
                  class: vue.normalizeClass(vue.unref(ns).e("icon"))
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(caret_top_default))
                  ]),
                  _: 1
                }, 8, ["class"])
              ])
            ], 14, ["onClick"])) : vue.createCommentVNode("v-if", true)
          ]),
          _: 3
        }, 8, ["name"]);
      };
    }
  });
  var Backtop = /* @__PURE__ */ _export_sfc(_sfc_main$2b, [["__file", "backtop.vue"]]);

  const ElBacktop = withInstall(Backtop);

  const badgeProps = buildProps({
    value: {
      type: [String, Number],
      default: ""
    },
    max: {
      type: Number,
      default: 99
    },
    isDot: Boolean,
    hidden: Boolean,
    type: {
      type: String,
      values: ["primary", "success", "warning", "info", "danger"],
      default: "danger"
    },
    showZero: {
      type: Boolean,
      default: true
    },
    color: String,
    badgeStyle: {
      type: definePropType([String, Object, Array])
    },
    offset: {
      type: definePropType(Array),
      default: [0, 0]
    },
    badgeClass: {
      type: String
    }
  });

  const __default__$1H = vue.defineComponent({
    name: "ElBadge"
  });
  const _sfc_main$2a = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1H,
    props: badgeProps,
    setup(__props, { expose }) {
      const props = __props;
      const ns = useNamespace("badge");
      const content = vue.computed(() => {
        if (props.isDot)
          return "";
        if (isNumber(props.value) && isNumber(props.max)) {
          return props.max < props.value ? `${props.max}+` : `${props.value}`;
        }
        return `${props.value}`;
      });
      const style = vue.computed(() => {
        var _a, _b, _c, _d, _e;
        return [
          {
            backgroundColor: props.color,
            marginRight: addUnit(-((_b = (_a = props.offset) == null ? void 0 : _a[0]) != null ? _b : 0)),
            marginTop: addUnit((_d = (_c = props.offset) == null ? void 0 : _c[1]) != null ? _d : 0)
          },
          (_e = props.badgeStyle) != null ? _e : {}
        ];
      });
      expose({
        content
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.renderSlot(_ctx.$slots, "default"),
          vue.createVNode(vue.Transition, {
            name: `${vue.unref(ns).namespace.value}-zoom-in-center`,
            persisted: ""
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("sup", {
                class: vue.normalizeClass([
                  vue.unref(ns).e("content"),
                  vue.unref(ns).em("content", _ctx.type),
                  vue.unref(ns).is("fixed", !!_ctx.$slots.default),
                  vue.unref(ns).is("dot", _ctx.isDot),
                  vue.unref(ns).is("hide-zero", !_ctx.showZero && _ctx.value === 0),
                  _ctx.badgeClass
                ]),
                style: vue.normalizeStyle(vue.unref(style))
              }, [
                vue.renderSlot(_ctx.$slots, "content", { value: vue.unref(content) }, () => [
                  vue.createTextVNode(vue.toDisplayString(vue.unref(content)), 1)
                ])
              ], 6), [
                [vue.vShow, !_ctx.hidden && (vue.unref(content) || _ctx.isDot || _ctx.$slots.content)]
              ])
            ]),
            _: 3
          }, 8, ["name"])
        ], 2);
      };
    }
  });
  var Badge = /* @__PURE__ */ _export_sfc(_sfc_main$2a, [["__file", "badge.vue"]]);

  const ElBadge = withInstall(Badge);

  const breadcrumbKey = Symbol("breadcrumbKey");

  const breadcrumbProps = buildProps({
    separator: {
      type: String,
      default: "/"
    },
    separatorIcon: {
      type: iconPropType
    }
  });

  const __default__$1G = vue.defineComponent({
    name: "ElBreadcrumb"
  });
  const _sfc_main$29 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1G,
    props: breadcrumbProps,
    setup(__props) {
      const props = __props;
      const { t } = useLocale();
      const ns = useNamespace("breadcrumb");
      const breadcrumb = vue.ref();
      vue.provide(breadcrumbKey, props);
      vue.onMounted(() => {
        const items = breadcrumb.value.querySelectorAll(`.${ns.e("item")}`);
        if (items.length) {
          items[items.length - 1].setAttribute("aria-current", "page");
        }
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "breadcrumb",
          ref: breadcrumb,
          class: vue.normalizeClass(vue.unref(ns).b()),
          "aria-label": vue.unref(t)("el.breadcrumb.label"),
          role: "navigation"
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 10, ["aria-label"]);
      };
    }
  });
  var Breadcrumb = /* @__PURE__ */ _export_sfc(_sfc_main$29, [["__file", "breadcrumb.vue"]]);

  const breadcrumbItemProps = buildProps({
    to: {
      type: definePropType([String, Object]),
      default: ""
    },
    replace: Boolean
  });

  const __default__$1F = vue.defineComponent({
    name: "ElBreadcrumbItem"
  });
  const _sfc_main$28 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1F,
    props: breadcrumbItemProps,
    setup(__props) {
      const props = __props;
      const instance = vue.getCurrentInstance();
      const breadcrumbContext = vue.inject(breadcrumbKey, void 0);
      const ns = useNamespace("breadcrumb");
      const router = instance.appContext.config.globalProperties.$router;
      const link = vue.ref();
      const onClick = () => {
        if (!props.to || !router)
          return;
        props.replace ? router.replace(props.to) : router.push(props.to);
      };
      return (_ctx, _cache) => {
        var _a, _b;
        return vue.openBlock(), vue.createElementBlock("span", {
          class: vue.normalizeClass(vue.unref(ns).e("item"))
        }, [
          vue.createElementVNode("span", {
            ref_key: "link",
            ref: link,
            class: vue.normalizeClass([vue.unref(ns).e("inner"), vue.unref(ns).is("link", !!_ctx.to)]),
            role: "link",
            onClick
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2),
          ((_a = vue.unref(breadcrumbContext)) == null ? void 0 : _a.separatorIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("separator"))
          }, {
            default: vue.withCtx(() => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(breadcrumbContext).separatorIcon)))
            ]),
            _: 1
          }, 8, ["class"])) : (vue.openBlock(), vue.createElementBlock("span", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("separator")),
            role: "presentation"
          }, vue.toDisplayString((_b = vue.unref(breadcrumbContext)) == null ? void 0 : _b.separator), 3))
        ], 2);
      };
    }
  });
  var BreadcrumbItem = /* @__PURE__ */ _export_sfc(_sfc_main$28, [["__file", "breadcrumb-item.vue"]]);

  const ElBreadcrumb = withInstall(Breadcrumb, {
    BreadcrumbItem
  });
  const ElBreadcrumbItem = withNoopInstall(BreadcrumbItem);

  const buttonGroupContextKey = Symbol("buttonGroupContextKey");

  const useButton = (props, emit) => {
    useDeprecated({
      from: "type.text",
      replacement: "link",
      version: "3.0.0",
      scope: "props",
      ref: "https://element-plus.org/en-US/component/button.html#button-attributes"
    }, vue.computed(() => props.type === "text"));
    const buttonGroupContext = vue.inject(buttonGroupContextKey, void 0);
    const globalConfig = useGlobalConfig("button");
    const { form } = useFormItem();
    const _size = useFormSize(vue.computed(() => buttonGroupContext == null ? void 0 : buttonGroupContext.size));
    const _disabled = useFormDisabled();
    const _ref = vue.ref();
    const slots = vue.useSlots();
    const _type = vue.computed(() => {
      var _a;
      return props.type || (buttonGroupContext == null ? void 0 : buttonGroupContext.type) || ((_a = globalConfig.value) == null ? void 0 : _a.type) || "";
    });
    const autoInsertSpace = vue.computed(() => {
      var _a, _b, _c;
      return (_c = (_b = props.autoInsertSpace) != null ? _b : (_a = globalConfig.value) == null ? void 0 : _a.autoInsertSpace) != null ? _c : false;
    });
    const _plain = vue.computed(() => {
      var _a, _b, _c;
      return (_c = (_b = props.plain) != null ? _b : (_a = globalConfig.value) == null ? void 0 : _a.plain) != null ? _c : false;
    });
    const _round = vue.computed(() => {
      var _a, _b, _c;
      return (_c = (_b = props.round) != null ? _b : (_a = globalConfig.value) == null ? void 0 : _a.round) != null ? _c : false;
    });
    const _text = vue.computed(() => {
      var _a, _b, _c;
      return (_c = (_b = props.text) != null ? _b : (_a = globalConfig.value) == null ? void 0 : _a.text) != null ? _c : false;
    });
    const _props = vue.computed(() => {
      if (props.tag === "button") {
        return {
          ariaDisabled: _disabled.value || props.loading,
          disabled: _disabled.value || props.loading,
          autofocus: props.autofocus,
          type: props.nativeType
        };
      }
      return {};
    });
    const shouldAddSpace = vue.computed(() => {
      var _a;
      const defaultSlot = (_a = slots.default) == null ? void 0 : _a.call(slots);
      if (autoInsertSpace.value && (defaultSlot == null ? void 0 : defaultSlot.length) === 1) {
        const slot = defaultSlot[0];
        if ((slot == null ? void 0 : slot.type) === vue.Text) {
          const text = slot.children;
          return /^\p{Unified_Ideograph}{2}$/u.test(text.trim());
        }
      }
      return false;
    });
    const handleClick = (evt) => {
      if (_disabled.value || props.loading) {
        evt.stopPropagation();
        return;
      }
      if (props.nativeType === "reset") {
        form == null ? void 0 : form.resetFields();
      }
      emit("click", evt);
    };
    return {
      _disabled,
      _size,
      _type,
      _ref,
      _props,
      _plain,
      _round,
      _text,
      shouldAddSpace,
      handleClick
    };
  };

  const buttonTypes = [
    "default",
    "primary",
    "success",
    "warning",
    "info",
    "danger",
    "text",
    ""
  ];
  const buttonNativeTypes = ["button", "submit", "reset"];
  const buttonProps = buildProps({
    size: useSizeProp,
    disabled: Boolean,
    type: {
      type: String,
      values: buttonTypes,
      default: ""
    },
    icon: {
      type: iconPropType
    },
    nativeType: {
      type: String,
      values: buttonNativeTypes,
      default: "button"
    },
    loading: Boolean,
    loadingIcon: {
      type: iconPropType,
      default: () => loading_default
    },
    plain: {
      type: Boolean,
      default: void 0
    },
    text: {
      type: Boolean,
      default: void 0
    },
    link: Boolean,
    bg: Boolean,
    autofocus: Boolean,
    round: {
      type: Boolean,
      default: void 0
    },
    circle: Boolean,
    color: String,
    dark: Boolean,
    autoInsertSpace: {
      type: Boolean,
      default: void 0
    },
    tag: {
      type: definePropType([String, Object]),
      default: "button"
    }
  });
  const buttonEmits = {
    click: (evt) => evt instanceof MouseEvent
  };

  function bound01(n, max) {
    if (isOnePointZero(n)) {
      n = "100%";
    }
    var isPercent = isPercentage(n);
    n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
    if (isPercent) {
      n = parseInt(String(n * max), 10) / 100;
    }
    if (Math.abs(n - max) < 1e-6) {
      return 1;
    }
    if (max === 360) {
      n = (n < 0 ? n % max + max : n % max) / parseFloat(String(max));
    } else {
      n = n % max / parseFloat(String(max));
    }
    return n;
  }
  function clamp01(val) {
    return Math.min(1, Math.max(0, val));
  }
  function isOnePointZero(n) {
    return typeof n === "string" && n.indexOf(".") !== -1 && parseFloat(n) === 1;
  }
  function isPercentage(n) {
    return typeof n === "string" && n.indexOf("%") !== -1;
  }
  function boundAlpha(a) {
    a = parseFloat(a);
    if (isNaN(a) || a < 0 || a > 1) {
      a = 1;
    }
    return a;
  }
  function convertToPercentage(n) {
    if (n <= 1) {
      return "".concat(Number(n) * 100, "%");
    }
    return n;
  }
  function pad2(c) {
    return c.length === 1 ? "0" + c : String(c);
  }

  function rgbToRgb(r, g, b) {
    return {
      r: bound01(r, 255) * 255,
      g: bound01(g, 255) * 255,
      b: bound01(b, 255) * 255
    };
  }
  function rgbToHsl(r, g, b) {
    r = bound01(r, 255);
    g = bound01(g, 255);
    b = bound01(b, 255);
    var max = Math.max(r, g, b);
    var min = Math.min(r, g, b);
    var h = 0;
    var s = 0;
    var l = (max + min) / 2;
    if (max === min) {
      s = 0;
      h = 0;
    } else {
      var d = max - min;
      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
      switch (max) {
        case r:
          h = (g - b) / d + (g < b ? 6 : 0);
          break;
        case g:
          h = (b - r) / d + 2;
          break;
        case b:
          h = (r - g) / d + 4;
          break;
      }
      h /= 6;
    }
    return { h, s, l };
  }
  function hue2rgb(p, q, t) {
    if (t < 0) {
      t += 1;
    }
    if (t > 1) {
      t -= 1;
    }
    if (t < 1 / 6) {
      return p + (q - p) * (6 * t);
    }
    if (t < 1 / 2) {
      return q;
    }
    if (t < 2 / 3) {
      return p + (q - p) * (2 / 3 - t) * 6;
    }
    return p;
  }
  function hslToRgb(h, s, l) {
    var r;
    var g;
    var b;
    h = bound01(h, 360);
    s = bound01(s, 100);
    l = bound01(l, 100);
    if (s === 0) {
      g = l;
      b = l;
      r = 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 { r: r * 255, g: g * 255, b: b * 255 };
  }
  function rgbToHsv(r, g, b) {
    r = bound01(r, 255);
    g = bound01(g, 255);
    b = bound01(b, 255);
    var max = Math.max(r, g, b);
    var min = Math.min(r, g, b);
    var h = 0;
    var v = max;
    var d = max - min;
    var s = max === 0 ? 0 : d / max;
    if (max === min) {
      h = 0;
    } else {
      switch (max) {
        case r:
          h = (g - b) / d + (g < b ? 6 : 0);
          break;
        case g:
          h = (b - r) / d + 2;
          break;
        case b:
          h = (r - g) / d + 4;
          break;
      }
      h /= 6;
    }
    return { h, s, v };
  }
  function hsvToRgb(h, s, v) {
    h = bound01(h, 360) * 6;
    s = bound01(s, 100);
    v = bound01(v, 100);
    var i = Math.floor(h);
    var f = h - i;
    var p = v * (1 - s);
    var q = v * (1 - f * s);
    var t = v * (1 - (1 - f) * s);
    var mod = i % 6;
    var r = [v, q, p, p, t, v][mod];
    var g = [t, v, v, q, p, p][mod];
    var b = [p, p, t, v, v, q][mod];
    return { r: r * 255, g: g * 255, b: b * 255 };
  }
  function rgbToHex(r, g, b, allow3Char) {
    var hex = [
      pad2(Math.round(r).toString(16)),
      pad2(Math.round(g).toString(16)),
      pad2(Math.round(b).toString(16))
    ];
    if (allow3Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1))) {
      return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
    }
    return hex.join("");
  }
  function rgbaToHex(r, g, b, a, allow4Char) {
    var hex = [
      pad2(Math.round(r).toString(16)),
      pad2(Math.round(g).toString(16)),
      pad2(Math.round(b).toString(16)),
      pad2(convertDecimalToHex(a))
    ];
    if (allow4Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1)) && hex[3].startsWith(hex[3].charAt(1))) {
      return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
    }
    return hex.join("");
  }
  function convertDecimalToHex(d) {
    return Math.round(parseFloat(d) * 255).toString(16);
  }
  function convertHexToDecimal(h) {
    return parseIntFromHex(h) / 255;
  }
  function parseIntFromHex(val) {
    return parseInt(val, 16);
  }
  function numberInputToObject(color) {
    return {
      r: color >> 16,
      g: (color & 65280) >> 8,
      b: color & 255
    };
  }

  var names = {
    aliceblue: "#f0f8ff",
    antiquewhite: "#faebd7",
    aqua: "#00ffff",
    aquamarine: "#7fffd4",
    azure: "#f0ffff",
    beige: "#f5f5dc",
    bisque: "#ffe4c4",
    black: "#000000",
    blanchedalmond: "#ffebcd",
    blue: "#0000ff",
    blueviolet: "#8a2be2",
    brown: "#a52a2a",
    burlywood: "#deb887",
    cadetblue: "#5f9ea0",
    chartreuse: "#7fff00",
    chocolate: "#d2691e",
    coral: "#ff7f50",
    cornflowerblue: "#6495ed",
    cornsilk: "#fff8dc",
    crimson: "#dc143c",
    cyan: "#00ffff",
    darkblue: "#00008b",
    darkcyan: "#008b8b",
    darkgoldenrod: "#b8860b",
    darkgray: "#a9a9a9",
    darkgreen: "#006400",
    darkgrey: "#a9a9a9",
    darkkhaki: "#bdb76b",
    darkmagenta: "#8b008b",
    darkolivegreen: "#556b2f",
    darkorange: "#ff8c00",
    darkorchid: "#9932cc",
    darkred: "#8b0000",
    darksalmon: "#e9967a",
    darkseagreen: "#8fbc8f",
    darkslateblue: "#483d8b",
    darkslategray: "#2f4f4f",
    darkslategrey: "#2f4f4f",
    darkturquoise: "#00ced1",
    darkviolet: "#9400d3",
    deeppink: "#ff1493",
    deepskyblue: "#00bfff",
    dimgray: "#696969",
    dimgrey: "#696969",
    dodgerblue: "#1e90ff",
    firebrick: "#b22222",
    floralwhite: "#fffaf0",
    forestgreen: "#228b22",
    fuchsia: "#ff00ff",
    gainsboro: "#dcdcdc",
    ghostwhite: "#f8f8ff",
    goldenrod: "#daa520",
    gold: "#ffd700",
    gray: "#808080",
    green: "#008000",
    greenyellow: "#adff2f",
    grey: "#808080",
    honeydew: "#f0fff0",
    hotpink: "#ff69b4",
    indianred: "#cd5c5c",
    indigo: "#4b0082",
    ivory: "#fffff0",
    khaki: "#f0e68c",
    lavenderblush: "#fff0f5",
    lavender: "#e6e6fa",
    lawngreen: "#7cfc00",
    lemonchiffon: "#fffacd",
    lightblue: "#add8e6",
    lightcoral: "#f08080",
    lightcyan: "#e0ffff",
    lightgoldenrodyellow: "#fafad2",
    lightgray: "#d3d3d3",
    lightgreen: "#90ee90",
    lightgrey: "#d3d3d3",
    lightpink: "#ffb6c1",
    lightsalmon: "#ffa07a",
    lightseagreen: "#20b2aa",
    lightskyblue: "#87cefa",
    lightslategray: "#778899",
    lightslategrey: "#778899",
    lightsteelblue: "#b0c4de",
    lightyellow: "#ffffe0",
    lime: "#00ff00",
    limegreen: "#32cd32",
    linen: "#faf0e6",
    magenta: "#ff00ff",
    maroon: "#800000",
    mediumaquamarine: "#66cdaa",
    mediumblue: "#0000cd",
    mediumorchid: "#ba55d3",
    mediumpurple: "#9370db",
    mediumseagreen: "#3cb371",
    mediumslateblue: "#7b68ee",
    mediumspringgreen: "#00fa9a",
    mediumturquoise: "#48d1cc",
    mediumvioletred: "#c71585",
    midnightblue: "#191970",
    mintcream: "#f5fffa",
    mistyrose: "#ffe4e1",
    moccasin: "#ffe4b5",
    navajowhite: "#ffdead",
    navy: "#000080",
    oldlace: "#fdf5e6",
    olive: "#808000",
    olivedrab: "#6b8e23",
    orange: "#ffa500",
    orangered: "#ff4500",
    orchid: "#da70d6",
    palegoldenrod: "#eee8aa",
    palegreen: "#98fb98",
    paleturquoise: "#afeeee",
    palevioletred: "#db7093",
    papayawhip: "#ffefd5",
    peachpuff: "#ffdab9",
    peru: "#cd853f",
    pink: "#ffc0cb",
    plum: "#dda0dd",
    powderblue: "#b0e0e6",
    purple: "#800080",
    rebeccapurple: "#663399",
    red: "#ff0000",
    rosybrown: "#bc8f8f",
    royalblue: "#4169e1",
    saddlebrown: "#8b4513",
    salmon: "#fa8072",
    sandybrown: "#f4a460",
    seagreen: "#2e8b57",
    seashell: "#fff5ee",
    sienna: "#a0522d",
    silver: "#c0c0c0",
    skyblue: "#87ceeb",
    slateblue: "#6a5acd",
    slategray: "#708090",
    slategrey: "#708090",
    snow: "#fffafa",
    springgreen: "#00ff7f",
    steelblue: "#4682b4",
    tan: "#d2b48c",
    teal: "#008080",
    thistle: "#d8bfd8",
    tomato: "#ff6347",
    turquoise: "#40e0d0",
    violet: "#ee82ee",
    wheat: "#f5deb3",
    white: "#ffffff",
    whitesmoke: "#f5f5f5",
    yellow: "#ffff00",
    yellowgreen: "#9acd32"
  };

  function inputToRGB(color) {
    var rgb = { r: 0, g: 0, b: 0 };
    var a = 1;
    var s = null;
    var v = null;
    var l = null;
    var ok = false;
    var format = false;
    if (typeof color === "string") {
      color = stringInputToObject(color);
    }
    if (typeof color === "object") {
      if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
        rgb = rgbToRgb(color.r, color.g, color.b);
        ok = true;
        format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
        s = convertToPercentage(color.s);
        v = convertToPercentage(color.v);
        rgb = hsvToRgb(color.h, s, v);
        ok = true;
        format = "hsv";
      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
        s = convertToPercentage(color.s);
        l = convertToPercentage(color.l);
        rgb = hslToRgb(color.h, s, l);
        ok = true;
        format = "hsl";
      }
      if (Object.prototype.hasOwnProperty.call(color, "a")) {
        a = color.a;
      }
    }
    a = boundAlpha(a);
    return {
      ok,
      format: color.format || format,
      r: Math.min(255, Math.max(rgb.r, 0)),
      g: Math.min(255, Math.max(rgb.g, 0)),
      b: Math.min(255, Math.max(rgb.b, 0)),
      a
    };
  }
  var CSS_INTEGER = "[-\\+]?\\d+%?";
  var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
  var CSS_UNIT = "(?:".concat(CSS_NUMBER, ")|(?:").concat(CSS_INTEGER, ")");
  var PERMISSIVE_MATCH3 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
  var PERMISSIVE_MATCH4 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
  var matchers = {
    CSS_UNIT: new RegExp(CSS_UNIT),
    rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
    rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
    hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
    hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
    hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
    hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
    hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
    hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
    hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
    hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
  };
  function stringInputToObject(color) {
    color = color.trim().toLowerCase();
    if (color.length === 0) {
      return false;
    }
    var named = false;
    if (names[color]) {
      color = names[color];
      named = true;
    } else if (color === "transparent") {
      return { r: 0, g: 0, b: 0, a: 0, format: "name" };
    }
    var match = matchers.rgb.exec(color);
    if (match) {
      return { r: match[1], g: match[2], b: match[3] };
    }
    match = matchers.rgba.exec(color);
    if (match) {
      return { r: match[1], g: match[2], b: match[3], a: match[4] };
    }
    match = matchers.hsl.exec(color);
    if (match) {
      return { h: match[1], s: match[2], l: match[3] };
    }
    match = matchers.hsla.exec(color);
    if (match) {
      return { h: match[1], s: match[2], l: match[3], a: match[4] };
    }
    match = matchers.hsv.exec(color);
    if (match) {
      return { h: match[1], s: match[2], v: match[3] };
    }
    match = matchers.hsva.exec(color);
    if (match) {
      return { h: match[1], s: match[2], v: match[3], a: match[4] };
    }
    match = matchers.hex8.exec(color);
    if (match) {
      return {
        r: parseIntFromHex(match[1]),
        g: parseIntFromHex(match[2]),
        b: parseIntFromHex(match[3]),
        a: convertHexToDecimal(match[4]),
        format: named ? "name" : "hex8"
      };
    }
    match = matchers.hex6.exec(color);
    if (match) {
      return {
        r: parseIntFromHex(match[1]),
        g: parseIntFromHex(match[2]),
        b: parseIntFromHex(match[3]),
        format: named ? "name" : "hex"
      };
    }
    match = matchers.hex4.exec(color);
    if (match) {
      return {
        r: parseIntFromHex(match[1] + match[1]),
        g: parseIntFromHex(match[2] + match[2]),
        b: parseIntFromHex(match[3] + match[3]),
        a: convertHexToDecimal(match[4] + match[4]),
        format: named ? "name" : "hex8"
      };
    }
    match = matchers.hex3.exec(color);
    if (match) {
      return {
        r: parseIntFromHex(match[1] + match[1]),
        g: parseIntFromHex(match[2] + match[2]),
        b: parseIntFromHex(match[3] + match[3]),
        format: named ? "name" : "hex"
      };
    }
    return false;
  }
  function isValidCSSUnit(color) {
    return Boolean(matchers.CSS_UNIT.exec(String(color)));
  }

  var TinyColor = function() {
    function TinyColor2(color, opts) {
      if (color === void 0) {
        color = "";
      }
      if (opts === void 0) {
        opts = {};
      }
      var _a;
      if (color instanceof TinyColor2) {
        return color;
      }
      if (typeof color === "number") {
        color = numberInputToObject(color);
      }
      this.originalInput = color;
      var rgb = inputToRGB(color);
      this.originalInput = color;
      this.r = rgb.r;
      this.g = rgb.g;
      this.b = rgb.b;
      this.a = rgb.a;
      this.roundA = Math.round(100 * this.a) / 100;
      this.format = (_a = opts.format) !== null && _a !== void 0 ? _a : rgb.format;
      this.gradientType = opts.gradientType;
      if (this.r < 1) {
        this.r = Math.round(this.r);
      }
      if (this.g < 1) {
        this.g = Math.round(this.g);
      }
      if (this.b < 1) {
        this.b = Math.round(this.b);
      }
      this.isValid = rgb.ok;
    }
    TinyColor2.prototype.isDark = function() {
      return this.getBrightness() < 128;
    };
    TinyColor2.prototype.isLight = function() {
      return !this.isDark();
    };
    TinyColor2.prototype.getBrightness = function() {
      var rgb = this.toRgb();
      return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3;
    };
    TinyColor2.prototype.getLuminance = function() {
      var rgb = this.toRgb();
      var R;
      var G;
      var B;
      var RsRGB = rgb.r / 255;
      var GsRGB = rgb.g / 255;
      var BsRGB = rgb.b / 255;
      if (RsRGB <= 0.03928) {
        R = RsRGB / 12.92;
      } else {
        R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
      }
      if (GsRGB <= 0.03928) {
        G = GsRGB / 12.92;
      } else {
        G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
      }
      if (BsRGB <= 0.03928) {
        B = BsRGB / 12.92;
      } else {
        B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
      }
      return 0.2126 * R + 0.7152 * G + 0.0722 * B;
    };
    TinyColor2.prototype.getAlpha = function() {
      return this.a;
    };
    TinyColor2.prototype.setAlpha = function(alpha) {
      this.a = boundAlpha(alpha);
      this.roundA = Math.round(100 * this.a) / 100;
      return this;
    };
    TinyColor2.prototype.isMonochrome = function() {
      var s = this.toHsl().s;
      return s === 0;
    };
    TinyColor2.prototype.toHsv = function() {
      var hsv = rgbToHsv(this.r, this.g, this.b);
      return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
    };
    TinyColor2.prototype.toHsvString = function() {
      var hsv = rgbToHsv(this.r, this.g, this.b);
      var h = Math.round(hsv.h * 360);
      var s = Math.round(hsv.s * 100);
      var v = Math.round(hsv.v * 100);
      return this.a === 1 ? "hsv(".concat(h, ", ").concat(s, "%, ").concat(v, "%)") : "hsva(".concat(h, ", ").concat(s, "%, ").concat(v, "%, ").concat(this.roundA, ")");
    };
    TinyColor2.prototype.toHsl = function() {
      var hsl = rgbToHsl(this.r, this.g, this.b);
      return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };
    };
    TinyColor2.prototype.toHslString = function() {
      var hsl = rgbToHsl(this.r, this.g, this.b);
      var h = Math.round(hsl.h * 360);
      var s = Math.round(hsl.s * 100);
      var l = Math.round(hsl.l * 100);
      return this.a === 1 ? "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)") : "hsla(".concat(h, ", ").concat(s, "%, ").concat(l, "%, ").concat(this.roundA, ")");
    };
    TinyColor2.prototype.toHex = function(allow3Char) {
      if (allow3Char === void 0) {
        allow3Char = false;
      }
      return rgbToHex(this.r, this.g, this.b, allow3Char);
    };
    TinyColor2.prototype.toHexString = function(allow3Char) {
      if (allow3Char === void 0) {
        allow3Char = false;
      }
      return "#" + this.toHex(allow3Char);
    };
    TinyColor2.prototype.toHex8 = function(allow4Char) {
      if (allow4Char === void 0) {
        allow4Char = false;
      }
      return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);
    };
    TinyColor2.prototype.toHex8String = function(allow4Char) {
      if (allow4Char === void 0) {
        allow4Char = false;
      }
      return "#" + this.toHex8(allow4Char);
    };
    TinyColor2.prototype.toHexShortString = function(allowShortChar) {
      if (allowShortChar === void 0) {
        allowShortChar = false;
      }
      return this.a === 1 ? this.toHexString(allowShortChar) : this.toHex8String(allowShortChar);
    };
    TinyColor2.prototype.toRgb = function() {
      return {
        r: Math.round(this.r),
        g: Math.round(this.g),
        b: Math.round(this.b),
        a: this.a
      };
    };
    TinyColor2.prototype.toRgbString = function() {
      var r = Math.round(this.r);
      var g = Math.round(this.g);
      var b = Math.round(this.b);
      return this.a === 1 ? "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")") : "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(this.roundA, ")");
    };
    TinyColor2.prototype.toPercentageRgb = function() {
      var fmt = function(x) {
        return "".concat(Math.round(bound01(x, 255) * 100), "%");
      };
      return {
        r: fmt(this.r),
        g: fmt(this.g),
        b: fmt(this.b),
        a: this.a
      };
    };
    TinyColor2.prototype.toPercentageRgbString = function() {
      var rnd = function(x) {
        return Math.round(bound01(x, 255) * 100);
      };
      return this.a === 1 ? "rgb(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%)") : "rgba(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%, ").concat(this.roundA, ")");
    };
    TinyColor2.prototype.toName = function() {
      if (this.a === 0) {
        return "transparent";
      }
      if (this.a < 1) {
        return false;
      }
      var hex = "#" + rgbToHex(this.r, this.g, this.b, false);
      for (var _i = 0, _a = Object.entries(names); _i < _a.length; _i++) {
        var _b = _a[_i], key = _b[0], value = _b[1];
        if (hex === value) {
          return key;
        }
      }
      return false;
    };
    TinyColor2.prototype.toString = function(format) {
      var formatSet = Boolean(format);
      format = format !== null && format !== void 0 ? format : this.format;
      var formattedString = false;
      var hasAlpha = this.a < 1 && this.a >= 0;
      var needsAlphaFormat = !formatSet && hasAlpha && (format.startsWith("hex") || format === "name");
      if (needsAlphaFormat) {
        if (format === "name" && this.a === 0) {
          return this.toName();
        }
        return this.toRgbString();
      }
      if (format === "rgb") {
        formattedString = this.toRgbString();
      }
      if (format === "prgb") {
        formattedString = this.toPercentageRgbString();
      }
      if (format === "hex" || format === "hex6") {
        formattedString = this.toHexString();
      }
      if (format === "hex3") {
        formattedString = this.toHexString(true);
      }
      if (format === "hex4") {
        formattedString = this.toHex8String(true);
      }
      if (format === "hex8") {
        formattedString = this.toHex8String();
      }
      if (format === "name") {
        formattedString = this.toName();
      }
      if (format === "hsl") {
        formattedString = this.toHslString();
      }
      if (format === "hsv") {
        formattedString = this.toHsvString();
      }
      return formattedString || this.toHexString();
    };
    TinyColor2.prototype.toNumber = function() {
      return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
    };
    TinyColor2.prototype.clone = function() {
      return new TinyColor2(this.toString());
    };
    TinyColor2.prototype.lighten = function(amount) {
      if (amount === void 0) {
        amount = 10;
      }
      var hsl = this.toHsl();
      hsl.l += amount / 100;
      hsl.l = clamp01(hsl.l);
      return new TinyColor2(hsl);
    };
    TinyColor2.prototype.brighten = function(amount) {
      if (amount === void 0) {
        amount = 10;
      }
      var rgb = this.toRgb();
      rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
      rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
      rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
      return new TinyColor2(rgb);
    };
    TinyColor2.prototype.darken = function(amount) {
      if (amount === void 0) {
        amount = 10;
      }
      var hsl = this.toHsl();
      hsl.l -= amount / 100;
      hsl.l = clamp01(hsl.l);
      return new TinyColor2(hsl);
    };
    TinyColor2.prototype.tint = function(amount) {
      if (amount === void 0) {
        amount = 10;
      }
      return this.mix("white", amount);
    };
    TinyColor2.prototype.shade = function(amount) {
      if (amount === void 0) {
        amount = 10;
      }
      return this.mix("black", amount);
    };
    TinyColor2.prototype.desaturate = function(amount) {
      if (amount === void 0) {
        amount = 10;
      }
      var hsl = this.toHsl();
      hsl.s -= amount / 100;
      hsl.s = clamp01(hsl.s);
      return new TinyColor2(hsl);
    };
    TinyColor2.prototype.saturate = function(amount) {
      if (amount === void 0) {
        amount = 10;
      }
      var hsl = this.toHsl();
      hsl.s += amount / 100;
      hsl.s = clamp01(hsl.s);
      return new TinyColor2(hsl);
    };
    TinyColor2.prototype.greyscale = function() {
      return this.desaturate(100);
    };
    TinyColor2.prototype.spin = function(amount) {
      var hsl = this.toHsl();
      var hue = (hsl.h + amount) % 360;
      hsl.h = hue < 0 ? 360 + hue : hue;
      return new TinyColor2(hsl);
    };
    TinyColor2.prototype.mix = function(color, amount) {
      if (amount === void 0) {
        amount = 50;
      }
      var rgb1 = this.toRgb();
      var rgb2 = new TinyColor2(color).toRgb();
      var p = amount / 100;
      var rgba = {
        r: (rgb2.r - rgb1.r) * p + rgb1.r,
        g: (rgb2.g - rgb1.g) * p + rgb1.g,
        b: (rgb2.b - rgb1.b) * p + rgb1.b,
        a: (rgb2.a - rgb1.a) * p + rgb1.a
      };
      return new TinyColor2(rgba);
    };
    TinyColor2.prototype.analogous = function(results, slices) {
      if (results === void 0) {
        results = 6;
      }
      if (slices === void 0) {
        slices = 30;
      }
      var hsl = this.toHsl();
      var part = 360 / slices;
      var ret = [this];
      for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results; ) {
        hsl.h = (hsl.h + part) % 360;
        ret.push(new TinyColor2(hsl));
      }
      return ret;
    };
    TinyColor2.prototype.complement = function() {
      var hsl = this.toHsl();
      hsl.h = (hsl.h + 180) % 360;
      return new TinyColor2(hsl);
    };
    TinyColor2.prototype.monochromatic = function(results) {
      if (results === void 0) {
        results = 6;
      }
      var hsv = this.toHsv();
      var h = hsv.h;
      var s = hsv.s;
      var v = hsv.v;
      var res = [];
      var modification = 1 / results;
      while (results--) {
        res.push(new TinyColor2({ h, s, v }));
        v = (v + modification) % 1;
      }
      return res;
    };
    TinyColor2.prototype.splitcomplement = function() {
      var hsl = this.toHsl();
      var h = hsl.h;
      return [
        this,
        new TinyColor2({ h: (h + 72) % 360, s: hsl.s, l: hsl.l }),
        new TinyColor2({ h: (h + 216) % 360, s: hsl.s, l: hsl.l })
      ];
    };
    TinyColor2.prototype.onBackground = function(background) {
      var fg = this.toRgb();
      var bg = new TinyColor2(background).toRgb();
      var alpha = fg.a + bg.a * (1 - fg.a);
      return new TinyColor2({
        r: (fg.r * fg.a + bg.r * bg.a * (1 - fg.a)) / alpha,
        g: (fg.g * fg.a + bg.g * bg.a * (1 - fg.a)) / alpha,
        b: (fg.b * fg.a + bg.b * bg.a * (1 - fg.a)) / alpha,
        a: alpha
      });
    };
    TinyColor2.prototype.triad = function() {
      return this.polyad(3);
    };
    TinyColor2.prototype.tetrad = function() {
      return this.polyad(4);
    };
    TinyColor2.prototype.polyad = function(n) {
      var hsl = this.toHsl();
      var h = hsl.h;
      var result = [this];
      var increment = 360 / n;
      for (var i = 1; i < n; i++) {
        result.push(new TinyColor2({ h: (h + i * increment) % 360, s: hsl.s, l: hsl.l }));
      }
      return result;
    };
    TinyColor2.prototype.equals = function(color) {
      return this.toRgbString() === new TinyColor2(color).toRgbString();
    };
    return TinyColor2;
  }();

  function darken(color, amount = 20) {
    return color.mix("#141414", amount).toString();
  }
  function useButtonCustomStyle(props) {
    const _disabled = useFormDisabled();
    const ns = useNamespace("button");
    return vue.computed(() => {
      let styles = {};
      let buttonColor = props.color;
      if (buttonColor) {
        const match = buttonColor.match(/var\((.*?)\)/);
        if (match) {
          buttonColor = window.getComputedStyle(window.document.documentElement).getPropertyValue(match[1]);
        }
        const color = new TinyColor(buttonColor);
        const activeBgColor = props.dark ? color.tint(20).toString() : darken(color, 20);
        if (props.plain) {
          styles = ns.cssVarBlock({
            "bg-color": props.dark ? darken(color, 90) : color.tint(90).toString(),
            "text-color": buttonColor,
            "border-color": props.dark ? darken(color, 50) : color.tint(50).toString(),
            "hover-text-color": `var(${ns.cssVarName("color-white")})`,
            "hover-bg-color": buttonColor,
            "hover-border-color": buttonColor,
            "active-bg-color": activeBgColor,
            "active-text-color": `var(${ns.cssVarName("color-white")})`,
            "active-border-color": activeBgColor
          });
          if (_disabled.value) {
            styles[ns.cssVarBlockName("disabled-bg-color")] = props.dark ? darken(color, 90) : color.tint(90).toString();
            styles[ns.cssVarBlockName("disabled-text-color")] = props.dark ? darken(color, 50) : color.tint(50).toString();
            styles[ns.cssVarBlockName("disabled-border-color")] = props.dark ? darken(color, 80) : color.tint(80).toString();
          }
        } else {
          const hoverBgColor = props.dark ? darken(color, 30) : color.tint(30).toString();
          const textColor = color.isDark() ? `var(${ns.cssVarName("color-white")})` : `var(${ns.cssVarName("color-black")})`;
          styles = ns.cssVarBlock({
            "bg-color": buttonColor,
            "text-color": textColor,
            "border-color": buttonColor,
            "hover-bg-color": hoverBgColor,
            "hover-text-color": textColor,
            "hover-border-color": hoverBgColor,
            "active-bg-color": activeBgColor,
            "active-border-color": activeBgColor
          });
          if (_disabled.value) {
            const disabledButtonColor = props.dark ? darken(color, 50) : color.tint(50).toString();
            styles[ns.cssVarBlockName("disabled-bg-color")] = disabledButtonColor;
            styles[ns.cssVarBlockName("disabled-text-color")] = props.dark ? "rgba(255, 255, 255, 0.5)" : `var(${ns.cssVarName("color-white")})`;
            styles[ns.cssVarBlockName("disabled-border-color")] = disabledButtonColor;
          }
        }
      }
      return styles;
    });
  }

  const __default__$1E = vue.defineComponent({
    name: "ElButton"
  });
  const _sfc_main$27 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1E,
    props: buttonProps,
    emits: buttonEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const buttonStyle = useButtonCustomStyle(props);
      const ns = useNamespace("button");
      const {
        _ref,
        _size,
        _type,
        _disabled,
        _props,
        _plain,
        _round,
        _text,
        shouldAddSpace,
        handleClick
      } = useButton(props, emit);
      const buttonKls = vue.computed(() => [
        ns.b(),
        ns.m(_type.value),
        ns.m(_size.value),
        ns.is("disabled", _disabled.value),
        ns.is("loading", props.loading),
        ns.is("plain", _plain.value),
        ns.is("round", _round.value),
        ns.is("circle", props.circle),
        ns.is("text", _text.value),
        ns.is("link", props.link),
        ns.is("has-bg", props.bg)
      ]);
      expose({
        ref: _ref,
        size: _size,
        type: _type,
        disabled: _disabled,
        shouldAddSpace
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), vue.mergeProps({
          ref_key: "_ref",
          ref: _ref
        }, vue.unref(_props), {
          class: vue.unref(buttonKls),
          style: vue.unref(buttonStyle),
          onClick: vue.unref(handleClick)
        }), {
          default: vue.withCtx(() => [
            _ctx.loading ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
              _ctx.$slots.loading ? vue.renderSlot(_ctx.$slots, "loading", { key: 0 }) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 1,
                class: vue.normalizeClass(vue.unref(ns).is("loading"))
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.loadingIcon)))
                ]),
                _: 1
              }, 8, ["class"]))
            ], 64)) : _ctx.icon || _ctx.$slots.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
              default: vue.withCtx(() => [
                _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon), { key: 0 })) : vue.renderSlot(_ctx.$slots, "icon", { key: 1 })
              ]),
              _: 3
            })) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 2,
              class: vue.normalizeClass({ [vue.unref(ns).em("text", "expand")]: vue.unref(shouldAddSpace) })
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ]),
          _: 3
        }, 16, ["class", "style", "onClick"]);
      };
    }
  });
  var Button = /* @__PURE__ */ _export_sfc(_sfc_main$27, [["__file", "button.vue"]]);

  const buttonGroupProps = {
    size: buttonProps.size,
    type: buttonProps.type
  };

  const __default__$1D = vue.defineComponent({
    name: "ElButtonGroup"
  });
  const _sfc_main$26 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1D,
    props: buttonGroupProps,
    setup(__props) {
      const props = __props;
      vue.provide(buttonGroupContextKey, vue.reactive({
        size: vue.toRef(props, "size"),
        type: vue.toRef(props, "type")
      }));
      const ns = useNamespace("button");
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b("group"))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2);
      };
    }
  });
  var ButtonGroup = /* @__PURE__ */ _export_sfc(_sfc_main$26, [["__file", "button-group.vue"]]);

  const ElButton = withInstall(Button, {
    ButtonGroup
  });
  const ElButtonGroup$1 = withNoopInstall(ButtonGroup);

  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

  var dayjs_min = {exports: {}};

  (function(module, exports) {
    !function(t, e) {
      module.exports = e() ;
    }(commonjsGlobal, function() {
      var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) {
        var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
        return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
      } }, m = function(t2, e2, n2) {
        var r2 = String(t2);
        return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
      }, v = { s: m, z: function(t2) {
        var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
        return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
      }, m: function t2(e2, n2) {
        if (e2.date() < n2.date())
          return -t2(n2, e2);
        var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c);
        return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
      }, a: function(t2) {
        return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
      }, p: function(t2) {
        return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
      }, u: function(t2) {
        return t2 === void 0;
      } }, g = "en", D = {};
      D[g] = M;
      var p = "$isDayjsObject", S = function(t2) {
        return t2 instanceof _ || !(!t2 || !t2[p]);
      }, w = function t2(e2, n2, r2) {
        var i2;
        if (!e2)
          return g;
        if (typeof e2 == "string") {
          var s2 = e2.toLowerCase();
          D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
          var u2 = e2.split("-");
          if (!i2 && u2.length > 1)
            return t2(u2[0]);
        } else {
          var a2 = e2.name;
          D[a2] = e2, i2 = a2;
        }
        return !r2 && i2 && (g = i2), i2 || !r2 && g;
      }, O = function(t2, e2) {
        if (S(t2))
          return t2.clone();
        var n2 = typeof e2 == "object" ? e2 : {};
        return n2.date = t2, n2.args = arguments, new _(n2);
      }, b = v;
      b.l = w, b.i = S, b.w = function(t2, e2) {
        return O(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
      };
      var _ = function() {
        function M2(t2) {
          this.$L = w(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = true;
        }
        var m2 = M2.prototype;
        return m2.parse = function(t2) {
          this.$d = function(t3) {
            var e2 = t3.date, n2 = t3.utc;
            if (e2 === null)
              return new Date(NaN);
            if (b.u(e2))
              return new Date();
            if (e2 instanceof Date)
              return new Date(e2);
            if (typeof e2 == "string" && !/Z$/i.test(e2)) {
              var r2 = e2.match($);
              if (r2) {
                var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
                return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
              }
            }
            return new Date(e2);
          }(t2), this.init();
        }, m2.init = function() {
          var t2 = this.$d;
          this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
        }, m2.$utils = function() {
          return b;
        }, m2.isValid = function() {
          return !(this.$d.toString() === l);
        }, m2.isSame = function(t2, e2) {
          var n2 = O(t2);
          return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
        }, m2.isAfter = function(t2, e2) {
          return O(t2) < this.startOf(e2);
        }, m2.isBefore = function(t2, e2) {
          return this.endOf(e2) < O(t2);
        }, m2.$g = function(t2, e2, n2) {
          return b.u(t2) ? this[e2] : this.set(n2, t2);
        }, m2.unix = function() {
          return Math.floor(this.valueOf() / 1e3);
        }, m2.valueOf = function() {
          return this.$d.getTime();
        }, m2.startOf = function(t2, e2) {
          var n2 = this, r2 = !!b.u(e2) || e2, f2 = b.p(t2), l2 = function(t3, e3) {
            var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
            return r2 ? i2 : i2.endOf(a);
          }, $2 = function(t3, e3) {
            return b.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
          }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
          switch (f2) {
            case h:
              return r2 ? l2(1, 0) : l2(31, 11);
            case c:
              return r2 ? l2(1, M3) : l2(0, M3 + 1);
            case o:
              var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
              return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
            case a:
            case d:
              return $2(v2 + "Hours", 0);
            case u:
              return $2(v2 + "Minutes", 1);
            case s:
              return $2(v2 + "Seconds", 2);
            case i:
              return $2(v2 + "Milliseconds", 3);
            default:
              return this.clone();
          }
        }, m2.endOf = function(t2) {
          return this.startOf(t2, false);
        }, m2.$set = function(t2, e2) {
          var n2, o2 = b.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
          if (o2 === c || o2 === h) {
            var y2 = this.clone().set(d, 1);
            y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
          } else
            l2 && this.$d[l2]($2);
          return this.init(), this;
        }, m2.set = function(t2, e2) {
          return this.clone().$set(t2, e2);
        }, m2.get = function(t2) {
          return this[b.p(t2)]();
        }, m2.add = function(r2, f2) {
          var d2, l2 = this;
          r2 = Number(r2);
          var $2 = b.p(f2), y2 = function(t2) {
            var e2 = O(l2);
            return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
          };
          if ($2 === c)
            return this.set(c, this.$M + r2);
          if ($2 === h)
            return this.set(h, this.$y + r2);
          if ($2 === a)
            return y2(1);
          if ($2 === o)
            return y2(7);
          var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
          return b.w(m3, this);
        }, m2.subtract = function(t2, e2) {
          return this.add(-1 * t2, e2);
        }, m2.format = function(t2) {
          var e2 = this, n2 = this.$locale();
          if (!this.isValid())
            return n2.invalidDate || l;
          var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = function(t3, n3, i3, s3) {
            return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
          }, d2 = function(t3) {
            return b.s(s2 % 12 || 12, t3, "0");
          }, $2 = f2 || function(t3, e3, n3) {
            var r3 = t3 < 12 ? "AM" : "PM";
            return n3 ? r3.toLowerCase() : r3;
          };
          return r2.replace(y, function(t3, r3) {
            return r3 || function(t4) {
              switch (t4) {
                case "YY":
                  return String(e2.$y).slice(-2);
                case "YYYY":
                  return b.s(e2.$y, 4, "0");
                case "M":
                  return a2 + 1;
                case "MM":
                  return b.s(a2 + 1, 2, "0");
                case "MMM":
                  return h2(n2.monthsShort, a2, c2, 3);
                case "MMMM":
                  return h2(c2, a2);
                case "D":
                  return e2.$D;
                case "DD":
                  return b.s(e2.$D, 2, "0");
                case "d":
                  return String(e2.$W);
                case "dd":
                  return h2(n2.weekdaysMin, e2.$W, o2, 2);
                case "ddd":
                  return h2(n2.weekdaysShort, e2.$W, o2, 3);
                case "dddd":
                  return o2[e2.$W];
                case "H":
                  return String(s2);
                case "HH":
                  return b.s(s2, 2, "0");
                case "h":
                  return d2(1);
                case "hh":
                  return d2(2);
                case "a":
                  return $2(s2, u2, true);
                case "A":
                  return $2(s2, u2, false);
                case "m":
                  return String(u2);
                case "mm":
                  return b.s(u2, 2, "0");
                case "s":
                  return String(e2.$s);
                case "ss":
                  return b.s(e2.$s, 2, "0");
                case "SSS":
                  return b.s(e2.$ms, 3, "0");
                case "Z":
                  return i2;
              }
              return null;
            }(t3) || i2.replace(":", "");
          });
        }, m2.utcOffset = function() {
          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
        }, m2.diff = function(r2, d2, l2) {
          var $2, y2 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = function() {
            return b.m(y2, m3);
          };
          switch (M3) {
            case h:
              $2 = D2() / 12;
              break;
            case c:
              $2 = D2();
              break;
            case f:
              $2 = D2() / 3;
              break;
            case o:
              $2 = (g2 - v2) / 6048e5;
              break;
            case a:
              $2 = (g2 - v2) / 864e5;
              break;
            case u:
              $2 = g2 / n;
              break;
            case s:
              $2 = g2 / e;
              break;
            case i:
              $2 = g2 / t;
              break;
            default:
              $2 = g2;
          }
          return l2 ? $2 : b.a($2);
        }, m2.daysInMonth = function() {
          return this.endOf(c).$D;
        }, m2.$locale = function() {
          return D[this.$L];
        }, m2.locale = function(t2, e2) {
          if (!t2)
            return this.$L;
          var n2 = this.clone(), r2 = w(t2, e2, true);
          return r2 && (n2.$L = r2), n2;
        }, m2.clone = function() {
          return b.w(this.$d, this);
        }, m2.toDate = function() {
          return new Date(this.valueOf());
        }, m2.toJSON = function() {
          return this.isValid() ? this.toISOString() : null;
        }, m2.toISOString = function() {
          return this.$d.toISOString();
        }, m2.toString = function() {
          return this.$d.toUTCString();
        }, M2;
      }(), k = _.prototype;
      return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach(function(t2) {
        k[t2[1]] = function(e2) {
          return this.$g(e2, t2[0], t2[1]);
        };
      }), O.extend = function(t2, e2) {
        return t2.$i || (t2(e2, _, O), t2.$i = true), O;
      }, O.locale = w, O.isDayjs = S, O.unix = function(t2) {
        return O(1e3 * t2);
      }, O.en = D[g], O.Ls = D, O.p = {}, O;
    });
  })(dayjs_min);
  var dayjs = dayjs_min.exports;

  var customParseFormat$1 = {exports: {}};

  (function(module, exports) {
    !function(e, t) {
      module.exports = t() ;
    }(commonjsGlobal, function() {
      var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" }, t = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|Q|YYYY|YY?|ww?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d/, r = /\d\d/, i = /\d\d?/, o = /\d*[^-_:/,()\s\d]+/, s = {}, a = function(e2) {
        return (e2 = +e2) + (e2 > 68 ? 1900 : 2e3);
      };
      var f = function(e2) {
        return function(t2) {
          this[e2] = +t2;
        };
      }, h = [/[+-]\d\d:?(\d\d)?|Z/, function(e2) {
        (this.zone || (this.zone = {})).offset = function(e3) {
          if (!e3)
            return 0;
          if (e3 === "Z")
            return 0;
          var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
          return n2 === 0 ? 0 : t2[0] === "+" ? -n2 : n2;
        }(e2);
      }], u = function(e2) {
        var t2 = s[e2];
        return t2 && (t2.indexOf ? t2 : t2.s.concat(t2.f));
      }, d = function(e2, t2) {
        var n2, r2 = s.meridiem;
        if (r2) {
          for (var i2 = 1; i2 <= 24; i2 += 1)
            if (e2.indexOf(r2(i2, 0, t2)) > -1) {
              n2 = i2 > 12;
              break;
            }
        } else
          n2 = e2 === (t2 ? "pm" : "PM");
        return n2;
      }, c = { A: [o, function(e2) {
        this.afternoon = d(e2, false);
      }], a: [o, function(e2) {
        this.afternoon = d(e2, true);
      }], Q: [n, function(e2) {
        this.month = 3 * (e2 - 1) + 1;
      }], S: [n, function(e2) {
        this.milliseconds = 100 * +e2;
      }], SS: [r, function(e2) {
        this.milliseconds = 10 * +e2;
      }], SSS: [/\d{3}/, function(e2) {
        this.milliseconds = +e2;
      }], s: [i, f("seconds")], ss: [i, f("seconds")], m: [i, f("minutes")], mm: [i, f("minutes")], H: [i, f("hours")], h: [i, f("hours")], HH: [i, f("hours")], hh: [i, f("hours")], D: [i, f("day")], DD: [r, f("day")], Do: [o, function(e2) {
        var t2 = s.ordinal, n2 = e2.match(/\d+/);
        if (this.day = n2[0], t2)
          for (var r2 = 1; r2 <= 31; r2 += 1)
            t2(r2).replace(/\[|\]/g, "") === e2 && (this.day = r2);
      }], w: [i, f("week")], ww: [r, f("week")], M: [i, f("month")], MM: [r, f("month")], MMM: [o, function(e2) {
        var t2 = u("months"), n2 = (u("monthsShort") || t2.map(function(e3) {
          return e3.slice(0, 3);
        })).indexOf(e2) + 1;
        if (n2 < 1)
          throw new Error();
        this.month = n2 % 12 || n2;
      }], MMMM: [o, function(e2) {
        var t2 = u("months").indexOf(e2) + 1;
        if (t2 < 1)
          throw new Error();
        this.month = t2 % 12 || t2;
      }], Y: [/[+-]?\d+/, f("year")], YY: [r, function(e2) {
        this.year = a(e2);
      }], YYYY: [/\d{4}/, f("year")], Z: h, ZZ: h };
      function l(n2) {
        var r2, i2;
        r2 = n2, i2 = s && s.formats;
        for (var o2 = (n2 = r2.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function(t2, n3, r3) {
          var o3 = r3 && r3.toUpperCase();
          return n3 || i2[r3] || e[r3] || i2[o3].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(e2, t3, n4) {
            return t3 || n4.slice(1);
          });
        })).match(t), a2 = o2.length, f2 = 0; f2 < a2; f2 += 1) {
          var h2 = o2[f2], u2 = c[h2], d2 = u2 && u2[0], l2 = u2 && u2[1];
          o2[f2] = l2 ? { regex: d2, parser: l2 } : h2.replace(/^\[|\]$/g, "");
        }
        return function(e2) {
          for (var t2 = {}, n3 = 0, r3 = 0; n3 < a2; n3 += 1) {
            var i3 = o2[n3];
            if (typeof i3 == "string")
              r3 += i3.length;
            else {
              var s2 = i3.regex, f3 = i3.parser, h3 = e2.slice(r3), u3 = s2.exec(h3)[0];
              f3.call(t2, u3), e2 = e2.replace(u3, "");
            }
          }
          return function(e3) {
            var t3 = e3.afternoon;
            if (t3 !== void 0) {
              var n4 = e3.hours;
              t3 ? n4 < 12 && (e3.hours += 12) : n4 === 12 && (e3.hours = 0), delete e3.afternoon;
            }
          }(t2), t2;
        };
      }
      return function(e2, t2, n2) {
        n2.p.customParseFormat = true, e2 && e2.parseTwoDigitYear && (a = e2.parseTwoDigitYear);
        var r2 = t2.prototype, i2 = r2.parse;
        r2.parse = function(e3) {
          var t3 = e3.date, r3 = e3.utc, o2 = e3.args;
          this.$u = r3;
          var a2 = o2[1];
          if (typeof a2 == "string") {
            var f2 = o2[2] === true, h2 = o2[3] === true, u2 = f2 || h2, d2 = o2[2];
            h2 && (d2 = o2[2]), s = this.$locale(), !f2 && d2 && (s = n2.Ls[d2]), this.$d = function(e4, t4, n3, r4) {
              try {
                if (["x", "X"].indexOf(t4) > -1)
                  return new Date((t4 === "X" ? 1e3 : 1) * e4);
                var i3 = l(t4)(e4), o3 = i3.year, s2 = i3.month, a3 = i3.day, f3 = i3.hours, h3 = i3.minutes, u3 = i3.seconds, d3 = i3.milliseconds, c3 = i3.zone, m2 = i3.week, M2 = new Date(), Y = a3 || (o3 || s2 ? 1 : M2.getDate()), p = o3 || M2.getFullYear(), v = 0;
                o3 && !s2 || (v = s2 > 0 ? s2 - 1 : M2.getMonth());
                var D, w = f3 || 0, g = h3 || 0, y = u3 || 0, L = d3 || 0;
                return c3 ? new Date(Date.UTC(p, v, Y, w, g, y, L + 60 * c3.offset * 1e3)) : n3 ? new Date(Date.UTC(p, v, Y, w, g, y, L)) : (D = new Date(p, v, Y, w, g, y, L), m2 && (D = r4(D).week(m2).toDate()), D);
              } catch (e5) {
                return new Date("");
              }
            }(t3, a2, r3, n2), this.init(), d2 && d2 !== true && (this.$L = this.locale(d2).$L), u2 && t3 != this.format(a2) && (this.$d = new Date("")), s = {};
          } else if (a2 instanceof Array)
            for (var c2 = a2.length, m = 1; m <= c2; m += 1) {
              o2[1] = a2[m - 1];
              var M = n2.apply(this, o2);
              if (M.isValid()) {
                this.$d = M.$d, this.$L = M.$L, this.init();
                break;
              }
              m === c2 && (this.$d = new Date(""));
            }
          else
            i2.call(this, e3);
        };
      };
    });
  })(customParseFormat$1);
  var customParseFormat = customParseFormat$1.exports;

  const timeUnits$1 = ["hours", "minutes", "seconds"];
  const PICKER_BASE_INJECTION_KEY = "EP_PICKER_BASE";
  const PICKER_POPPER_OPTIONS_INJECTION_KEY = "ElPopperOptions";
  const ROOT_COMMON_PICKER_INJECTION_KEY = Symbol("commonPickerContextKey");
  const DEFAULT_FORMATS_TIME = "HH:mm:ss";
  const DEFAULT_FORMATS_DATE = "YYYY-MM-DD";
  const DEFAULT_FORMATS_DATEPICKER = {
    date: DEFAULT_FORMATS_DATE,
    dates: DEFAULT_FORMATS_DATE,
    week: "gggg[w]ww",
    year: "YYYY",
    years: "YYYY",
    month: "YYYY-MM",
    months: "YYYY-MM",
    datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,
    monthrange: "YYYY-MM",
    yearrange: "YYYY",
    daterange: DEFAULT_FORMATS_DATE,
    datetimerange: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`
  };

  const buildTimeList = (value, bound) => {
    return [
      value > 0 ? value - 1 : void 0,
      value,
      value < bound ? value + 1 : void 0
    ];
  };
  const rangeArr = (n) => Array.from(Array.from({ length: n }).keys());
  const extractDateFormat = (format) => {
    return format.replace(/\W?m{1,2}|\W?ZZ/g, "").replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, "").trim();
  };
  const extractTimeFormat = (format) => {
    return format.replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, "").trim();
  };
  const dateEquals = function(a, b) {
    const aIsDate = isDate$1(a);
    const bIsDate = isDate$1(b);
    if (aIsDate && bIsDate) {
      return a.getTime() === b.getTime();
    }
    if (!aIsDate && !bIsDate) {
      return a === b;
    }
    return false;
  };
  const valueEquals = function(a, b) {
    const aIsArray = isArray$1(a);
    const bIsArray = isArray$1(b);
    if (aIsArray && bIsArray) {
      if (a.length !== b.length) {
        return false;
      }
      return a.every((item, index) => dateEquals(item, b[index]));
    }
    if (!aIsArray && !bIsArray) {
      return dateEquals(a, b);
    }
    return false;
  };
  const parseDate = function(date, format, lang) {
    const day = isEmpty(format) || format === "x" ? dayjs(date).locale(lang) : dayjs(date, format).locale(lang);
    return day.isValid() ? day : void 0;
  };
  const formatter = function(date, format, lang) {
    if (isEmpty(format))
      return date;
    if (format === "x")
      return +date;
    return dayjs(date).locale(lang).format(format);
  };
  const makeList = (total, method) => {
    var _a;
    const arr = [];
    const disabledArr = method == null ? void 0 : method();
    for (let i = 0; i < total; i++) {
      arr.push((_a = disabledArr == null ? void 0 : disabledArr.includes(i)) != null ? _a : false);
    }
    return arr;
  };
  const dayOrDaysToDate = (dayOrDays) => {
    return isArray$1(dayOrDays) ? dayOrDays.map((d) => d.toDate()) : dayOrDays.toDate();
  };

  const useCommonPicker = (props, emit) => {
    const { lang } = useLocale();
    const pickerVisible = vue.ref(false);
    const pickerActualVisible = vue.ref(false);
    const userInput = vue.ref(null);
    const valueIsEmpty = vue.computed(() => {
      const { modelValue } = props;
      return !modelValue || isArray$1(modelValue) && !modelValue.filter(Boolean).length;
    });
    const emitInput = (input) => {
      if (!valueEquals(props.modelValue, input)) {
        let formatted;
        if (isArray$1(input)) {
          formatted = input.map((item) => formatter(item, props.valueFormat, lang.value));
        } else if (input) {
          formatted = formatter(input, props.valueFormat, lang.value);
        }
        const emitVal = input ? formatted : input;
        emit(UPDATE_MODEL_EVENT, emitVal, lang.value);
      }
    };
    const parsedValue = vue.computed(() => {
      var _a;
      let dayOrDays;
      if (valueIsEmpty.value) {
        if (pickerOptions.value.getDefaultValue) {
          dayOrDays = pickerOptions.value.getDefaultValue();
        }
      } else {
        if (isArray$1(props.modelValue)) {
          dayOrDays = props.modelValue.map((d) => parseDate(d, props.valueFormat, lang.value));
        } else {
          dayOrDays = parseDate((_a = props.modelValue) != null ? _a : "", props.valueFormat, lang.value);
        }
      }
      if (pickerOptions.value.getRangeAvailableTime) {
        const availableResult = pickerOptions.value.getRangeAvailableTime(dayOrDays);
        if (!isEqual$1(availableResult, dayOrDays)) {
          dayOrDays = availableResult;
          if (!valueIsEmpty.value) {
            emitInput(dayOrDaysToDate(dayOrDays));
          }
        }
      }
      if (isArray$1(dayOrDays) && dayOrDays.some((day) => !day)) {
        dayOrDays = [];
      }
      return dayOrDays;
    });
    const pickerOptions = vue.ref({});
    const onSetPickerOption = (e) => {
      pickerOptions.value[e[0]] = e[1];
      pickerOptions.value.panelReady = true;
    };
    const onCalendarChange = (e) => {
      emit("calendar-change", e);
    };
    const onPanelChange = (value, mode, view) => {
      emit("panel-change", value, mode, view);
    };
    const onPick = (date = "", visible = false) => {
      pickerVisible.value = visible;
      let result;
      if (isArray$1(date)) {
        result = date.map((_) => _.toDate());
      } else {
        result = date ? date.toDate() : date;
      }
      userInput.value = null;
      emitInput(result);
    };
    return {
      parsedValue,
      pickerActualVisible,
      pickerOptions,
      pickerVisible,
      userInput,
      valueIsEmpty,
      emitInput,
      onCalendarChange,
      onPanelChange,
      onPick,
      onSetPickerOption
    };
  };

  const disabledTimeListsProps = buildProps({
    disabledHours: {
      type: definePropType(Function)
    },
    disabledMinutes: {
      type: definePropType(Function)
    },
    disabledSeconds: {
      type: definePropType(Function)
    }
  });
  const timePanelSharedProps = buildProps({
    visible: Boolean,
    actualVisible: {
      type: Boolean,
      default: void 0
    },
    format: {
      type: String,
      default: ""
    }
  });

  const timePickerDefaultProps = buildProps({
    automaticDropdown: {
      type: Boolean,
      default: true
    },
    id: {
      type: definePropType([Array, String])
    },
    name: {
      type: definePropType([Array, String])
    },
    popperClass: useTooltipContentProps.popperClass,
    popperStyle: useTooltipContentProps.popperStyle,
    format: String,
    valueFormat: String,
    dateFormat: String,
    timeFormat: String,
    type: {
      type: String,
      default: ""
    },
    clearable: {
      type: Boolean,
      default: true
    },
    clearIcon: {
      type: definePropType([String, Object]),
      default: circle_close_default
    },
    editable: {
      type: Boolean,
      default: true
    },
    prefixIcon: {
      type: definePropType([String, Object]),
      default: ""
    },
    size: useSizeProp,
    readonly: Boolean,
    disabled: Boolean,
    placeholder: {
      type: String,
      default: ""
    },
    popperOptions: {
      type: definePropType(Object),
      default: () => ({})
    },
    modelValue: {
      type: definePropType([Date, Array, String, Number]),
      default: ""
    },
    rangeSeparator: {
      type: String,
      default: "-"
    },
    startPlaceholder: String,
    endPlaceholder: String,
    defaultValue: {
      type: definePropType([Date, Array])
    },
    defaultTime: {
      type: definePropType([Date, Array])
    },
    isRange: Boolean,
    ...disabledTimeListsProps,
    disabledDate: {
      type: Function
    },
    cellClassName: {
      type: Function
    },
    shortcuts: {
      type: Array,
      default: () => []
    },
    arrowControl: Boolean,
    tabindex: {
      type: definePropType([String, Number]),
      default: 0
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    unlinkPanels: Boolean,
    placement: {
      type: definePropType(String),
      values: Ee,
      default: "bottom"
    },
    fallbackPlacements: {
      type: definePropType(Array),
      default: ["bottom", "top", "right", "left"]
    },
    ...useEmptyValuesProps,
    ...useAriaProps(["ariaLabel"]),
    showNow: {
      type: Boolean,
      default: true
    },
    showConfirm: {
      type: Boolean,
      default: true
    },
    showFooter: {
      type: Boolean,
      default: true
    },
    showWeekNumber: Boolean
  });
  const timePickerRangeTriggerProps = buildProps({
    id: {
      type: definePropType(Array)
    },
    name: {
      type: definePropType(Array)
    },
    modelValue: {
      type: definePropType([Array, String])
    },
    startPlaceholder: String,
    endPlaceholder: String,
    disabled: Boolean
  });
  const timePickerRngeTriggerProps = timePickerRangeTriggerProps;

  const __default__$1C = vue.defineComponent({
    name: "PickerRangeTrigger",
    inheritAttrs: false
  });
  const _sfc_main$25 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1C,
    props: timePickerRangeTriggerProps,
    emits: [
      "mouseenter",
      "mouseleave",
      "click",
      "touchstart",
      "focus",
      "blur",
      "startInput",
      "endInput",
      "startChange",
      "endChange"
    ],
    setup(__props, { expose, emit }) {
      const props = __props;
      const { formItem } = useFormItem();
      const { inputId } = useFormItemInputId(vue.reactive({ id: vue.computed(() => {
        var _a;
        return (_a = props.id) == null ? void 0 : _a[0];
      }) }), {
        formItemContext: formItem
      });
      const attrs = useAttrs();
      const nsDate = useNamespace("date");
      const nsRange = useNamespace("range");
      const inputRef = vue.ref();
      const endInputRef = vue.ref();
      const { wrapperRef, isFocused } = useFocusController(inputRef, {
        disabled: vue.computed(() => props.disabled)
      });
      const handleClick = (evt) => {
        emit("click", evt);
      };
      const handleMouseEnter = (evt) => {
        emit("mouseenter", evt);
      };
      const handleMouseLeave = (evt) => {
        emit("mouseleave", evt);
      };
      const handleTouchStart = (evt) => {
        emit("touchstart", evt);
      };
      const handleStartInput = (evt) => {
        emit("startInput", evt);
      };
      const handleEndInput = (evt) => {
        emit("endInput", evt);
      };
      const handleStartChange = (evt) => {
        emit("startChange", evt);
      };
      const handleEndChange = (evt) => {
        emit("endChange", evt);
      };
      const focus = () => {
        var _a;
        (_a = inputRef.value) == null ? void 0 : _a.focus();
      };
      const blur = () => {
        var _a, _b;
        (_a = inputRef.value) == null ? void 0 : _a.blur();
        (_b = endInputRef.value) == null ? void 0 : _b.blur();
      };
      expose({
        focus,
        blur
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "wrapperRef",
          ref: wrapperRef,
          class: vue.normalizeClass([vue.unref(nsDate).is("active", vue.unref(isFocused)), _ctx.$attrs.class]),
          style: vue.normalizeStyle(_ctx.$attrs.style),
          onClick: handleClick,
          onMouseenter: handleMouseEnter,
          onMouseleave: handleMouseLeave,
          onTouchstartPassive: handleTouchStart
        }, [
          vue.renderSlot(_ctx.$slots, "prefix"),
          vue.createElementVNode("input", vue.mergeProps(vue.unref(attrs), {
            id: vue.unref(inputId),
            ref_key: "inputRef",
            ref: inputRef,
            name: _ctx.name && _ctx.name[0],
            placeholder: _ctx.startPlaceholder,
            value: _ctx.modelValue && _ctx.modelValue[0],
            class: vue.unref(nsRange).b("input"),
            disabled: _ctx.disabled,
            onInput: handleStartInput,
            onChange: handleStartChange
          }), null, 16, ["id", "name", "placeholder", "value", "disabled"]),
          vue.renderSlot(_ctx.$slots, "range-separator"),
          vue.createElementVNode("input", vue.mergeProps(vue.unref(attrs), {
            id: _ctx.id && _ctx.id[1],
            ref_key: "endInputRef",
            ref: endInputRef,
            name: _ctx.name && _ctx.name[1],
            placeholder: _ctx.endPlaceholder,
            value: _ctx.modelValue && _ctx.modelValue[1],
            class: vue.unref(nsRange).b("input"),
            disabled: _ctx.disabled,
            onInput: handleEndInput,
            onChange: handleEndChange
          }), null, 16, ["id", "name", "placeholder", "value", "disabled"]),
          vue.renderSlot(_ctx.$slots, "suffix")
        ], 38);
      };
    }
  });
  var PickerRangeTrigger = /* @__PURE__ */ _export_sfc(_sfc_main$25, [["__file", "picker-range-trigger.vue"]]);

  const __default__$1B = vue.defineComponent({
    name: "Picker"
  });
  const _sfc_main$24 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1B,
    props: timePickerDefaultProps,
    emits: [
      UPDATE_MODEL_EVENT,
      CHANGE_EVENT,
      "focus",
      "blur",
      "clear",
      "calendar-change",
      "panel-change",
      "visible-change",
      "keydown"
    ],
    setup(__props, { expose, emit }) {
      const props = __props;
      const attrs = vue.useAttrs();
      const nsDate = useNamespace("date");
      const nsInput = useNamespace("input");
      const nsRange = useNamespace("range");
      const { formItem } = useFormItem();
      const elPopperOptions = vue.inject(PICKER_POPPER_OPTIONS_INJECTION_KEY, {});
      const emptyValues = useEmptyValues(props, null);
      const refPopper = vue.ref();
      const inputRef = vue.ref();
      const valueOnOpen = vue.ref(null);
      let hasJustTabExitedInput = false;
      const pickerDisabled = useFormDisabled();
      const commonPicker = useCommonPicker(props, emit);
      const {
        parsedValue,
        pickerActualVisible,
        userInput,
        pickerVisible,
        pickerOptions,
        valueIsEmpty,
        emitInput,
        onPick,
        onSetPickerOption,
        onCalendarChange,
        onPanelChange
      } = commonPicker;
      const { isFocused, handleFocus, handleBlur } = useFocusController(inputRef, {
        disabled: pickerDisabled,
        beforeFocus() {
          return props.readonly;
        },
        afterFocus() {
          if (!props.automaticDropdown)
            return;
          pickerVisible.value = true;
        },
        beforeBlur(event) {
          var _a;
          return !hasJustTabExitedInput && ((_a = refPopper.value) == null ? void 0 : _a.isFocusInsideContent(event));
        },
        afterBlur() {
          handleChange();
          pickerVisible.value = false;
          hasJustTabExitedInput = false;
          props.validateEvent && (formItem == null ? void 0 : formItem.validate("blur").catch((err) => debugWarn(err)));
        }
      });
      const hovering = vue.ref(false);
      const rangeInputKls = vue.computed(() => [
        nsDate.b("editor"),
        nsDate.bm("editor", props.type),
        nsInput.e("wrapper"),
        nsDate.is("disabled", pickerDisabled.value),
        nsDate.is("active", pickerVisible.value),
        nsRange.b("editor"),
        pickerSize ? nsRange.bm("editor", pickerSize.value) : "",
        attrs.class
      ]);
      const clearIconKls = vue.computed(() => [
        nsInput.e("icon"),
        nsRange.e("close-icon"),
        !showClearBtn.value ? nsRange.em("close-icon", "hidden") : ""
      ]);
      vue.watch(pickerVisible, (val) => {
        if (!val) {
          userInput.value = null;
          vue.nextTick(() => {
            emitChange(props.modelValue);
          });
        } else {
          vue.nextTick(() => {
            if (val) {
              valueOnOpen.value = props.modelValue;
            }
          });
        }
      });
      const emitChange = (val, isClear) => {
        if (isClear || !valueEquals(val, valueOnOpen.value)) {
          emit(CHANGE_EVENT, val);
          isClear && (valueOnOpen.value = val);
          props.validateEvent && (formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err)));
        }
      };
      const emitKeydown = (e) => {
        emit("keydown", e);
      };
      const refInput = vue.computed(() => {
        if (inputRef.value) {
          return Array.from(inputRef.value.$el.querySelectorAll("input"));
        }
        return [];
      });
      const setSelectionRange = (start, end, pos) => {
        const _inputs = refInput.value;
        if (!_inputs.length)
          return;
        if (!pos || pos === "min") {
          _inputs[0].setSelectionRange(start, end);
          _inputs[0].focus();
        } else if (pos === "max") {
          _inputs[1].setSelectionRange(start, end);
          _inputs[1].focus();
        }
      };
      const onBeforeShow = () => {
        pickerActualVisible.value = true;
      };
      const onShow = () => {
        emit("visible-change", true);
      };
      const onHide = () => {
        pickerActualVisible.value = false;
        pickerVisible.value = false;
        emit("visible-change", false);
      };
      const handleOpen = () => {
        pickerVisible.value = true;
      };
      const handleClose = () => {
        pickerVisible.value = false;
      };
      const displayValue = vue.computed(() => {
        const formattedValue = formatToString(parsedValue.value);
        if (isArray$1(userInput.value)) {
          return [
            userInput.value[0] || formattedValue && formattedValue[0] || "",
            userInput.value[1] || formattedValue && formattedValue[1] || ""
          ];
        } else if (userInput.value !== null) {
          return userInput.value;
        }
        if (!isTimePicker.value && valueIsEmpty.value)
          return "";
        if (!pickerVisible.value && valueIsEmpty.value)
          return "";
        if (formattedValue) {
          return isDatesPicker.value || isMonthsPicker.value || isYearsPicker.value ? formattedValue.join(", ") : formattedValue;
        }
        return "";
      });
      const isTimeLikePicker = vue.computed(() => props.type.includes("time"));
      const isTimePicker = vue.computed(() => props.type.startsWith("time"));
      const isDatesPicker = vue.computed(() => props.type === "dates");
      const isMonthsPicker = vue.computed(() => props.type === "months");
      const isYearsPicker = vue.computed(() => props.type === "years");
      const triggerIcon = vue.computed(() => props.prefixIcon || (isTimeLikePicker.value ? clock_default : calendar_default));
      const showClearBtn = vue.computed(() => props.clearable && !pickerDisabled.value && !props.readonly && !valueIsEmpty.value && (hovering.value || isFocused.value));
      const onClearIconClick = (event) => {
        if (props.readonly || pickerDisabled.value)
          return;
        if (showClearBtn.value) {
          event.stopPropagation();
          if (pickerOptions.value.handleClear) {
            pickerOptions.value.handleClear();
          } else {
            emitInput(emptyValues.valueOnClear.value);
          }
          emitChange(emptyValues.valueOnClear.value, true);
          onHide();
        }
        emit("clear");
      };
      const onMouseDownInput = async (event) => {
        var _a;
        if (props.readonly || pickerDisabled.value)
          return;
        if (((_a = event.target) == null ? void 0 : _a.tagName) !== "INPUT" || isFocused.value || !props.automaticDropdown) {
          pickerVisible.value = true;
        }
      };
      const onMouseEnter = () => {
        if (props.readonly || pickerDisabled.value)
          return;
        if (!valueIsEmpty.value && props.clearable) {
          hovering.value = true;
        }
      };
      const onMouseLeave = () => {
        hovering.value = false;
      };
      const onTouchStartInput = (event) => {
        var _a;
        if (props.readonly || pickerDisabled.value)
          return;
        if (((_a = event.touches[0].target) == null ? void 0 : _a.tagName) !== "INPUT" || isFocused.value || !props.automaticDropdown) {
          pickerVisible.value = true;
        }
      };
      const isRangeInput = vue.computed(() => {
        return props.type.includes("range");
      });
      const pickerSize = useFormSize();
      const popperEl = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = vue.unref(refPopper)) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
      });
      const stophandle = onClickOutside(inputRef, (e) => {
        const unrefedPopperEl = vue.unref(popperEl);
        const inputEl = unrefElement(inputRef);
        if (unrefedPopperEl && (e.target === unrefedPopperEl || e.composedPath().includes(unrefedPopperEl)) || e.target === inputEl || inputEl && e.composedPath().includes(inputEl))
          return;
        pickerVisible.value = false;
      });
      vue.onBeforeUnmount(() => {
        stophandle == null ? void 0 : stophandle();
      });
      const handleChange = () => {
        if (userInput.value) {
          const value = parseUserInputToDayjs(displayValue.value);
          if (value) {
            if (isValidValue(value)) {
              emitInput(dayOrDaysToDate(value));
              userInput.value = null;
            }
          }
        }
        if (userInput.value === "") {
          emitInput(emptyValues.valueOnClear.value);
          emitChange(emptyValues.valueOnClear.value, true);
          userInput.value = null;
        }
      };
      const parseUserInputToDayjs = (value) => {
        if (!value)
          return null;
        return pickerOptions.value.parseUserInput(value);
      };
      const formatToString = (value) => {
        if (!value)
          return null;
        const res = isArray$1(value) ? value.map((_) => _.format(props.format)) : value.format(props.format);
        return res;
      };
      const isValidValue = (value) => {
        return pickerOptions.value.isValidValue(value);
      };
      const handleKeydownInput = async (event) => {
        if (props.readonly || pickerDisabled.value)
          return;
        const code = getEventCode(event);
        emitKeydown(event);
        if (code === EVENT_CODE.esc) {
          if (pickerVisible.value === true) {
            pickerVisible.value = false;
            event.preventDefault();
            event.stopPropagation();
          }
          return;
        }
        if (code === EVENT_CODE.down) {
          if (pickerOptions.value.handleFocusPicker) {
            event.preventDefault();
            event.stopPropagation();
          }
          if (pickerVisible.value === false) {
            pickerVisible.value = true;
            await vue.nextTick();
          }
          if (pickerOptions.value.handleFocusPicker) {
            pickerOptions.value.handleFocusPicker();
            return;
          }
        }
        if (code === EVENT_CODE.tab) {
          hasJustTabExitedInput = true;
          return;
        }
        if (code === EVENT_CODE.enter || code === EVENT_CODE.numpadEnter) {
          if (!pickerVisible.value) {
            pickerVisible.value = true;
          } else if (userInput.value === null || userInput.value === "" || isValidValue(parseUserInputToDayjs(displayValue.value))) {
            handleChange();
            pickerVisible.value = false;
          }
          event.preventDefault();
          event.stopPropagation();
          return;
        }
        if (userInput.value) {
          event.stopPropagation();
          return;
        }
        if (pickerOptions.value.handleKeydownInput) {
          pickerOptions.value.handleKeydownInput(event);
        }
      };
      const onUserInput = (e) => {
        userInput.value = e;
        if (!pickerVisible.value) {
          pickerVisible.value = true;
        }
      };
      const handleStartInput = (event) => {
        const target = event.target;
        if (userInput.value) {
          userInput.value = [target.value, userInput.value[1]];
        } else {
          userInput.value = [target.value, null];
        }
      };
      const handleEndInput = (event) => {
        const target = event.target;
        if (userInput.value) {
          userInput.value = [userInput.value[0], target.value];
        } else {
          userInput.value = [null, target.value];
        }
      };
      const handleStartChange = () => {
        var _a;
        const values = userInput.value;
        const value = parseUserInputToDayjs(values && values[0]);
        const parsedVal = vue.unref(parsedValue);
        if (value && value.isValid()) {
          userInput.value = [
            formatToString(value),
            ((_a = displayValue.value) == null ? void 0 : _a[1]) || null
          ];
          const newValue = [value, parsedVal && (parsedVal[1] || null)];
          if (isValidValue(newValue)) {
            emitInput(dayOrDaysToDate(newValue));
            userInput.value = null;
          }
        }
      };
      const handleEndChange = () => {
        var _a;
        const values = vue.unref(userInput);
        const value = parseUserInputToDayjs(values && values[1]);
        const parsedVal = vue.unref(parsedValue);
        if (value && value.isValid()) {
          userInput.value = [
            ((_a = vue.unref(displayValue)) == null ? void 0 : _a[0]) || null,
            formatToString(value)
          ];
          const newValue = [parsedVal && parsedVal[0], value];
          if (isValidValue(newValue)) {
            emitInput(dayOrDaysToDate(newValue));
            userInput.value = null;
          }
        }
      };
      const focus = () => {
        var _a;
        (_a = inputRef.value) == null ? void 0 : _a.focus();
      };
      const blur = () => {
        var _a;
        (_a = inputRef.value) == null ? void 0 : _a.blur();
      };
      vue.provide(PICKER_BASE_INJECTION_KEY, {
        props,
        emptyValues
      });
      vue.provide(ROOT_COMMON_PICKER_INJECTION_KEY, commonPicker);
      expose({
        focus,
        blur,
        handleOpen,
        handleClose,
        onPick
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), vue.mergeProps({
          ref_key: "refPopper",
          ref: refPopper,
          visible: vue.unref(pickerVisible),
          effect: "light",
          pure: "",
          trigger: "click"
        }, _ctx.$attrs, {
          role: "dialog",
          teleported: "",
          transition: `${vue.unref(nsDate).namespace.value}-zoom-in-top`,
          "popper-class": [`${vue.unref(nsDate).namespace.value}-picker__popper`, _ctx.popperClass],
          "popper-style": _ctx.popperStyle,
          "popper-options": vue.unref(elPopperOptions),
          "fallback-placements": _ctx.fallbackPlacements,
          "gpu-acceleration": false,
          placement: _ctx.placement,
          "stop-popper-mouse-event": false,
          "hide-after": 0,
          persistent: "",
          onBeforeShow,
          onShow,
          onHide
        }), {
          default: vue.withCtx(() => [
            !vue.unref(isRangeInput) ? (vue.openBlock(), vue.createBlock(vue.unref(ElInput), {
              key: 0,
              id: _ctx.id,
              ref_key: "inputRef",
              ref: inputRef,
              "container-role": "combobox",
              "model-value": vue.unref(displayValue),
              name: _ctx.name,
              size: vue.unref(pickerSize),
              disabled: vue.unref(pickerDisabled),
              placeholder: _ctx.placeholder,
              class: vue.normalizeClass([
                vue.unref(nsDate).b("editor"),
                vue.unref(nsDate).bm("editor", _ctx.type),
                vue.unref(nsDate).is("focus", vue.unref(pickerVisible)),
                _ctx.$attrs.class
              ]),
              style: vue.normalizeStyle(_ctx.$attrs.style),
              readonly: !_ctx.editable || _ctx.readonly || vue.unref(isDatesPicker) || vue.unref(isMonthsPicker) || vue.unref(isYearsPicker) || _ctx.type === "week",
              "aria-label": _ctx.ariaLabel,
              tabindex: _ctx.tabindex,
              "validate-event": false,
              onInput: onUserInput,
              onFocus: vue.unref(handleFocus),
              onBlur: vue.unref(handleBlur),
              onKeydown: handleKeydownInput,
              onChange: handleChange,
              onMousedown: onMouseDownInput,
              onMouseenter: onMouseEnter,
              onMouseleave: onMouseLeave,
              onTouchstartPassive: onTouchStartInput,
              onClick: vue.withModifiers(() => {
              }, ["stop"])
            }, {
              prefix: vue.withCtx(() => [
                vue.unref(triggerIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(nsInput).e("icon")),
                  onMousedown: vue.withModifiers(onMouseDownInput, ["prevent"]),
                  onTouchstartPassive: onTouchStartInput
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(triggerIcon))))
                  ]),
                  _: 1
                }, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true)
              ]),
              suffix: vue.withCtx(() => [
                vue.unref(showClearBtn) && _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(`${vue.unref(nsInput).e("icon")} clear-icon`),
                  onMousedown: vue.withModifiers(vue.unref(NOOP), ["prevent"]),
                  onClick: onClearIconClick
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                  ]),
                  _: 1
                }, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true)
              ]),
              _: 1
            }, 8, ["id", "model-value", "name", "size", "disabled", "placeholder", "class", "style", "readonly", "aria-label", "tabindex", "onFocus", "onBlur", "onClick"])) : (vue.openBlock(), vue.createBlock(PickerRangeTrigger, {
              key: 1,
              id: _ctx.id,
              ref_key: "inputRef",
              ref: inputRef,
              "model-value": vue.unref(displayValue),
              name: _ctx.name,
              disabled: vue.unref(pickerDisabled),
              readonly: !_ctx.editable || _ctx.readonly,
              "start-placeholder": _ctx.startPlaceholder,
              "end-placeholder": _ctx.endPlaceholder,
              class: vue.normalizeClass(vue.unref(rangeInputKls)),
              style: vue.normalizeStyle(_ctx.$attrs.style),
              "aria-label": _ctx.ariaLabel,
              tabindex: _ctx.tabindex,
              autocomplete: "off",
              role: "combobox",
              onClick: onMouseDownInput,
              onFocus: vue.unref(handleFocus),
              onBlur: vue.unref(handleBlur),
              onStartInput: handleStartInput,
              onStartChange: handleStartChange,
              onEndInput: handleEndInput,
              onEndChange: handleEndChange,
              onMousedown: onMouseDownInput,
              onMouseenter: onMouseEnter,
              onMouseleave: onMouseLeave,
              onTouchstartPassive: onTouchStartInput,
              onKeydown: handleKeydownInput
            }, {
              prefix: vue.withCtx(() => [
                vue.unref(triggerIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass([vue.unref(nsInput).e("icon"), vue.unref(nsRange).e("icon")])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(triggerIcon))))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
              ]),
              "range-separator": vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "range-separator", {}, () => [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(nsRange).b("separator"))
                  }, vue.toDisplayString(_ctx.rangeSeparator), 3)
                ])
              ]),
              suffix: vue.withCtx(() => [
                _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(clearIconKls)),
                  onMousedown: vue.withModifiers(vue.unref(NOOP), ["prevent"]),
                  onClick: onClearIconClick
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                  ]),
                  _: 1
                }, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["id", "model-value", "name", "disabled", "readonly", "start-placeholder", "end-placeholder", "class", "style", "aria-label", "tabindex", "onFocus", "onBlur"]))
          ]),
          content: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default", {
              visible: vue.unref(pickerVisible),
              actualVisible: vue.unref(pickerActualVisible),
              parsedValue: vue.unref(parsedValue),
              format: _ctx.format,
              dateFormat: _ctx.dateFormat,
              timeFormat: _ctx.timeFormat,
              unlinkPanels: _ctx.unlinkPanels,
              type: _ctx.type,
              defaultValue: _ctx.defaultValue,
              showNow: _ctx.showNow,
              showConfirm: _ctx.showConfirm,
              showFooter: _ctx.showFooter,
              showWeekNumber: _ctx.showWeekNumber,
              onPick: vue.unref(onPick),
              onSelectRange: setSelectionRange,
              onSetPickerOption: vue.unref(onSetPickerOption),
              onCalendarChange: vue.unref(onCalendarChange),
              onPanelChange: vue.unref(onPanelChange),
              onMousedown: vue.withModifiers(() => {
              }, ["stop"])
            })
          ]),
          _: 3
        }, 16, ["visible", "transition", "popper-class", "popper-style", "popper-options", "fallback-placements", "placement"]);
      };
    }
  });
  var CommonPicker = /* @__PURE__ */ _export_sfc(_sfc_main$24, [["__file", "picker.vue"]]);

  const panelTimePickerProps = buildProps({
    ...timePanelSharedProps,
    datetimeRole: String,
    parsedValue: {
      type: definePropType(Object)
    }
  });

  const useTimePanel = ({
    getAvailableHours,
    getAvailableMinutes,
    getAvailableSeconds
  }) => {
    const getAvailableTime = (date, role, first, compareDate) => {
      const availableTimeGetters = {
        hour: getAvailableHours,
        minute: getAvailableMinutes,
        second: getAvailableSeconds
      };
      let result = date;
      ["hour", "minute", "second"].forEach((type) => {
        if (availableTimeGetters[type]) {
          let availableTimeSlots;
          const method = availableTimeGetters[type];
          switch (type) {
            case "minute": {
              availableTimeSlots = method(result.hour(), role, compareDate);
              break;
            }
            case "second": {
              availableTimeSlots = method(result.hour(), result.minute(), role, compareDate);
              break;
            }
            default: {
              availableTimeSlots = method(role, compareDate);
              break;
            }
          }
          if ((availableTimeSlots == null ? void 0 : availableTimeSlots.length) && !availableTimeSlots.includes(result[type]())) {
            const pos = first ? 0 : availableTimeSlots.length - 1;
            result = result[type](availableTimeSlots[pos]);
          }
        }
      });
      return result;
    };
    const timePickerOptions = {};
    const onSetOption = ([key, val]) => {
      timePickerOptions[key] = val;
    };
    return {
      timePickerOptions,
      getAvailableTime,
      onSetOption
    };
  };

  const makeAvailableArr = (disabledList) => {
    const trueOrNumber = (isDisabled, index) => isDisabled || index;
    const getNumber = (predicate) => predicate !== true;
    return disabledList.map(trueOrNumber).filter(getNumber);
  };
  const getTimeLists = (disabledHours, disabledMinutes, disabledSeconds) => {
    const getHoursList = (role, compare) => {
      return makeList(24, disabledHours && (() => disabledHours == null ? void 0 : disabledHours(role, compare)));
    };
    const getMinutesList = (hour, role, compare) => {
      return makeList(60, disabledMinutes && (() => disabledMinutes == null ? void 0 : disabledMinutes(hour, role, compare)));
    };
    const getSecondsList = (hour, minute, role, compare) => {
      return makeList(60, disabledSeconds && (() => disabledSeconds == null ? void 0 : disabledSeconds(hour, minute, role, compare)));
    };
    return {
      getHoursList,
      getMinutesList,
      getSecondsList
    };
  };
  const buildAvailableTimeSlotGetter = (disabledHours, disabledMinutes, disabledSeconds) => {
    const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(disabledHours, disabledMinutes, disabledSeconds);
    const getAvailableHours = (role, compare) => {
      return makeAvailableArr(getHoursList(role, compare));
    };
    const getAvailableMinutes = (hour, role, compare) => {
      return makeAvailableArr(getMinutesList(hour, role, compare));
    };
    const getAvailableSeconds = (hour, minute, role, compare) => {
      return makeAvailableArr(getSecondsList(hour, minute, role, compare));
    };
    return {
      getAvailableHours,
      getAvailableMinutes,
      getAvailableSeconds
    };
  };
  const useOldValue = (props) => {
    const oldValue = vue.ref(props.parsedValue);
    vue.watch(() => props.visible, (val) => {
      if (!val) {
        oldValue.value = props.parsedValue;
      }
    });
    return oldValue;
  };

  const nodeList = /* @__PURE__ */ new Map();
  if (isClient) {
    let startClick;
    document.addEventListener("mousedown", (e) => startClick = e);
    document.addEventListener("mouseup", (e) => {
      if (startClick) {
        for (const handlers of nodeList.values()) {
          for (const { documentHandler } of handlers) {
            documentHandler(e, startClick);
          }
        }
        startClick = void 0;
      }
    });
  }
  function createDocumentHandler(el, binding) {
    let excludes = [];
    if (isArray$1(binding.arg)) {
      excludes = binding.arg;
    } else if (isElement$2(binding.arg)) {
      excludes.push(binding.arg);
    }
    return function(mouseup, mousedown) {
      const popperRef = binding.instance.popperRef;
      const mouseUpTarget = mouseup.target;
      const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
      const isBound = !binding || !binding.instance;
      const isTargetExists = !mouseUpTarget || !mouseDownTarget;
      const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
      const isSelf = el === mouseUpTarget;
      const isTargetExcluded = excludes.length && excludes.some((item) => item == null ? void 0 : item.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
      const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
      if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
        return;
      }
      binding.value(mouseup, mousedown);
    };
  }
  const ClickOutside = {
    beforeMount(el, binding) {
      if (!nodeList.has(el)) {
        nodeList.set(el, []);
      }
      nodeList.get(el).push({
        documentHandler: createDocumentHandler(el, binding),
        bindingFn: binding.value
      });
    },
    updated(el, binding) {
      if (!nodeList.has(el)) {
        nodeList.set(el, []);
      }
      const handlers = nodeList.get(el);
      const oldHandlerIndex = handlers.findIndex((item) => item.bindingFn === binding.oldValue);
      const newHandler = {
        documentHandler: createDocumentHandler(el, binding),
        bindingFn: binding.value
      };
      if (oldHandlerIndex >= 0) {
        handlers.splice(oldHandlerIndex, 1, newHandler);
      } else {
        handlers.push(newHandler);
      }
    },
    unmounted(el) {
      nodeList.delete(el);
    }
  };

  const REPEAT_INTERVAL = 100;
  const REPEAT_DELAY = 600;
  const SCOPE$5 = "_RepeatClick";
  const vRepeatClick = {
    beforeMount(el, binding) {
      const value = binding.value;
      const { interval = REPEAT_INTERVAL, delay = REPEAT_DELAY } = isFunction$1(value) ? {} : value;
      let intervalId;
      let delayId;
      const handler = () => isFunction$1(value) ? value() : value.handler();
      const clear = () => {
        if (delayId) {
          clearTimeout(delayId);
          delayId = void 0;
        }
        if (intervalId) {
          clearInterval(intervalId);
          intervalId = void 0;
        }
      };
      const start = (evt) => {
        if (evt.button !== 0)
          return;
        clear();
        handler();
        document.addEventListener("mouseup", clear, { once: true });
        delayId = setTimeout(() => {
          intervalId = setInterval(() => {
            handler();
          }, interval);
        }, delay);
      };
      el[SCOPE$5] = { start, clear };
      el.addEventListener("mousedown", start);
    },
    unmounted(el) {
      if (!el[SCOPE$5])
        return;
      const { start, clear } = el[SCOPE$5];
      if (start) {
        el.removeEventListener("mousedown", start);
      }
      if (clear) {
        clear();
        document.removeEventListener("mouseup", clear);
      }
      el[SCOPE$5] = null;
    }
  };

  const FOCUSABLE_CHILDREN = "_trap-focus-children";
  const FOCUS_STACK = [];
  const FOCUS_HANDLER = (e) => {
    if (FOCUS_STACK.length === 0)
      return;
    const code = getEventCode(e);
    const focusableElement = FOCUS_STACK[FOCUS_STACK.length - 1][FOCUSABLE_CHILDREN];
    if (focusableElement.length > 0 && code === EVENT_CODE.tab) {
      if (focusableElement.length === 1) {
        e.preventDefault();
        if (document.activeElement !== focusableElement[0]) {
          focusableElement[0].focus();
        }
        return;
      }
      const goingBackward = e.shiftKey;
      const isFirst = e.target === focusableElement[0];
      const isLast = e.target === focusableElement[focusableElement.length - 1];
      if (isFirst && goingBackward) {
        e.preventDefault();
        focusableElement[focusableElement.length - 1].focus();
      }
      if (isLast && !goingBackward) {
        e.preventDefault();
        focusableElement[0].focus();
      }
    }
  };
  const TrapFocus = {
    beforeMount(el) {
      el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements$1(el);
      FOCUS_STACK.push(el);
      if (FOCUS_STACK.length <= 1) {
        document.addEventListener("keydown", FOCUS_HANDLER);
      }
    },
    updated(el) {
      vue.nextTick(() => {
        el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements$1(el);
      });
    },
    unmounted() {
      FOCUS_STACK.shift();
      if (FOCUS_STACK.length === 0) {
        document.removeEventListener("keydown", FOCUS_HANDLER);
      }
    }
  };

  var v=!1,o,f,s,u,d,N,l,p,m,w,D,x,E,M,F;function a(){if(!v){v=!0;var e=navigator.userAgent,n=/(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(e),i=/(Mac OS X)|(Windows)|(Linux)/.exec(e);if(x=/\b(iPhone|iP[ao]d)/.exec(e),E=/\b(iP[ao]d)/.exec(e),w=/Android/i.exec(e),M=/FBAN\/\w+;/i.exec(e),F=/Mobile/i.exec(e),D=!!/Win64/.exec(e),n){o=n[1]?parseFloat(n[1]):n[5]?parseFloat(n[5]):NaN,o&&document&&document.documentMode&&(o=document.documentMode);var r=/(?:Trident\/(\d+.\d+))/.exec(e);N=r?parseFloat(r[1])+4:o,f=n[2]?parseFloat(n[2]):NaN,s=n[3]?parseFloat(n[3]):NaN,u=n[4]?parseFloat(n[4]):NaN,u?(n=/(?:Chrome\/(\d+\.\d+))/.exec(e),d=n&&n[1]?parseFloat(n[1]):NaN):d=NaN;}else o=f=s=d=u=NaN;if(i){if(i[1]){var t=/(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(e);l=t?parseFloat(t[1].replace("_",".")):!0;}else l=!1;p=!!i[2],m=!!i[3];}else l=p=m=!1;}}var _={ie:function(){return a()||o},ieCompatibilityMode:function(){return a()||N>o},ie64:function(){return _.ie()&&D},firefox:function(){return a()||f},opera:function(){return a()||s},webkit:function(){return a()||u},safari:function(){return _.webkit()},chrome:function(){return a()||d},windows:function(){return a()||p},osx:function(){return a()||l},linux:function(){return a()||m},iphone:function(){return a()||x},mobile:function(){return a()||x||E||w||F},nativeApp:function(){return a()||M},android:function(){return a()||w},ipad:function(){return a()||E}},A=_;var c=!!(typeof window<"u"&&window.document&&window.document.createElement),U={canUseDOM:c,canUseWorkers:typeof Worker<"u",canUseEventListeners:c&&!!(window.addEventListener||window.attachEvent),canUseViewport:c&&!!window.screen,isInWorker:!c},h=U;var X;h.canUseDOM&&(X=document.implementation&&document.implementation.hasFeature&&document.implementation.hasFeature("","")!==!0);function S(e,n){if(!h.canUseDOM||n&&!("addEventListener"in document))return !1;var i="on"+e,r=i in document;if(!r){var t=document.createElement("div");t.setAttribute(i,"return;"),r=typeof t[i]=="function";}return !r&&X&&e==="wheel"&&(r=document.implementation.hasFeature("Events.wheel","3.0")),r}var b=S;var O=10,I=40,P=800;function T(e){var n=0,i=0,r=0,t=0;return "detail"in e&&(i=e.detail),"wheelDelta"in e&&(i=-e.wheelDelta/120),"wheelDeltaY"in e&&(i=-e.wheelDeltaY/120),"wheelDeltaX"in e&&(n=-e.wheelDeltaX/120),"axis"in e&&e.axis===e.HORIZONTAL_AXIS&&(n=i,i=0),r=n*O,t=i*O,"deltaY"in e&&(t=e.deltaY),"deltaX"in e&&(r=e.deltaX),(r||t)&&e.deltaMode&&(e.deltaMode==1?(r*=I,t*=I):(r*=P,t*=P)),r&&!n&&(n=r<1?-1:1),t&&!i&&(i=t<1?-1:1),{spinX:n,spinY:i,pixelX:r,pixelY:t}}T.getEventType=function(){return A.firefox()?"DOMMouseScroll":b("wheel")?"wheel":"mousewheel"};var Y=T;/**
   * Checks if an event is supported in the current execution environment.
   *
   * NOTE: This will not work correctly for non-generic events such as `change`,
   * `reset`, `load`, `error`, and `select`.
   *
   * Borrows from Modernizr.
   *
   * @param {string} eventNameSuffix Event name, e.g. "click".
   * @param {?boolean} capture Check if the capture phase is supported.
   * @return {boolean} True if the event is supported.
   * @internal
   * @license Modernizr 3.0.0pre (Custom Build) | MIT
   */

  const SCOPE$4 = "_Mousewheel";
  const mousewheel = function(element, callback) {
    if (element && element.addEventListener) {
      removeWheelHandler(element);
      const fn = function(event) {
        const normalized = Y(event);
        callback && Reflect.apply(callback, this, [event, normalized]);
      };
      element[SCOPE$4] = { wheelHandler: fn };
      element.addEventListener("wheel", fn, { passive: true });
    }
  };
  const removeWheelHandler = (element) => {
    var _a;
    if ((_a = element[SCOPE$4]) == null ? void 0 : _a.wheelHandler) {
      element.removeEventListener("wheel", element[SCOPE$4].wheelHandler);
      element[SCOPE$4] = null;
    }
  };
  const Mousewheel = {
    beforeMount(el, binding) {
      mousewheel(el, binding.value);
    },
    unmounted(el) {
      removeWheelHandler(el);
    },
    updated(el, binding) {
      if (binding.value !== binding.oldValue) {
        mousewheel(el, binding.value);
      }
    }
  };

  const basicTimeSpinnerProps = buildProps({
    role: {
      type: String,
      required: true
    },
    spinnerDate: {
      type: definePropType(Object),
      required: true
    },
    showSeconds: {
      type: Boolean,
      default: true
    },
    arrowControl: Boolean,
    amPmMode: {
      type: definePropType(String),
      default: ""
    },
    ...disabledTimeListsProps
  });

  const _sfc_main$23 = /* @__PURE__ */ vue.defineComponent({
    __name: "basic-time-spinner",
    props: basicTimeSpinnerProps,
    emits: [CHANGE_EVENT, "select-range", "set-option"],
    setup(__props, { emit }) {
      const props = __props;
      const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
      const { isRange, format } = pickerBase.props;
      const ns = useNamespace("time");
      const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
      let isScrolling = false;
      const currentScrollbar = vue.ref();
      const listHoursRef = vue.ref();
      const listMinutesRef = vue.ref();
      const listSecondsRef = vue.ref();
      const listRefsMap = {
        hours: listHoursRef,
        minutes: listMinutesRef,
        seconds: listSecondsRef
      };
      const spinnerItems = vue.computed(() => {
        return props.showSeconds ? timeUnits$1 : timeUnits$1.slice(0, 2);
      });
      const timePartials = vue.computed(() => {
        const { spinnerDate } = props;
        const hours = spinnerDate.hour();
        const minutes = spinnerDate.minute();
        const seconds = spinnerDate.second();
        return { hours, minutes, seconds };
      });
      const timeList = vue.computed(() => {
        const { hours, minutes } = vue.unref(timePartials);
        const { role, spinnerDate } = props;
        const compare = !isRange ? spinnerDate : void 0;
        return {
          hours: getHoursList(role, compare),
          minutes: getMinutesList(hours, role, compare),
          seconds: getSecondsList(hours, minutes, role, compare)
        };
      });
      const arrowControlTimeList = vue.computed(() => {
        const { hours, minutes, seconds } = vue.unref(timePartials);
        return {
          hours: buildTimeList(hours, 23),
          minutes: buildTimeList(minutes, 59),
          seconds: buildTimeList(seconds, 59)
        };
      });
      const debouncedResetScroll = debounce((type) => {
        isScrolling = false;
        adjustCurrentSpinner(type);
      }, 200);
      const getAmPmFlag = (hour) => {
        const shouldShowAmPm = !!props.amPmMode;
        if (!shouldShowAmPm)
          return "";
        const isCapital = props.amPmMode === "A";
        let content = hour < 12 ? " am" : " pm";
        if (isCapital)
          content = content.toUpperCase();
        return content;
      };
      const emitSelectRange = (type) => {
        let range = [0, 0];
        const actualFormat = format || DEFAULT_FORMATS_TIME;
        const hourIndex = actualFormat.indexOf("HH");
        const minuteIndex = actualFormat.indexOf("mm");
        const secondIndex = actualFormat.indexOf("ss");
        switch (type) {
          case "hours":
            if (hourIndex !== -1) {
              range = [hourIndex, hourIndex + 2];
            }
            break;
          case "minutes":
            if (minuteIndex !== -1) {
              range = [minuteIndex, minuteIndex + 2];
            }
            break;
          case "seconds":
            if (secondIndex !== -1) {
              range = [secondIndex, secondIndex + 2];
            }
            break;
        }
        const [left, right] = range;
        emit("select-range", left, right);
        currentScrollbar.value = type;
      };
      const adjustCurrentSpinner = (type) => {
        adjustSpinner(type, vue.unref(timePartials)[type]);
      };
      const adjustSpinners = () => {
        adjustCurrentSpinner("hours");
        adjustCurrentSpinner("minutes");
        adjustCurrentSpinner("seconds");
      };
      const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
      const adjustSpinner = (type, value) => {
        if (props.arrowControl)
          return;
        const scrollbar = vue.unref(listRefsMap[type]);
        if (scrollbar && scrollbar.$el) {
          getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type));
        }
      };
      const typeItemHeight = (type) => {
        const scrollbar = vue.unref(listRefsMap[type]);
        const listItem = scrollbar == null ? void 0 : scrollbar.$el.querySelector("li");
        if (listItem) {
          return Number.parseFloat(getStyle(listItem, "height")) || 0;
        }
        return 0;
      };
      const onIncrement = () => {
        scrollDown(1);
      };
      const onDecrement = () => {
        scrollDown(-1);
      };
      const scrollDown = (step) => {
        if (!currentScrollbar.value) {
          emitSelectRange("hours");
        }
        const label = currentScrollbar.value;
        const now = vue.unref(timePartials)[label];
        const total = currentScrollbar.value === "hours" ? 24 : 60;
        const next = findNextUnDisabled(label, now, step, total);
        modifyDateField(label, next);
        adjustSpinner(label, next);
        vue.nextTick(() => emitSelectRange(label));
      };
      const findNextUnDisabled = (type, now, step, total) => {
        let next = (now + step + total) % total;
        const list = vue.unref(timeList)[type];
        while (list[next] && next !== now) {
          next = (next + step + total) % total;
        }
        return next;
      };
      const modifyDateField = (type, value) => {
        const list = vue.unref(timeList)[type];
        const isDisabled = list[value];
        if (isDisabled)
          return;
        const { hours, minutes, seconds } = vue.unref(timePartials);
        let changeTo;
        switch (type) {
          case "hours":
            changeTo = props.spinnerDate.hour(value).minute(minutes).second(seconds);
            break;
          case "minutes":
            changeTo = props.spinnerDate.hour(hours).minute(value).second(seconds);
            break;
          case "seconds":
            changeTo = props.spinnerDate.hour(hours).minute(minutes).second(value);
            break;
        }
        emit(CHANGE_EVENT, changeTo);
      };
      const handleClick = (type, { value, disabled }) => {
        if (!disabled) {
          modifyDateField(type, value);
          emitSelectRange(type);
          adjustSpinner(type, value);
        }
      };
      const handleScroll = (type) => {
        const scrollbar = vue.unref(listRefsMap[type]);
        if (!scrollbar)
          return;
        isScrolling = true;
        debouncedResetScroll(type);
        const value = Math.min(Math.round((getScrollbarElement(scrollbar.$el).scrollTop - (scrollBarHeight(type) * 0.5 - 10) / typeItemHeight(type) + 3) / typeItemHeight(type)), type === "hours" ? 23 : 59);
        modifyDateField(type, value);
      };
      const scrollBarHeight = (type) => {
        return vue.unref(listRefsMap[type]).$el.offsetHeight;
      };
      const bindScrollEvent = () => {
        const bindFunction = (type) => {
          const scrollbar = vue.unref(listRefsMap[type]);
          if (scrollbar && scrollbar.$el) {
            getScrollbarElement(scrollbar.$el).onscroll = () => {
              handleScroll(type);
            };
          }
        };
        bindFunction("hours");
        bindFunction("minutes");
        bindFunction("seconds");
      };
      vue.onMounted(() => {
        vue.nextTick(() => {
          !props.arrowControl && bindScrollEvent();
          adjustSpinners();
          if (props.role === "start")
            emitSelectRange("hours");
        });
      });
      const setRef = (scrollbar, type) => {
        listRefsMap[type].value = scrollbar != null ? scrollbar : void 0;
      };
      emit("set-option", [`${props.role}_scrollDown`, scrollDown]);
      emit("set-option", [`${props.role}_emitSelectRange`, emitSelectRange]);
      vue.watch(() => props.spinnerDate, () => {
        if (isScrolling)
          return;
        adjustSpinners();
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }])
        }, [
          !_ctx.arrowControl ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(vue.unref(spinnerItems), (item) => {
            return vue.openBlock(), vue.createBlock(vue.unref(ElScrollbar), {
              key: item,
              ref_for: true,
              ref: (scrollbar) => setRef(scrollbar, item),
              class: vue.normalizeClass(vue.unref(ns).be("spinner", "wrapper")),
              "wrap-style": "max-height: inherit;",
              "view-class": vue.unref(ns).be("spinner", "list"),
              noresize: "",
              tag: "ul",
              onMouseenter: ($event) => emitSelectRange(item),
              onMousemove: ($event) => adjustCurrentSpinner(item)
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(timeList)[item], (disabled, key) => {
                  return vue.openBlock(), vue.createElementBlock("li", {
                    key,
                    class: vue.normalizeClass([
                      vue.unref(ns).be("spinner", "item"),
                      vue.unref(ns).is("active", key === vue.unref(timePartials)[item]),
                      vue.unref(ns).is("disabled", disabled)
                    ]),
                    onClick: ($event) => handleClick(item, { value: key, disabled })
                  }, [
                    item === "hours" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                      vue.createTextVNode(vue.toDisplayString(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + vue.toDisplayString(getAmPmFlag(key)), 1)
                    ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                      vue.createTextVNode(vue.toDisplayString(("0" + key).slice(-2)), 1)
                    ], 64))
                  ], 10, ["onClick"]);
                }), 128))
              ]),
              _: 2
            }, 1032, ["class", "view-class", "onMouseenter", "onMousemove"]);
          }), 128)) : vue.createCommentVNode("v-if", true),
          _ctx.arrowControl ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(vue.unref(spinnerItems), (item) => {
            return vue.openBlock(), vue.createElementBlock("div", {
              key: item,
              class: vue.normalizeClass([vue.unref(ns).be("spinner", "wrapper"), vue.unref(ns).is("arrow")]),
              onMouseenter: ($event) => emitSelectRange(item)
            }, [
              vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                class: vue.normalizeClass(["arrow-up", vue.unref(ns).be("spinner", "arrow")])
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(vue.unref(arrow_up_default))
                ]),
                _: 1
              }, 8, ["class"])), [
                [vue.unref(vRepeatClick), onDecrement]
              ]),
              vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                class: vue.normalizeClass(["arrow-down", vue.unref(ns).be("spinner", "arrow")])
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(vue.unref(arrow_down_default))
                ]),
                _: 1
              }, 8, ["class"])), [
                [vue.unref(vRepeatClick), onIncrement]
              ]),
              vue.createElementVNode("ul", {
                class: vue.normalizeClass(vue.unref(ns).be("spinner", "list"))
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(arrowControlTimeList)[item], (time, key) => {
                  return vue.openBlock(), vue.createElementBlock("li", {
                    key,
                    class: vue.normalizeClass([
                      vue.unref(ns).be("spinner", "item"),
                      vue.unref(ns).is("active", time === vue.unref(timePartials)[item]),
                      vue.unref(ns).is("disabled", vue.unref(timeList)[item][time])
                    ])
                  }, [
                    vue.unref(isNumber)(time) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                      item === "hours" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                        vue.createTextVNode(vue.toDisplayString(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + vue.toDisplayString(getAmPmFlag(time)), 1)
                      ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                        vue.createTextVNode(vue.toDisplayString(("0" + time).slice(-2)), 1)
                      ], 64))
                    ], 64)) : vue.createCommentVNode("v-if", true)
                  ], 2);
                }), 128))
              ], 2)
            ], 42, ["onMouseenter"]);
          }), 128)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var TimeSpinner = /* @__PURE__ */ _export_sfc(_sfc_main$23, [["__file", "basic-time-spinner.vue"]]);

  const _sfc_main$22 = /* @__PURE__ */ vue.defineComponent({
    __name: "panel-time-pick",
    props: panelTimePickerProps,
    emits: ["pick", "select-range", "set-picker-option"],
    setup(__props, { emit }) {
      const props = __props;
      const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
      const {
        arrowControl,
        disabledHours,
        disabledMinutes,
        disabledSeconds,
        defaultValue
      } = pickerBase.props;
      const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours, disabledMinutes, disabledSeconds);
      const ns = useNamespace("time");
      const { t, lang } = useLocale();
      const selectionRange = vue.ref([0, 2]);
      const oldValue = useOldValue(props);
      const transitionName = vue.computed(() => {
        return isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
      });
      const showSeconds = vue.computed(() => {
        return props.format.includes("ss");
      });
      const amPmMode = vue.computed(() => {
        if (props.format.includes("A"))
          return "A";
        if (props.format.includes("a"))
          return "a";
        return "";
      });
      const isValidValue = (_date) => {
        const parsedDate = dayjs(_date).locale(lang.value);
        const result = getRangeAvailableTime(parsedDate);
        return parsedDate.isSame(result);
      };
      const handleCancel = () => {
        const old = oldValue.value;
        emit("pick", old, false);
        vue.nextTick(() => {
          oldValue.value = old;
        });
      };
      const handleConfirm = (visible = false, first = false) => {
        if (first)
          return;
        emit("pick", props.parsedValue, visible);
      };
      const handleChange = (_date) => {
        if (!props.visible) {
          return;
        }
        const result = getRangeAvailableTime(_date).millisecond(0);
        emit("pick", result, true);
      };
      const setSelectionRange = (start, end) => {
        emit("select-range", start, end);
        selectionRange.value = [start, end];
      };
      const changeSelectionRange = (step) => {
        const actualFormat = props.format;
        const hourIndex = actualFormat.indexOf("HH");
        const minuteIndex = actualFormat.indexOf("mm");
        const secondIndex = actualFormat.indexOf("ss");
        const list = [];
        const mapping = [];
        if (hourIndex !== -1) {
          list.push(hourIndex);
          mapping.push("hours");
        }
        if (minuteIndex !== -1) {
          list.push(minuteIndex);
          mapping.push("minutes");
        }
        if (secondIndex !== -1 && showSeconds.value) {
          list.push(secondIndex);
          mapping.push("seconds");
        }
        const index = list.indexOf(selectionRange.value[0]);
        const next = (index + step + list.length) % list.length;
        timePickerOptions["start_emitSelectRange"](mapping[next]);
      };
      const handleKeydown = (event) => {
        const code = getEventCode(event);
        const { left, right, up, down } = EVENT_CODE;
        if ([left, right].includes(code)) {
          const step = code === left ? -1 : 1;
          changeSelectionRange(step);
          event.preventDefault();
          return;
        }
        if ([up, down].includes(code)) {
          const step = code === up ? -1 : 1;
          timePickerOptions["start_scrollDown"](step);
          event.preventDefault();
          return;
        }
      };
      const { timePickerOptions, onSetOption, getAvailableTime } = useTimePanel({
        getAvailableHours,
        getAvailableMinutes,
        getAvailableSeconds
      });
      const getRangeAvailableTime = (date) => {
        return getAvailableTime(date, props.datetimeRole || "", true);
      };
      const parseUserInput = (value) => {
        if (!value)
          return null;
        return dayjs(value, props.format).locale(lang.value);
      };
      const getDefaultValue = () => {
        return dayjs(defaultValue).locale(lang.value);
      };
      emit("set-picker-option", ["isValidValue", isValidValue]);
      emit("set-picker-option", ["parseUserInput", parseUserInput]);
      emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
      emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
      emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, { name: vue.unref(transitionName) }, {
          default: vue.withCtx(() => [
            _ctx.actualVisible || _ctx.visible ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).b("panel"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass([vue.unref(ns).be("panel", "content"), { "has-seconds": vue.unref(showSeconds) }])
              }, [
                vue.createVNode(TimeSpinner, {
                  ref: "spinner",
                  role: _ctx.datetimeRole || "start",
                  "arrow-control": vue.unref(arrowControl),
                  "show-seconds": vue.unref(showSeconds),
                  "am-pm-mode": vue.unref(amPmMode),
                  "spinner-date": _ctx.parsedValue,
                  "disabled-hours": vue.unref(disabledHours),
                  "disabled-minutes": vue.unref(disabledMinutes),
                  "disabled-seconds": vue.unref(disabledSeconds),
                  onChange: handleChange,
                  onSetOption: vue.unref(onSetOption),
                  onSelectRange: setSelectionRange
                }, null, 8, ["role", "arrow-control", "show-seconds", "am-pm-mode", "spinner-date", "disabled-hours", "disabled-minutes", "disabled-seconds", "onSetOption"])
              ], 2),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).be("panel", "footer"))
              }, [
                vue.createElementVNode("button", {
                  type: "button",
                  class: vue.normalizeClass([vue.unref(ns).be("panel", "btn"), "cancel"]),
                  onClick: handleCancel
                }, vue.toDisplayString(vue.unref(t)("el.datepicker.cancel")), 3),
                vue.createElementVNode("button", {
                  type: "button",
                  class: vue.normalizeClass([vue.unref(ns).be("panel", "btn"), "confirm"]),
                  onClick: ($event) => handleConfirm()
                }, vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 11, ["onClick"])
              ], 2)
            ], 2)) : vue.createCommentVNode("v-if", true)
          ]),
          _: 1
        }, 8, ["name"]);
      };
    }
  });
  var TimePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$22, [["__file", "panel-time-pick.vue"]]);

  const panelTimeRangeProps = buildProps({
    ...timePanelSharedProps,
    parsedValue: {
      type: definePropType(Array)
    }
  });

  const _sfc_main$21 = /* @__PURE__ */ vue.defineComponent({
    __name: "panel-time-range",
    props: panelTimeRangeProps,
    emits: ["pick", "select-range", "set-picker-option"],
    setup(__props, { emit }) {
      const props = __props;
      const makeSelectRange = (start, end) => {
        const result = [];
        for (let i = start; i <= end; i++) {
          result.push(i);
        }
        return result;
      };
      const { t, lang } = useLocale();
      const nsTime = useNamespace("time");
      const nsPicker = useNamespace("picker");
      const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
      const {
        arrowControl,
        disabledHours,
        disabledMinutes,
        disabledSeconds,
        defaultValue
      } = pickerBase.props;
      const startContainerKls = vue.computed(() => [
        nsTime.be("range-picker", "body"),
        nsTime.be("panel", "content"),
        nsTime.is("arrow", arrowControl),
        showSeconds.value ? "has-seconds" : ""
      ]);
      const endContainerKls = vue.computed(() => [
        nsTime.be("range-picker", "body"),
        nsTime.be("panel", "content"),
        nsTime.is("arrow", arrowControl),
        showSeconds.value ? "has-seconds" : ""
      ]);
      const startTime = vue.computed(() => props.parsedValue[0]);
      const endTime = vue.computed(() => props.parsedValue[1]);
      const oldValue = useOldValue(props);
      const handleCancel = () => {
        const old = oldValue.value;
        emit("pick", old, false);
        vue.nextTick(() => {
          oldValue.value = old;
        });
      };
      const showSeconds = vue.computed(() => {
        return props.format.includes("ss");
      });
      const amPmMode = vue.computed(() => {
        if (props.format.includes("A"))
          return "A";
        if (props.format.includes("a"))
          return "a";
        return "";
      });
      const handleConfirm = (visible = false) => {
        emit("pick", [startTime.value, endTime.value], visible);
      };
      const handleMinChange = (date) => {
        handleChange(date.millisecond(0), endTime.value);
      };
      const handleMaxChange = (date) => {
        handleChange(startTime.value, date.millisecond(0));
      };
      const isValidValue = (_date) => {
        const parsedDate = _date.map((_) => dayjs(_).locale(lang.value));
        const result = getRangeAvailableTime(parsedDate);
        return parsedDate[0].isSame(result[0]) && parsedDate[1].isSame(result[1]);
      };
      const handleChange = (start, end) => {
        if (!props.visible) {
          return;
        }
        emit("pick", [start, end], true);
      };
      const btnConfirmDisabled = vue.computed(() => {
        return startTime.value > endTime.value;
      });
      const selectionRange = vue.ref([0, 2]);
      const setMinSelectionRange = (start, end) => {
        emit("select-range", start, end, "min");
        selectionRange.value = [start, end];
      };
      const offset = vue.computed(() => showSeconds.value ? 11 : 8);
      const setMaxSelectionRange = (start, end) => {
        emit("select-range", start, end, "max");
        const _offset = vue.unref(offset);
        selectionRange.value = [start + _offset, end + _offset];
      };
      const changeSelectionRange = (step) => {
        const list = showSeconds.value ? [0, 3, 6, 11, 14, 17] : [0, 3, 8, 11];
        const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
        const index = list.indexOf(selectionRange.value[0]);
        const next = (index + step + list.length) % list.length;
        const half = list.length / 2;
        if (next < half) {
          timePickerOptions["start_emitSelectRange"](mapping[next]);
        } else {
          timePickerOptions["end_emitSelectRange"](mapping[next - half]);
        }
      };
      const handleKeydown = (event) => {
        const code = getEventCode(event);
        const { left, right, up, down } = EVENT_CODE;
        if ([left, right].includes(code)) {
          const step = code === left ? -1 : 1;
          changeSelectionRange(step);
          event.preventDefault();
          return;
        }
        if ([up, down].includes(code)) {
          const step = code === up ? -1 : 1;
          const role = selectionRange.value[0] < offset.value ? "start" : "end";
          timePickerOptions[`${role}_scrollDown`](step);
          event.preventDefault();
          return;
        }
      };
      const disabledHours_ = (role, compare) => {
        const defaultDisable = disabledHours ? disabledHours(role) : [];
        const isStart = role === "start";
        const compareDate = compare || (isStart ? endTime.value : startTime.value);
        const compareHour = compareDate.hour();
        const nextDisable = isStart ? makeSelectRange(compareHour + 1, 23) : makeSelectRange(0, compareHour - 1);
        return union(defaultDisable, nextDisable);
      };
      const disabledMinutes_ = (hour, role, compare) => {
        const defaultDisable = disabledMinutes ? disabledMinutes(hour, role) : [];
        const isStart = role === "start";
        const compareDate = compare || (isStart ? endTime.value : startTime.value);
        const compareHour = compareDate.hour();
        if (hour !== compareHour) {
          return defaultDisable;
        }
        const compareMinute = compareDate.minute();
        const nextDisable = isStart ? makeSelectRange(compareMinute + 1, 59) : makeSelectRange(0, compareMinute - 1);
        return union(defaultDisable, nextDisable);
      };
      const disabledSeconds_ = (hour, minute, role, compare) => {
        const defaultDisable = disabledSeconds ? disabledSeconds(hour, minute, role) : [];
        const isStart = role === "start";
        const compareDate = compare || (isStart ? endTime.value : startTime.value);
        const compareHour = compareDate.hour();
        const compareMinute = compareDate.minute();
        if (hour !== compareHour || minute !== compareMinute) {
          return defaultDisable;
        }
        const compareSecond = compareDate.second();
        const nextDisable = isStart ? makeSelectRange(compareSecond + 1, 59) : makeSelectRange(0, compareSecond - 1);
        return union(defaultDisable, nextDisable);
      };
      const getRangeAvailableTime = ([start, end]) => {
        return [
          getAvailableTime(start, "start", true, end),
          getAvailableTime(end, "end", false, start)
        ];
      };
      const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours_, disabledMinutes_, disabledSeconds_);
      const {
        timePickerOptions,
        getAvailableTime,
        onSetOption
      } = useTimePanel({
        getAvailableHours,
        getAvailableMinutes,
        getAvailableSeconds
      });
      const parseUserInput = (days) => {
        if (!days)
          return null;
        if (isArray$1(days)) {
          return days.map((d) => dayjs(d, props.format).locale(lang.value));
        }
        return dayjs(days, props.format).locale(lang.value);
      };
      const getDefaultValue = () => {
        if (isArray$1(defaultValue)) {
          return defaultValue.map((d) => dayjs(d).locale(lang.value));
        }
        const defaultDay = dayjs(defaultValue).locale(lang.value);
        return [defaultDay, defaultDay.add(60, "m")];
      };
      emit("set-picker-option", ["parseUserInput", parseUserInput]);
      emit("set-picker-option", ["isValidValue", isValidValue]);
      emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
      emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
      emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
      return (_ctx, _cache) => {
        return _ctx.actualVisible ? (vue.openBlock(), vue.createElementBlock("div", {
          key: 0,
          class: vue.normalizeClass([vue.unref(nsTime).b("range-picker"), vue.unref(nsPicker).b("panel")])
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "content"))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "cell"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "header"))
              }, vue.toDisplayString(vue.unref(t)("el.datepicker.startTime")), 3),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(startContainerKls))
              }, [
                vue.createVNode(TimeSpinner, {
                  ref: "minSpinner",
                  role: "start",
                  "show-seconds": vue.unref(showSeconds),
                  "am-pm-mode": vue.unref(amPmMode),
                  "arrow-control": vue.unref(arrowControl),
                  "spinner-date": vue.unref(startTime),
                  "disabled-hours": disabledHours_,
                  "disabled-minutes": disabledMinutes_,
                  "disabled-seconds": disabledSeconds_,
                  onChange: handleMinChange,
                  onSetOption: vue.unref(onSetOption),
                  onSelectRange: setMinSelectionRange
                }, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
              ], 2)
            ], 2),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "cell"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "header"))
              }, vue.toDisplayString(vue.unref(t)("el.datepicker.endTime")), 3),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(endContainerKls))
              }, [
                vue.createVNode(TimeSpinner, {
                  ref: "maxSpinner",
                  role: "end",
                  "show-seconds": vue.unref(showSeconds),
                  "am-pm-mode": vue.unref(amPmMode),
                  "arrow-control": vue.unref(arrowControl),
                  "spinner-date": vue.unref(endTime),
                  "disabled-hours": disabledHours_,
                  "disabled-minutes": disabledMinutes_,
                  "disabled-seconds": disabledSeconds_,
                  onChange: handleMaxChange,
                  onSetOption: vue.unref(onSetOption),
                  onSelectRange: setMaxSelectionRange
                }, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
              ], 2)
            ], 2)
          ], 2),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(nsTime).be("panel", "footer"))
          }, [
            vue.createElementVNode("button", {
              type: "button",
              class: vue.normalizeClass([vue.unref(nsTime).be("panel", "btn"), "cancel"]),
              onClick: ($event) => handleCancel()
            }, vue.toDisplayString(vue.unref(t)("el.datepicker.cancel")), 11, ["onClick"]),
            vue.createElementVNode("button", {
              type: "button",
              class: vue.normalizeClass([vue.unref(nsTime).be("panel", "btn"), "confirm"]),
              disabled: vue.unref(btnConfirmDisabled),
              onClick: ($event) => handleConfirm()
            }, vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 11, ["disabled", "onClick"])
          ], 2)
        ], 2)) : vue.createCommentVNode("v-if", true);
      };
    }
  });
  var TimeRangePanel = /* @__PURE__ */ _export_sfc(_sfc_main$21, [["__file", "panel-time-range.vue"]]);

  dayjs.extend(customParseFormat);
  var TimePicker = vue.defineComponent({
    name: "ElTimePicker",
    install: null,
    props: {
      ...timePickerDefaultProps,
      isRange: Boolean
    },
    emits: [UPDATE_MODEL_EVENT],
    setup(props, ctx) {
      const commonPicker = vue.ref();
      const [type, Panel] = props.isRange ? ["timerange", TimeRangePanel] : ["time", TimePickPanel];
      const modelUpdater = (value) => ctx.emit(UPDATE_MODEL_EVENT, value);
      vue.provide(PICKER_POPPER_OPTIONS_INJECTION_KEY, props.popperOptions);
      ctx.expose({
        focus: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.focus();
        },
        blur: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.blur();
        },
        handleOpen: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.handleOpen();
        },
        handleClose: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.handleClose();
        }
      });
      return () => {
        var _a;
        const format = (_a = props.format) != null ? _a : DEFAULT_FORMATS_TIME;
        return vue.createVNode(CommonPicker, vue.mergeProps(props, {
          "ref": commonPicker,
          "type": type,
          "format": format,
          "onUpdate:modelValue": modelUpdater
        }), {
          default: (props2) => vue.createVNode(Panel, props2, null)
        });
      };
    }
  });

  const ElTimePicker = withInstall(TimePicker);

  const getPrevMonthLastDays = (date, count) => {
    const lastDay = date.subtract(1, "month").endOf("month").date();
    return rangeArr(count).map((_, index) => lastDay - (count - index - 1));
  };
  const getMonthDays = (date) => {
    const days = date.daysInMonth();
    return rangeArr(days).map((_, index) => index + 1);
  };
  const toNestedArr = (days) => rangeArr(days.length / 7).map((index) => {
    const start = index * 7;
    return days.slice(start, start + 7);
  });
  const dateTableProps = buildProps({
    selectedDay: {
      type: definePropType(Object)
    },
    range: {
      type: definePropType(Array)
    },
    date: {
      type: definePropType(Object),
      required: true
    },
    hideHeader: {
      type: Boolean
    }
  });
  const dateTableEmits = {
    pick: (value) => isObject$1(value)
  };

  var localeData$1 = {exports: {}};

  (function(module, exports) {
    !function(n, e) {
      module.exports = e() ;
    }(commonjsGlobal, function() {
      return function(n, e, t) {
        var r = e.prototype, o = function(n2) {
          return n2 && (n2.indexOf ? n2 : n2.s);
        }, u = function(n2, e2, t2, r2, u2) {
          var i2 = n2.name ? n2 : n2.$locale(), a2 = o(i2[e2]), s2 = o(i2[t2]), f = a2 || s2.map(function(n3) {
            return n3.slice(0, r2);
          });
          if (!u2)
            return f;
          var d = i2.weekStart;
          return f.map(function(n3, e3) {
            return f[(e3 + (d || 0)) % 7];
          });
        }, i = function() {
          return t.Ls[t.locale()];
        }, a = function(n2, e2) {
          return n2.formats[e2] || function(n3) {
            return n3.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(n4, e3, t2) {
              return e3 || t2.slice(1);
            });
          }(n2.formats[e2.toUpperCase()]);
        }, s = function() {
          var n2 = this;
          return { months: function(e2) {
            return e2 ? e2.format("MMMM") : u(n2, "months");
          }, monthsShort: function(e2) {
            return e2 ? e2.format("MMM") : u(n2, "monthsShort", "months", 3);
          }, firstDayOfWeek: function() {
            return n2.$locale().weekStart || 0;
          }, weekdays: function(e2) {
            return e2 ? e2.format("dddd") : u(n2, "weekdays");
          }, weekdaysMin: function(e2) {
            return e2 ? e2.format("dd") : u(n2, "weekdaysMin", "weekdays", 2);
          }, weekdaysShort: function(e2) {
            return e2 ? e2.format("ddd") : u(n2, "weekdaysShort", "weekdays", 3);
          }, longDateFormat: function(e2) {
            return a(n2.$locale(), e2);
          }, meridiem: this.$locale().meridiem, ordinal: this.$locale().ordinal };
        };
        r.localeData = function() {
          return s.bind(this)();
        }, t.localeData = function() {
          var n2 = i();
          return { firstDayOfWeek: function() {
            return n2.weekStart || 0;
          }, weekdays: function() {
            return t.weekdays();
          }, weekdaysShort: function() {
            return t.weekdaysShort();
          }, weekdaysMin: function() {
            return t.weekdaysMin();
          }, months: function() {
            return t.months();
          }, monthsShort: function() {
            return t.monthsShort();
          }, longDateFormat: function(e2) {
            return a(n2, e2);
          }, meridiem: n2.meridiem, ordinal: n2.ordinal };
        }, t.months = function() {
          return u(i(), "months");
        }, t.monthsShort = function() {
          return u(i(), "monthsShort", "months", 3);
        }, t.weekdays = function(n2) {
          return u(i(), "weekdays", null, null, n2);
        }, t.weekdaysShort = function(n2) {
          return u(i(), "weekdaysShort", "weekdays", 3, n2);
        }, t.weekdaysMin = function(n2) {
          return u(i(), "weekdaysMin", "weekdays", 2, n2);
        };
      };
    });
  })(localeData$1);
  var localeData = localeData$1.exports;

  const useDateTable = (props, emit) => {
    dayjs.extend(localeData);
    const firstDayOfWeek = dayjs.localeData().firstDayOfWeek();
    const { t, lang } = useLocale();
    const now = dayjs().locale(lang.value);
    const isInRange = vue.computed(() => !!props.range && !!props.range.length);
    const rows = vue.computed(() => {
      let days = [];
      if (isInRange.value) {
        const [start, end] = props.range;
        const currentMonthRange = rangeArr(end.date() - start.date() + 1).map((index) => ({
          text: start.date() + index,
          type: "current"
        }));
        let remaining = currentMonthRange.length % 7;
        remaining = remaining === 0 ? 0 : 7 - remaining;
        const nextMonthRange = rangeArr(remaining).map((_, index) => ({
          text: index + 1,
          type: "next"
        }));
        days = currentMonthRange.concat(nextMonthRange);
      } else {
        const firstDay = props.date.startOf("month").day();
        const prevMonthDays = getPrevMonthLastDays(props.date, (firstDay - firstDayOfWeek + 7) % 7).map((day) => ({
          text: day,
          type: "prev"
        }));
        const currentMonthDays = getMonthDays(props.date).map((day) => ({
          text: day,
          type: "current"
        }));
        days = [...prevMonthDays, ...currentMonthDays];
        const remaining = 7 - (days.length % 7 || 7);
        const nextMonthDays = rangeArr(remaining).map((_, index) => ({
          text: index + 1,
          type: "next"
        }));
        days = days.concat(nextMonthDays);
      }
      return toNestedArr(days);
    });
    const weekDays = vue.computed(() => {
      const start = firstDayOfWeek;
      if (start === 0) {
        return WEEK_DAYS.map((_) => t(`el.datepicker.weeks.${_}`));
      } else {
        return WEEK_DAYS.slice(start).concat(WEEK_DAYS.slice(0, start)).map((_) => t(`el.datepicker.weeks.${_}`));
      }
    });
    const getFormattedDate = (day, type) => {
      switch (type) {
        case "prev":
          return props.date.startOf("month").subtract(1, "month").date(day);
        case "next":
          return props.date.startOf("month").add(1, "month").date(day);
        case "current":
          return props.date.date(day);
      }
    };
    const handlePickDay = ({ text, type }) => {
      const date = getFormattedDate(text, type);
      emit("pick", date);
    };
    const getSlotData = ({ text, type }) => {
      const day = getFormattedDate(text, type);
      return {
        isSelected: day.isSame(props.selectedDay),
        type: `${type}-month`,
        day: day.format("YYYY-MM-DD"),
        date: day.toDate()
      };
    };
    return {
      now,
      isInRange,
      rows,
      weekDays,
      getFormattedDate,
      handlePickDay,
      getSlotData
    };
  };

  const __default__$1A = vue.defineComponent({
    name: "DateTable"
  });
  const _sfc_main$20 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1A,
    props: dateTableProps,
    emits: dateTableEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const {
        isInRange,
        now,
        rows,
        weekDays,
        getFormattedDate,
        handlePickDay,
        getSlotData
      } = useDateTable(props, emit);
      const nsTable = useNamespace("calendar-table");
      const nsDay = useNamespace("calendar-day");
      const getCellClass = ({ text, type }) => {
        const classes = [type];
        if (type === "current") {
          const date = getFormattedDate(text, type);
          if (date.isSame(props.selectedDay, "day")) {
            classes.push(nsDay.is("selected"));
          }
          if (date.isSame(now, "day")) {
            classes.push(nsDay.is("today"));
          }
        }
        return classes;
      };
      expose({
        getFormattedDate
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("table", {
          class: vue.normalizeClass([vue.unref(nsTable).b(), vue.unref(nsTable).is("range", vue.unref(isInRange))]),
          cellspacing: "0",
          cellpadding: "0"
        }, [
          !_ctx.hideHeader ? (vue.openBlock(), vue.createElementBlock("thead", { key: 0 }, [
            vue.createElementVNode("tr", null, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(weekDays), (day) => {
                return vue.openBlock(), vue.createElementBlock("th", {
                  key: day,
                  scope: "col"
                }, vue.toDisplayString(day), 1);
              }), 128))
            ])
          ])) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("tbody", null, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, index) => {
              return vue.openBlock(), vue.createElementBlock("tr", {
                key: index,
                class: vue.normalizeClass({
                  [vue.unref(nsTable).e("row")]: true,
                  [vue.unref(nsTable).em("row", "hide-border")]: index === 0 && _ctx.hideHeader
                })
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, key) => {
                  return vue.openBlock(), vue.createElementBlock("td", {
                    key,
                    class: vue.normalizeClass(getCellClass(cell)),
                    onClick: ($event) => vue.unref(handlePickDay)(cell)
                  }, [
                    vue.createElementVNode("div", {
                      class: vue.normalizeClass(vue.unref(nsDay).b())
                    }, [
                      vue.renderSlot(_ctx.$slots, "date-cell", {
                        data: vue.unref(getSlotData)(cell)
                      }, () => [
                        vue.createElementVNode("span", null, vue.toDisplayString(cell.text), 1)
                      ])
                    ], 2)
                  ], 10, ["onClick"]);
                }), 128))
              ], 2);
            }), 128))
          ])
        ], 2);
      };
    }
  });
  var DateTable$1 = /* @__PURE__ */ _export_sfc(_sfc_main$20, [["__file", "date-table.vue"]]);

  const adjacentMonth = (start, end) => {
    const firstMonthLastDay = start.endOf("month");
    const lastMonthFirstDay = end.startOf("month");
    const isSameWeek = firstMonthLastDay.isSame(lastMonthFirstDay, "week");
    const lastMonthStartDay = isSameWeek ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
    return [
      [start, firstMonthLastDay],
      [lastMonthStartDay.startOf("week"), end]
    ];
  };
  const threeConsecutiveMonth = (start, end) => {
    const firstMonthLastDay = start.endOf("month");
    const secondMonthFirstDay = start.add(1, "month").startOf("month");
    const secondMonthStartDay = firstMonthLastDay.isSame(secondMonthFirstDay, "week") ? secondMonthFirstDay.add(1, "week") : secondMonthFirstDay;
    const secondMonthLastDay = secondMonthStartDay.endOf("month");
    const lastMonthFirstDay = end.startOf("month");
    const lastMonthStartDay = secondMonthLastDay.isSame(lastMonthFirstDay, "week") ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
    return [
      [start, firstMonthLastDay],
      [secondMonthStartDay.startOf("week"), secondMonthLastDay],
      [lastMonthStartDay.startOf("week"), end]
    ];
  };
  const useCalendar = (props, emit, componentName) => {
    const { lang } = useLocale();
    const selectedDay = vue.ref();
    const now = dayjs().locale(lang.value);
    const realSelectedDay = vue.computed({
      get() {
        if (!props.modelValue)
          return selectedDay.value;
        return date.value;
      },
      set(val) {
        if (!val)
          return;
        selectedDay.value = val;
        const result = val.toDate();
        emit(INPUT_EVENT, result);
        emit(UPDATE_MODEL_EVENT, result);
      }
    });
    const validatedRange = vue.computed(() => {
      if (!props.range || !isArray$1(props.range) || props.range.length !== 2 || props.range.some((item) => !isDate$1(item)))
        return [];
      const rangeArrDayjs = props.range.map((_) => dayjs(_).locale(lang.value));
      const [startDayjs, endDayjs] = rangeArrDayjs;
      if (startDayjs.isAfter(endDayjs)) {
        debugWarn(componentName, "end time should be greater than start time");
        return [];
      }
      if (startDayjs.isSame(endDayjs, "month")) {
        return calculateValidatedDateRange(startDayjs, endDayjs);
      } else {
        if (startDayjs.add(1, "month").month() !== endDayjs.month()) {
          debugWarn(componentName, "start time and end time interval must not exceed two months");
          return [];
        }
        return calculateValidatedDateRange(startDayjs, endDayjs);
      }
    });
    const date = vue.computed(() => {
      if (!props.modelValue) {
        return realSelectedDay.value || (validatedRange.value.length ? validatedRange.value[0][0] : now);
      } else {
        return dayjs(props.modelValue).locale(lang.value);
      }
    });
    const prevMonthDayjs = vue.computed(() => date.value.subtract(1, "month").date(1));
    const nextMonthDayjs = vue.computed(() => date.value.add(1, "month").date(1));
    const prevYearDayjs = vue.computed(() => date.value.subtract(1, "year").date(1));
    const nextYearDayjs = vue.computed(() => date.value.add(1, "year").date(1));
    const calculateValidatedDateRange = (startDayjs, endDayjs) => {
      const firstDay = startDayjs.startOf("week");
      const lastDay = endDayjs.endOf("week");
      const firstMonth = firstDay.get("month");
      const lastMonth = lastDay.get("month");
      if (firstMonth === lastMonth) {
        return [[firstDay, lastDay]];
      } else if ((firstMonth + 1) % 12 === lastMonth) {
        return adjacentMonth(firstDay, lastDay);
      } else if (firstMonth + 2 === lastMonth || (firstMonth + 1) % 11 === lastMonth) {
        return threeConsecutiveMonth(firstDay, lastDay);
      } else {
        debugWarn(componentName, "start time and end time interval must not exceed two months");
        return [];
      }
    };
    const pickDay = (day) => {
      realSelectedDay.value = day;
    };
    const selectDate = (type) => {
      const dateMap = {
        "prev-month": prevMonthDayjs.value,
        "next-month": nextMonthDayjs.value,
        "prev-year": prevYearDayjs.value,
        "next-year": nextYearDayjs.value,
        today: now
      };
      const day = dateMap[type];
      if (!day.isSame(date.value, "day")) {
        pickDay(day);
      }
    };
    return {
      calculateValidatedDateRange,
      date,
      realSelectedDay,
      pickDay,
      selectDate,
      validatedRange
    };
  };

  const isValidRange$1 = (range) => isArray$1(range) && range.length === 2 && range.every((item) => isDate$1(item));
  const calendarProps = buildProps({
    modelValue: {
      type: Date
    },
    range: {
      type: definePropType(Array),
      validator: isValidRange$1
    }
  });
  const calendarEmits = {
    [UPDATE_MODEL_EVENT]: (value) => isDate$1(value),
    [INPUT_EVENT]: (value) => isDate$1(value)
  };

  const COMPONENT_NAME$h = "ElCalendar";
  const __default__$1z = vue.defineComponent({
    name: COMPONENT_NAME$h
  });
  const _sfc_main$1$ = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1z,
    props: calendarProps,
    emits: calendarEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("calendar");
      const {
        calculateValidatedDateRange,
        date,
        pickDay,
        realSelectedDay,
        selectDate,
        validatedRange
      } = useCalendar(props, emit, COMPONENT_NAME$h);
      const { t } = useLocale();
      const i18nDate = vue.computed(() => {
        const pickedMonth = `el.datepicker.month${date.value.format("M")}`;
        return `${date.value.year()} ${t("el.datepicker.year")} ${t(pickedMonth)}`;
      });
      expose({
        selectedDay: realSelectedDay,
        pickDay,
        selectDate,
        calculateValidatedDateRange
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("header"))
          }, [
            vue.renderSlot(_ctx.$slots, "header", { date: vue.unref(i18nDate) }, () => [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("title"))
              }, vue.toDisplayString(vue.unref(i18nDate)), 3),
              vue.unref(validatedRange).length === 0 ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("button-group"))
              }, [
                vue.createVNode(vue.unref(ElButtonGroup$1), null, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(ElButton), {
                      size: "small",
                      onClick: ($event) => vue.unref(selectDate)("prev-month")
                    }, {
                      default: vue.withCtx(() => [
                        vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.prevMonth")), 1)
                      ]),
                      _: 1
                    }, 8, ["onClick"]),
                    vue.createVNode(vue.unref(ElButton), {
                      size: "small",
                      onClick: ($event) => vue.unref(selectDate)("today")
                    }, {
                      default: vue.withCtx(() => [
                        vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.today")), 1)
                      ]),
                      _: 1
                    }, 8, ["onClick"]),
                    vue.createVNode(vue.unref(ElButton), {
                      size: "small",
                      onClick: ($event) => vue.unref(selectDate)("next-month")
                    }, {
                      default: vue.withCtx(() => [
                        vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.nextMonth")), 1)
                      ]),
                      _: 1
                    }, 8, ["onClick"])
                  ]),
                  _: 1
                })
              ], 2)) : vue.createCommentVNode("v-if", true)
            ])
          ], 2),
          vue.unref(validatedRange).length === 0 ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("body"))
          }, [
            vue.createVNode(DateTable$1, {
              date: vue.unref(date),
              "selected-day": vue.unref(realSelectedDay),
              onPick: vue.unref(pickDay)
            }, vue.createSlots({
              _: 2
            }, [
              _ctx.$slots["date-cell"] ? {
                name: "date-cell",
                fn: vue.withCtx((data) => [
                  vue.renderSlot(_ctx.$slots, "date-cell", vue.normalizeProps(vue.guardReactiveProps(data)))
                ])
              } : void 0
            ]), 1032, ["date", "selected-day", "onPick"])
          ], 2)) : (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("body"))
          }, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(validatedRange), (range_, index) => {
              return vue.openBlock(), vue.createBlock(DateTable$1, {
                key: index,
                date: range_[0],
                "selected-day": vue.unref(realSelectedDay),
                range: range_,
                "hide-header": index !== 0,
                onPick: vue.unref(pickDay)
              }, vue.createSlots({
                _: 2
              }, [
                _ctx.$slots["date-cell"] ? {
                  name: "date-cell",
                  fn: vue.withCtx((data) => [
                    vue.renderSlot(_ctx.$slots, "date-cell", vue.normalizeProps(vue.guardReactiveProps(data)))
                  ])
                } : void 0
              ]), 1032, ["date", "selected-day", "range", "hide-header", "onPick"]);
            }), 128))
          ], 2))
        ], 2);
      };
    }
  });
  var Calendar = /* @__PURE__ */ _export_sfc(_sfc_main$1$, [["__file", "calendar.vue"]]);

  const ElCalendar = withInstall(Calendar);

  const cardProps = buildProps({
    header: {
      type: String,
      default: ""
    },
    footer: {
      type: String,
      default: ""
    },
    bodyStyle: {
      type: definePropType([String, Object, Array]),
      default: ""
    },
    headerClass: String,
    bodyClass: String,
    footerClass: String,
    shadow: {
      type: String,
      values: ["always", "hover", "never"],
      default: void 0
    }
  });
  const cardContextKey = Symbol("cardContextKey");

  const __default__$1y = vue.defineComponent({
    name: "ElCard"
  });
  const _sfc_main$1_ = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1y,
    props: cardProps,
    setup(__props) {
      const globalConfig = useGlobalConfig("card");
      const ns = useNamespace("card");
      return (_ctx, _cache) => {
        var _a;
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ns).b(),
            vue.unref(ns).is(`${_ctx.shadow || ((_a = vue.unref(globalConfig)) == null ? void 0 : _a.shadow) || "always"}-shadow`)
          ])
        }, [
          _ctx.$slots.header || _ctx.header ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass([vue.unref(ns).e("header"), _ctx.headerClass])
          }, [
            vue.renderSlot(_ctx.$slots, "header", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.header), 1)
            ])
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass([vue.unref(ns).e("body"), _ctx.bodyClass]),
            style: vue.normalizeStyle(_ctx.bodyStyle)
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 6),
          _ctx.$slots.footer || _ctx.footer ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass([vue.unref(ns).e("footer"), _ctx.footerClass])
          }, [
            vue.renderSlot(_ctx.$slots, "footer", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.footer), 1)
            ])
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var Card = /* @__PURE__ */ _export_sfc(_sfc_main$1_, [["__file", "card.vue"]]);

  const ElCard = withInstall(Card);

  const carouselProps = buildProps({
    initialIndex: {
      type: Number,
      default: 0
    },
    height: {
      type: String,
      default: ""
    },
    trigger: {
      type: String,
      values: ["hover", "click"],
      default: "hover"
    },
    autoplay: {
      type: Boolean,
      default: true
    },
    interval: {
      type: Number,
      default: 3e3
    },
    indicatorPosition: {
      type: String,
      values: ["", "none", "outside"],
      default: ""
    },
    arrow: {
      type: String,
      values: ["always", "hover", "never"],
      default: "hover"
    },
    type: {
      type: String,
      values: ["", "card"],
      default: ""
    },
    cardScale: {
      type: Number,
      default: 0.83
    },
    loop: {
      type: Boolean,
      default: true
    },
    direction: {
      type: String,
      values: ["horizontal", "vertical"],
      default: "horizontal"
    },
    pauseOnHover: {
      type: Boolean,
      default: true
    },
    motionBlur: Boolean
  });
  const carouselEmits = {
    change: (current, prev) => [current, prev].every(isNumber)
  };

  const carouselContextKey = Symbol("carouselContextKey");
  const CAROUSEL_ITEM_NAME = "ElCarouselItem";

  const THROTTLE_TIME = 300;
  const useCarousel = (props, emit, componentName) => {
    const {
      children: items,
      addChild: addItem,
      removeChild: removeItem,
      ChildrenSorter: ItemsSorter
    } = useOrderedChildren(vue.getCurrentInstance(), CAROUSEL_ITEM_NAME);
    const slots = vue.useSlots();
    const activeIndex = vue.ref(-1);
    const timer = vue.ref(null);
    const hover = vue.ref(false);
    const root = vue.ref();
    const containerHeight = vue.ref(0);
    const isItemsTwoLength = vue.ref(true);
    const arrowDisplay = vue.computed(() => props.arrow !== "never" && !vue.unref(isVertical));
    const hasLabel = vue.computed(() => {
      return items.value.some((item) => item.props.label.toString().length > 0);
    });
    const isCardType = vue.computed(() => props.type === "card");
    const isVertical = vue.computed(() => props.direction === "vertical");
    const containerStyle = vue.computed(() => {
      if (props.height !== "auto") {
        return {
          height: props.height
        };
      }
      return {
        height: `${containerHeight.value}px`,
        overflow: "hidden"
      };
    });
    const throttledArrowClick = throttle((index) => {
      setActiveItem(index);
    }, THROTTLE_TIME, { trailing: true });
    const throttledIndicatorHover = throttle((index) => {
      handleIndicatorHover(index);
    }, THROTTLE_TIME);
    const isTwoLengthShow = (index) => {
      if (!isItemsTwoLength.value)
        return true;
      return activeIndex.value <= 1 ? index <= 1 : index > 1;
    };
    function pauseTimer() {
      if (timer.value) {
        clearInterval(timer.value);
        timer.value = null;
      }
    }
    function startTimer() {
      if (props.interval <= 0 || !props.autoplay || timer.value)
        return;
      timer.value = setInterval(() => playSlides(), props.interval);
    }
    const playSlides = () => {
      if (activeIndex.value < items.value.length - 1) {
        activeIndex.value = activeIndex.value + 1;
      } else if (props.loop) {
        activeIndex.value = 0;
      }
    };
    function setActiveItem(index) {
      if (isString$1(index)) {
        const filteredItems = items.value.filter((item) => item.props.name === index);
        if (filteredItems.length > 0) {
          index = items.value.indexOf(filteredItems[0]);
        }
      }
      index = Number(index);
      if (Number.isNaN(index) || index !== Math.floor(index)) {
        debugWarn(componentName, "index must be integer.");
        return;
      }
      const itemCount = items.value.length;
      const oldIndex = activeIndex.value;
      if (index < 0) {
        activeIndex.value = props.loop ? itemCount - 1 : 0;
      } else if (index >= itemCount) {
        activeIndex.value = props.loop ? 0 : itemCount - 1;
      } else {
        activeIndex.value = index;
      }
      if (oldIndex === activeIndex.value) {
        resetItemPosition(oldIndex);
      }
      resetTimer();
    }
    function resetItemPosition(oldIndex) {
      items.value.forEach((item, index) => {
        item.translateItem(index, activeIndex.value, oldIndex);
      });
    }
    function itemInStage(item, index) {
      var _a, _b, _c, _d;
      const _items = vue.unref(items);
      const itemCount = _items.length;
      if (itemCount === 0 || !item.states.inStage)
        return false;
      const nextItemIndex = index + 1;
      const prevItemIndex = index - 1;
      const lastItemIndex = itemCount - 1;
      const isLastItemActive = _items[lastItemIndex].states.active;
      const isFirstItemActive = _items[0].states.active;
      const isNextItemActive = (_b = (_a = _items[nextItemIndex]) == null ? void 0 : _a.states) == null ? void 0 : _b.active;
      const isPrevItemActive = (_d = (_c = _items[prevItemIndex]) == null ? void 0 : _c.states) == null ? void 0 : _d.active;
      if (index === lastItemIndex && isFirstItemActive || isNextItemActive) {
        return "left";
      } else if (index === 0 && isLastItemActive || isPrevItemActive) {
        return "right";
      }
      return false;
    }
    function handleMouseEnter() {
      hover.value = true;
      if (props.pauseOnHover) {
        pauseTimer();
      }
    }
    function handleMouseLeave() {
      hover.value = false;
      startTimer();
    }
    function handleButtonEnter(arrow) {
      if (vue.unref(isVertical))
        return;
      items.value.forEach((item, index) => {
        if (arrow === itemInStage(item, index)) {
          item.states.hover = true;
        }
      });
    }
    function handleButtonLeave() {
      if (vue.unref(isVertical))
        return;
      items.value.forEach((item) => {
        item.states.hover = false;
      });
    }
    function handleIndicatorClick(index) {
      activeIndex.value = index;
    }
    function handleIndicatorHover(index) {
      if (props.trigger === "hover" && index !== activeIndex.value) {
        activeIndex.value = index;
      }
    }
    function prev() {
      setActiveItem(activeIndex.value - 1);
    }
    function next() {
      setActiveItem(activeIndex.value + 1);
    }
    function resetTimer() {
      pauseTimer();
      if (!props.pauseOnHover)
        startTimer();
    }
    function setContainerHeight(height) {
      if (props.height !== "auto")
        return;
      containerHeight.value = height;
    }
    function PlaceholderItem() {
      var _a;
      const defaultSlots = (_a = slots.default) == null ? void 0 : _a.call(slots);
      if (!defaultSlots)
        return null;
      const flatSlots = flattedChildren(defaultSlots);
      const normalizeSlots = flatSlots.filter((slot) => {
        return vue.isVNode(slot) && slot.type.name === CAROUSEL_ITEM_NAME;
      });
      if ((normalizeSlots == null ? void 0 : normalizeSlots.length) === 2 && props.loop && !isCardType.value) {
        isItemsTwoLength.value = true;
        return normalizeSlots;
      }
      isItemsTwoLength.value = false;
      return null;
    }
    vue.watch(() => activeIndex.value, (current, prev2) => {
      resetItemPosition(prev2);
      if (isItemsTwoLength.value) {
        current = current % 2;
        prev2 = prev2 % 2;
      }
      if (prev2 > -1) {
        emit(CHANGE_EVENT, current, prev2);
      }
    });
    const exposeActiveIndex = vue.computed({
      get: () => {
        return isItemsTwoLength.value ? activeIndex.value % 2 : activeIndex.value;
      },
      set: (value) => activeIndex.value = value
    });
    vue.watch(() => props.autoplay, (autoplay) => {
      autoplay ? startTimer() : pauseTimer();
    });
    vue.watch(() => props.loop, () => {
      setActiveItem(activeIndex.value);
    });
    vue.watch(() => props.interval, () => {
      resetTimer();
    });
    const resizeObserver = vue.shallowRef();
    vue.onMounted(() => {
      vue.watch(() => items.value, () => {
        if (items.value.length > 0)
          setActiveItem(props.initialIndex);
      }, {
        immediate: true
      });
      resizeObserver.value = useResizeObserver(root.value, () => {
        resetItemPosition();
      });
      startTimer();
    });
    vue.onBeforeUnmount(() => {
      pauseTimer();
      if (root.value && resizeObserver.value)
        resizeObserver.value.stop();
    });
    vue.provide(carouselContextKey, {
      root,
      isCardType,
      isVertical,
      items,
      loop: props.loop,
      cardScale: props.cardScale,
      addItem,
      removeItem,
      setActiveItem,
      setContainerHeight
    });
    return {
      root,
      activeIndex,
      exposeActiveIndex,
      arrowDisplay,
      hasLabel,
      hover,
      isCardType,
      items,
      isVertical,
      containerStyle,
      isItemsTwoLength,
      handleButtonEnter,
      handleButtonLeave,
      handleIndicatorClick,
      handleMouseEnter,
      handleMouseLeave,
      setActiveItem,
      prev,
      next,
      PlaceholderItem,
      isTwoLengthShow,
      ItemsSorter,
      throttledArrowClick,
      throttledIndicatorHover
    };
  };

  const COMPONENT_NAME$g = "ElCarousel";
  const __default__$1x = vue.defineComponent({
    name: COMPONENT_NAME$g
  });
  const _sfc_main$1Z = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1x,
    props: carouselProps,
    emits: carouselEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const {
        root,
        activeIndex,
        exposeActiveIndex,
        arrowDisplay,
        hasLabel,
        hover,
        isCardType,
        items,
        isVertical,
        containerStyle,
        handleButtonEnter,
        handleButtonLeave,
        handleIndicatorClick,
        handleMouseEnter,
        handleMouseLeave,
        setActiveItem,
        prev,
        next,
        PlaceholderItem,
        isTwoLengthShow,
        ItemsSorter,
        throttledArrowClick,
        throttledIndicatorHover
      } = useCarousel(props, emit, COMPONENT_NAME$g);
      const ns = useNamespace("carousel");
      const { t } = useLocale();
      const carouselClasses = vue.computed(() => {
        const classes = [ns.b(), ns.m(props.direction)];
        if (vue.unref(isCardType)) {
          classes.push(ns.m("card"));
        }
        return classes;
      });
      const indicatorsClasses = vue.computed(() => {
        const classes = [ns.e("indicators"), ns.em("indicators", props.direction)];
        if (vue.unref(hasLabel)) {
          classes.push(ns.em("indicators", "labels"));
        }
        if (props.indicatorPosition === "outside") {
          classes.push(ns.em("indicators", "outside"));
        }
        if (vue.unref(isVertical)) {
          classes.push(ns.em("indicators", "right"));
        }
        return classes;
      });
      function handleTransitionStart(e) {
        if (!props.motionBlur)
          return;
        const kls = vue.unref(isVertical) ? `${ns.namespace.value}-transitioning-vertical` : `${ns.namespace.value}-transitioning`;
        e.currentTarget.classList.add(kls);
      }
      function handleTransitionEnd(e) {
        if (!props.motionBlur)
          return;
        const kls = vue.unref(isVertical) ? `${ns.namespace.value}-transitioning-vertical` : `${ns.namespace.value}-transitioning`;
        e.currentTarget.classList.remove(kls);
      }
      expose({
        activeIndex: exposeActiveIndex,
        setActiveItem,
        prev,
        next
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "root",
          ref: root,
          class: vue.normalizeClass(vue.unref(carouselClasses)),
          onMouseenter: vue.withModifiers(vue.unref(handleMouseEnter), ["stop"]),
          onMouseleave: vue.withModifiers(vue.unref(handleMouseLeave), ["stop"])
        }, [
          vue.unref(arrowDisplay) ? (vue.openBlock(), vue.createBlock(vue.Transition, {
            key: 0,
            name: "carousel-arrow-left",
            persisted: ""
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("button", {
                type: "button",
                class: vue.normalizeClass([vue.unref(ns).e("arrow"), vue.unref(ns).em("arrow", "left")]),
                "aria-label": vue.unref(t)("el.carousel.leftArrow"),
                onMouseenter: ($event) => vue.unref(handleButtonEnter)("left"),
                onMouseleave: vue.unref(handleButtonLeave),
                onClick: vue.withModifiers(($event) => vue.unref(throttledArrowClick)(vue.unref(activeIndex) - 1), ["stop"])
              }, [
                vue.createVNode(vue.unref(ElIcon), null, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(arrow_left_default))
                  ]),
                  _: 1
                })
              ], 42, ["aria-label", "onMouseenter", "onMouseleave", "onClick"]), [
                [vue.vShow, (_ctx.arrow === "always" || vue.unref(hover)) && (_ctx.loop || vue.unref(activeIndex) > 0)]
              ])
            ]),
            _: 1
          })) : vue.createCommentVNode("v-if", true),
          vue.unref(arrowDisplay) ? (vue.openBlock(), vue.createBlock(vue.Transition, {
            key: 1,
            name: "carousel-arrow-right",
            persisted: ""
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("button", {
                type: "button",
                class: vue.normalizeClass([vue.unref(ns).e("arrow"), vue.unref(ns).em("arrow", "right")]),
                "aria-label": vue.unref(t)("el.carousel.rightArrow"),
                onMouseenter: ($event) => vue.unref(handleButtonEnter)("right"),
                onMouseleave: vue.unref(handleButtonLeave),
                onClick: vue.withModifiers(($event) => vue.unref(throttledArrowClick)(vue.unref(activeIndex) + 1), ["stop"])
              }, [
                vue.createVNode(vue.unref(ElIcon), null, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(arrow_right_default))
                  ]),
                  _: 1
                })
              ], 42, ["aria-label", "onMouseenter", "onMouseleave", "onClick"]), [
                [
                  vue.vShow,
                  (_ctx.arrow === "always" || vue.unref(hover)) && (_ctx.loop || vue.unref(activeIndex) < vue.unref(items).length - 1)
                ]
              ])
            ]),
            _: 1
          })) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("container")),
            style: vue.normalizeStyle(vue.unref(containerStyle)),
            onTransitionstart: handleTransitionStart,
            onTransitionend: handleTransitionEnd
          }, [
            vue.createVNode(vue.unref(PlaceholderItem)),
            vue.renderSlot(_ctx.$slots, "default")
          ], 38),
          vue.createVNode(vue.unref(ItemsSorter), null, {
            default: vue.withCtx(() => [
              _ctx.indicatorPosition !== "none" ? (vue.openBlock(), vue.createElementBlock("ul", {
                key: 0,
                class: vue.normalizeClass(vue.unref(indicatorsClasses))
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(items), (item, index) => {
                  return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
                    key: index,
                    class: vue.normalizeClass([
                      vue.unref(ns).e("indicator"),
                      vue.unref(ns).em("indicator", _ctx.direction),
                      vue.unref(ns).is("active", index === vue.unref(activeIndex))
                    ]),
                    onMouseenter: ($event) => vue.unref(throttledIndicatorHover)(index),
                    onClick: vue.withModifiers(($event) => vue.unref(handleIndicatorClick)(index), ["stop"])
                  }, [
                    vue.createElementVNode("button", {
                      class: vue.normalizeClass(vue.unref(ns).e("button")),
                      "aria-label": vue.unref(t)("el.carousel.indicator", { index: index + 1 })
                    }, [
                      vue.unref(hasLabel) ? (vue.openBlock(), vue.createElementBlock("span", { key: 0 }, vue.toDisplayString(item.props.label), 1)) : vue.createCommentVNode("v-if", true)
                    ], 10, ["aria-label"])
                  ], 42, ["onMouseenter", "onClick"])), [
                    [vue.vShow, vue.unref(isTwoLengthShow)(index)]
                  ]);
                }), 128))
              ], 2)) : vue.createCommentVNode("v-if", true)
            ]),
            _: 1
          }),
          _ctx.motionBlur ? (vue.openBlock(), vue.createElementBlock("svg", {
            key: 2,
            xmlns: "http://www.w3.org/2000/svg",
            version: "1.1",
            style: { "display": "none" }
          }, [
            vue.createElementVNode("defs", null, [
              vue.createElementVNode("filter", { id: "elCarouselHorizontal" }, [
                vue.createElementVNode("feGaussianBlur", {
                  in: "SourceGraphic",
                  stdDeviation: "12,0"
                })
              ]),
              vue.createElementVNode("filter", { id: "elCarouselVertical" }, [
                vue.createElementVNode("feGaussianBlur", {
                  in: "SourceGraphic",
                  stdDeviation: "0,10"
                })
              ])
            ])
          ])) : vue.createCommentVNode("v-if", true)
        ], 42, ["onMouseenter", "onMouseleave"]);
      };
    }
  });
  var Carousel = /* @__PURE__ */ _export_sfc(_sfc_main$1Z, [["__file", "carousel.vue"]]);

  const carouselItemProps = buildProps({
    name: { type: String, default: "" },
    label: {
      type: [String, Number],
      default: ""
    }
  });

  const useCarouselItem = (props) => {
    const carouselContext = vue.inject(carouselContextKey);
    const instance = vue.getCurrentInstance();
    if (!carouselContext) {
      debugWarn(CAROUSEL_ITEM_NAME, "usage: <el-carousel></el-carousel-item></el-carousel>");
    }
    if (!instance) {
      debugWarn(CAROUSEL_ITEM_NAME, "compositional hook can only be invoked inside setups");
    }
    const carouselItemRef = vue.ref();
    const hover = vue.ref(false);
    const translate = vue.ref(0);
    const scale = vue.ref(1);
    const active = vue.ref(false);
    const ready = vue.ref(false);
    const inStage = vue.ref(false);
    const animating = vue.ref(false);
    const { isCardType, isVertical, cardScale } = carouselContext;
    function processIndex(index, activeIndex, length) {
      const lastItemIndex = length - 1;
      const prevItemIndex = activeIndex - 1;
      const nextItemIndex = activeIndex + 1;
      const halfItemIndex = length / 2;
      if (activeIndex === 0 && index === lastItemIndex) {
        return -1;
      } else if (activeIndex === lastItemIndex && index === 0) {
        return length;
      } else if (index < prevItemIndex && activeIndex - index >= halfItemIndex) {
        return length + 1;
      } else if (index > nextItemIndex && index - activeIndex >= halfItemIndex) {
        return -2;
      }
      return index;
    }
    function calcCardTranslate(index, activeIndex) {
      var _a, _b;
      const parentWidth = vue.unref(isVertical) ? ((_a = carouselContext.root.value) == null ? void 0 : _a.offsetHeight) || 0 : ((_b = carouselContext.root.value) == null ? void 0 : _b.offsetWidth) || 0;
      if (inStage.value) {
        return parentWidth * ((2 - cardScale) * (index - activeIndex) + 1) / 4;
      } else if (index < activeIndex) {
        return -(1 + cardScale) * parentWidth / 4;
      } else {
        return (3 + cardScale) * parentWidth / 4;
      }
    }
    function calcTranslate(index, activeIndex, isVertical2) {
      const rootEl = carouselContext.root.value;
      if (!rootEl)
        return 0;
      const distance = (isVertical2 ? rootEl.offsetHeight : rootEl.offsetWidth) || 0;
      return distance * (index - activeIndex);
    }
    const translateItem = (index, activeIndex, oldIndex) => {
      var _a;
      const _isCardType = vue.unref(isCardType);
      const carouselItemLength = (_a = carouselContext.items.value.length) != null ? _a : Number.NaN;
      const isActive = index === activeIndex;
      if (!_isCardType && !isUndefined(oldIndex)) {
        animating.value = isActive || index === oldIndex;
      }
      if (!isActive && carouselItemLength > 2 && carouselContext.loop) {
        index = processIndex(index, activeIndex, carouselItemLength);
      }
      const _isVertical = vue.unref(isVertical);
      active.value = isActive;
      if (_isCardType) {
        inStage.value = Math.round(Math.abs(index - activeIndex)) <= 1;
        translate.value = calcCardTranslate(index, activeIndex);
        scale.value = vue.unref(active) ? 1 : cardScale;
      } else {
        translate.value = calcTranslate(index, activeIndex, _isVertical);
      }
      ready.value = true;
      if (isActive && carouselItemRef.value) {
        carouselContext.setContainerHeight(carouselItemRef.value.offsetHeight);
      }
    };
    function handleItemClick() {
      if (carouselContext && vue.unref(isCardType)) {
        const index = carouselContext.items.value.findIndex(({ uid }) => uid === instance.uid);
        carouselContext.setActiveItem(index);
      }
    }
    const carouselItemContext = {
      props,
      states: vue.reactive({
        hover,
        translate,
        scale,
        active,
        ready,
        inStage,
        animating
      }),
      uid: instance.uid,
      getVnode: () => instance.vnode,
      translateItem
    };
    carouselContext.addItem(carouselItemContext);
    vue.onBeforeUnmount(() => {
      carouselContext.removeItem(carouselItemContext);
    });
    return {
      carouselItemRef,
      active,
      animating,
      hover,
      inStage,
      isVertical,
      translate,
      isCardType,
      scale,
      ready,
      handleItemClick
    };
  };

  const __default__$1w = vue.defineComponent({
    name: CAROUSEL_ITEM_NAME
  });
  const _sfc_main$1Y = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1w,
    props: carouselItemProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("carousel");
      const {
        carouselItemRef,
        active,
        animating,
        hover,
        inStage,
        isVertical,
        translate,
        isCardType,
        scale,
        ready,
        handleItemClick
      } = useCarouselItem(props);
      const itemKls = vue.computed(() => [
        ns.e("item"),
        ns.is("active", active.value),
        ns.is("in-stage", inStage.value),
        ns.is("hover", hover.value),
        ns.is("animating", animating.value),
        {
          [ns.em("item", "card")]: isCardType.value,
          [ns.em("item", "card-vertical")]: isCardType.value && isVertical.value
        }
      ]);
      const itemStyle = vue.computed(() => {
        const translateType = `translate${vue.unref(isVertical) ? "Y" : "X"}`;
        const _translate = `${translateType}(${vue.unref(translate)}px)`;
        const _scale = `scale(${vue.unref(scale)})`;
        const transform = [_translate, _scale].join(" ");
        return {
          transform
        };
      });
      return (_ctx, _cache) => {
        return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "carouselItemRef",
          ref: carouselItemRef,
          class: vue.normalizeClass(vue.unref(itemKls)),
          style: vue.normalizeStyle(vue.unref(itemStyle)),
          onClick: vue.unref(handleItemClick)
        }, [
          vue.unref(isCardType) ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("mask"))
          }, null, 2)), [
            [vue.vShow, !vue.unref(active)]
          ]) : vue.createCommentVNode("v-if", true),
          vue.renderSlot(_ctx.$slots, "default")
        ], 14, ["onClick"])), [
          [vue.vShow, vue.unref(ready)]
        ]);
      };
    }
  });
  var CarouselItem = /* @__PURE__ */ _export_sfc(_sfc_main$1Y, [["__file", "carousel-item.vue"]]);

  const ElCarousel = withInstall(Carousel, {
    CarouselItem
  });
  const ElCarouselItem = withNoopInstall(CarouselItem);

  const checkboxProps = {
    modelValue: {
      type: [Number, String, Boolean],
      default: void 0
    },
    label: {
      type: [String, Boolean, Number, Object],
      default: void 0
    },
    value: {
      type: [String, Boolean, Number, Object],
      default: void 0
    },
    indeterminate: Boolean,
    disabled: Boolean,
    checked: Boolean,
    name: {
      type: String,
      default: void 0
    },
    trueValue: {
      type: [String, Number],
      default: void 0
    },
    falseValue: {
      type: [String, Number],
      default: void 0
    },
    trueLabel: {
      type: [String, Number],
      default: void 0
    },
    falseLabel: {
      type: [String, Number],
      default: void 0
    },
    id: {
      type: String,
      default: void 0
    },
    border: Boolean,
    size: useSizeProp,
    tabindex: [String, Number],
    validateEvent: {
      type: Boolean,
      default: true
    },
    ...useAriaProps(["ariaControls"])
  };
  const checkboxEmits = {
    [UPDATE_MODEL_EVENT]: (val) => isString$1(val) || isNumber(val) || isBoolean(val),
    change: (val) => isString$1(val) || isNumber(val) || isBoolean(val)
  };

  const checkboxGroupContextKey = Symbol("checkboxGroupContextKey");

  const useCheckboxDisabled = ({
    model,
    isChecked
  }) => {
    const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
    const isLimitDisabled = vue.computed(() => {
      var _a, _b;
      const max = (_a = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a.value;
      const min = (_b = checkboxGroup == null ? void 0 : checkboxGroup.min) == null ? void 0 : _b.value;
      return !isUndefined(max) && model.value.length >= max && !isChecked.value || !isUndefined(min) && model.value.length <= min && isChecked.value;
    });
    const isDisabled = useFormDisabled(vue.computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.disabled.value) || isLimitDisabled.value));
    return {
      isDisabled,
      isLimitDisabled
    };
  };

  const useCheckboxEvent = (props, {
    model,
    isLimitExceeded,
    hasOwnLabel,
    isDisabled,
    isLabeledByFormItem
  }) => {
    const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
    const { formItem } = useFormItem();
    const { emit } = vue.getCurrentInstance();
    function getLabeledValue(value) {
      var _a, _b, _c, _d;
      return [true, props.trueValue, props.trueLabel].includes(value) ? (_b = (_a = props.trueValue) != null ? _a : props.trueLabel) != null ? _b : true : (_d = (_c = props.falseValue) != null ? _c : props.falseLabel) != null ? _d : false;
    }
    function emitChangeEvent(checked, e) {
      emit(CHANGE_EVENT, getLabeledValue(checked), e);
    }
    function handleChange(e) {
      if (isLimitExceeded.value)
        return;
      const target = e.target;
      emit(CHANGE_EVENT, getLabeledValue(target.checked), e);
    }
    async function onClickRoot(e) {
      if (isLimitExceeded.value)
        return;
      if (!hasOwnLabel.value && !isDisabled.value && isLabeledByFormItem.value) {
        const eventTargets = e.composedPath();
        const hasLabel = eventTargets.some((item) => item.tagName === "LABEL");
        if (!hasLabel) {
          model.value = getLabeledValue([false, props.falseValue, props.falseLabel].includes(model.value));
          await vue.nextTick();
          emitChangeEvent(model.value, e);
        }
      }
    }
    const validateEvent = vue.computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.validateEvent) || props.validateEvent);
    vue.watch(() => props.modelValue, () => {
      if (validateEvent.value) {
        formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
      }
    });
    return {
      handleChange,
      onClickRoot
    };
  };

  const useCheckboxModel = (props) => {
    const selfModel = vue.ref(false);
    const { emit } = vue.getCurrentInstance();
    const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
    const isGroup = vue.computed(() => isUndefined(checkboxGroup) === false);
    const isLimitExceeded = vue.ref(false);
    const model = vue.computed({
      get() {
        var _a, _b;
        return isGroup.value ? (_a = checkboxGroup == null ? void 0 : checkboxGroup.modelValue) == null ? void 0 : _a.value : (_b = props.modelValue) != null ? _b : selfModel.value;
      },
      set(val) {
        var _a, _b;
        if (isGroup.value && isArray$1(val)) {
          isLimitExceeded.value = ((_a = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a.value) !== void 0 && val.length > (checkboxGroup == null ? void 0 : checkboxGroup.max.value) && val.length > model.value.length;
          isLimitExceeded.value === false && ((_b = checkboxGroup == null ? void 0 : checkboxGroup.changeEvent) == null ? void 0 : _b.call(checkboxGroup, val));
        } else {
          emit(UPDATE_MODEL_EVENT, val);
          selfModel.value = val;
        }
      }
    });
    return {
      model,
      isGroup,
      isLimitExceeded
    };
  };

  const useCheckboxStatus = (props, slots, { model }) => {
    const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
    const isFocused = vue.ref(false);
    const actualValue = vue.computed(() => {
      if (!isPropAbsent(props.value)) {
        return props.value;
      }
      return props.label;
    });
    const isChecked = vue.computed(() => {
      const value = model.value;
      if (isBoolean(value)) {
        return value;
      } else if (isArray$1(value)) {
        if (isObject$1(actualValue.value)) {
          return value.map(vue.toRaw).some((o) => isEqual$1(o, actualValue.value));
        } else {
          return value.map(vue.toRaw).includes(actualValue.value);
        }
      } else if (value !== null && value !== void 0) {
        return value === props.trueValue || value === props.trueLabel;
      } else {
        return !!value;
      }
    });
    const checkboxButtonSize = useFormSize(vue.computed(() => {
      var _a;
      return (_a = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a.value;
    }), {
      prop: true
    });
    const checkboxSize = useFormSize(vue.computed(() => {
      var _a;
      return (_a = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a.value;
    }));
    const hasOwnLabel = vue.computed(() => {
      return !!slots.default || !isPropAbsent(actualValue.value);
    });
    return {
      checkboxButtonSize,
      isChecked,
      isFocused,
      checkboxSize,
      hasOwnLabel,
      actualValue
    };
  };

  const useCheckbox = (props, slots) => {
    const { formItem: elFormItem } = useFormItem();
    const { model, isGroup, isLimitExceeded } = useCheckboxModel(props);
    const {
      isFocused,
      isChecked,
      checkboxButtonSize,
      checkboxSize,
      hasOwnLabel,
      actualValue
    } = useCheckboxStatus(props, slots, { model });
    const { isDisabled } = useCheckboxDisabled({ model, isChecked });
    const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
      formItemContext: elFormItem,
      disableIdGeneration: hasOwnLabel,
      disableIdManagement: isGroup
    });
    const { handleChange, onClickRoot } = useCheckboxEvent(props, {
      model,
      isLimitExceeded,
      hasOwnLabel,
      isDisabled,
      isLabeledByFormItem
    });
    const setStoreValue = () => {
      function addToStore() {
        var _a, _b;
        if (isArray$1(model.value) && !model.value.includes(actualValue.value)) {
          model.value.push(actualValue.value);
        } else {
          model.value = (_b = (_a = props.trueValue) != null ? _a : props.trueLabel) != null ? _b : true;
        }
      }
      props.checked && addToStore();
    };
    setStoreValue();
    useDeprecated({
      from: "label act as value",
      replacement: "value",
      version: "3.0.0",
      scope: "el-checkbox",
      ref: "https://element-plus.org/en-US/component/checkbox.html"
    }, vue.computed(() => isGroup.value && isPropAbsent(props.value)));
    useDeprecated({
      from: "true-label",
      replacement: "true-value",
      version: "3.0.0",
      scope: "el-checkbox",
      ref: "https://element-plus.org/en-US/component/checkbox.html"
    }, vue.computed(() => !!props.trueLabel));
    useDeprecated({
      from: "false-label",
      replacement: "false-value",
      version: "3.0.0",
      scope: "el-checkbox",
      ref: "https://element-plus.org/en-US/component/checkbox.html"
    }, vue.computed(() => !!props.falseLabel));
    return {
      inputId,
      isLabeledByFormItem,
      isChecked,
      isDisabled,
      isFocused,
      checkboxButtonSize,
      checkboxSize,
      hasOwnLabel,
      model,
      actualValue,
      handleChange,
      onClickRoot
    };
  };

  const __default__$1v = vue.defineComponent({
    name: "ElCheckbox"
  });
  const _sfc_main$1X = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1v,
    props: checkboxProps,
    emits: checkboxEmits,
    setup(__props) {
      const props = __props;
      const slots = vue.useSlots();
      const {
        inputId,
        isLabeledByFormItem,
        isChecked,
        isDisabled,
        isFocused,
        checkboxSize,
        hasOwnLabel,
        model,
        actualValue,
        handleChange,
        onClickRoot
      } = useCheckbox(props, slots);
      const inputBindings = vue.computed(() => {
        var _a, _b, _c, _d;
        if (props.trueValue || props.falseValue || props.trueLabel || props.falseLabel) {
          return {
            "true-value": (_b = (_a = props.trueValue) != null ? _a : props.trueLabel) != null ? _b : true,
            "false-value": (_d = (_c = props.falseValue) != null ? _c : props.falseLabel) != null ? _d : false
          };
        }
        return {
          value: actualValue.value
        };
      });
      const ns = useNamespace("checkbox");
      const compKls = vue.computed(() => {
        return [
          ns.b(),
          ns.m(checkboxSize.value),
          ns.is("disabled", isDisabled.value),
          ns.is("bordered", props.border),
          ns.is("checked", isChecked.value)
        ];
      });
      const spanKls = vue.computed(() => {
        return [
          ns.e("input"),
          ns.is("disabled", isDisabled.value),
          ns.is("checked", isChecked.value),
          ns.is("indeterminate", props.indeterminate),
          ns.is("focus", isFocused.value)
        ];
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(!vue.unref(hasOwnLabel) && vue.unref(isLabeledByFormItem) ? "span" : "label"), {
          class: vue.normalizeClass(vue.unref(compKls)),
          "aria-controls": _ctx.indeterminate ? _ctx.ariaControls : null,
          onClick: vue.unref(onClickRoot)
        }, {
          default: vue.withCtx(() => [
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(spanKls))
            }, [
              vue.withDirectives(vue.createElementVNode("input", vue.mergeProps({
                id: vue.unref(inputId),
                "onUpdate:modelValue": ($event) => vue.isRef(model) ? model.value = $event : null,
                class: vue.unref(ns).e("original"),
                type: "checkbox",
                indeterminate: _ctx.indeterminate,
                name: _ctx.name,
                tabindex: _ctx.tabindex,
                disabled: vue.unref(isDisabled)
              }, vue.unref(inputBindings), {
                onChange: vue.unref(handleChange),
                onFocus: ($event) => isFocused.value = true,
                onBlur: ($event) => isFocused.value = false,
                onClick: vue.withModifiers(() => {
                }, ["stop"])
              }), null, 16, ["id", "onUpdate:modelValue", "indeterminate", "name", "tabindex", "disabled", "onChange", "onFocus", "onBlur", "onClick"]), [
                [vue.vModelCheckbox, vue.unref(model)]
              ]),
              vue.createElementVNode("span", {
                class: vue.normalizeClass(vue.unref(ns).e("inner"))
              }, null, 2)
            ], 2),
            vue.unref(hasOwnLabel) ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("label"))
            }, [
              vue.renderSlot(_ctx.$slots, "default"),
              !_ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
              ], 64)) : vue.createCommentVNode("v-if", true)
            ], 2)) : vue.createCommentVNode("v-if", true)
          ]),
          _: 3
        }, 8, ["class", "aria-controls", "onClick"]);
      };
    }
  });
  var Checkbox = /* @__PURE__ */ _export_sfc(_sfc_main$1X, [["__file", "checkbox.vue"]]);

  const __default__$1u = vue.defineComponent({
    name: "ElCheckboxButton"
  });
  const _sfc_main$1W = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1u,
    props: checkboxProps,
    emits: checkboxEmits,
    setup(__props) {
      const props = __props;
      const slots = vue.useSlots();
      const {
        isFocused,
        isChecked,
        isDisabled,
        checkboxButtonSize,
        model,
        actualValue,
        handleChange
      } = useCheckbox(props, slots);
      const inputBindings = vue.computed(() => {
        var _a, _b, _c, _d;
        if (props.trueValue || props.falseValue || props.trueLabel || props.falseLabel) {
          return {
            "true-value": (_b = (_a = props.trueValue) != null ? _a : props.trueLabel) != null ? _b : true,
            "false-value": (_d = (_c = props.falseValue) != null ? _c : props.falseLabel) != null ? _d : false
          };
        }
        return {
          value: actualValue.value
        };
      });
      const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
      const ns = useNamespace("checkbox");
      const activeStyle = vue.computed(() => {
        var _a, _b, _c, _d;
        const fillValue = (_b = (_a = checkboxGroup == null ? void 0 : checkboxGroup.fill) == null ? void 0 : _a.value) != null ? _b : "";
        return {
          backgroundColor: fillValue,
          borderColor: fillValue,
          color: (_d = (_c = checkboxGroup == null ? void 0 : checkboxGroup.textColor) == null ? void 0 : _c.value) != null ? _d : "",
          boxShadow: fillValue ? `-1px 0 0 0 ${fillValue}` : void 0
        };
      });
      const labelKls = vue.computed(() => {
        return [
          ns.b("button"),
          ns.bm("button", checkboxButtonSize.value),
          ns.is("disabled", isDisabled.value),
          ns.is("checked", isChecked.value),
          ns.is("focus", isFocused.value)
        ];
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("label", {
          class: vue.normalizeClass(vue.unref(labelKls))
        }, [
          vue.withDirectives(vue.createElementVNode("input", vue.mergeProps({
            "onUpdate:modelValue": ($event) => vue.isRef(model) ? model.value = $event : null,
            class: vue.unref(ns).be("button", "original"),
            type: "checkbox",
            name: _ctx.name,
            tabindex: _ctx.tabindex,
            disabled: vue.unref(isDisabled)
          }, vue.unref(inputBindings), {
            onChange: vue.unref(handleChange),
            onFocus: ($event) => isFocused.value = true,
            onBlur: ($event) => isFocused.value = false,
            onClick: vue.withModifiers(() => {
            }, ["stop"])
          }), null, 16, ["onUpdate:modelValue", "name", "tabindex", "disabled", "onChange", "onFocus", "onBlur", "onClick"]), [
            [vue.vModelCheckbox, vue.unref(model)]
          ]),
          _ctx.$slots.default || _ctx.label ? (vue.openBlock(), vue.createElementBlock("span", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).be("button", "inner")),
            style: vue.normalizeStyle(vue.unref(isChecked) ? vue.unref(activeStyle) : void 0)
          }, [
            vue.renderSlot(_ctx.$slots, "default", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
            ])
          ], 6)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var CheckboxButton = /* @__PURE__ */ _export_sfc(_sfc_main$1W, [["__file", "checkbox-button.vue"]]);

  const checkboxGroupProps = buildProps({
    modelValue: {
      type: definePropType(Array),
      default: () => []
    },
    disabled: Boolean,
    min: Number,
    max: Number,
    size: useSizeProp,
    fill: String,
    textColor: String,
    tag: {
      type: String,
      default: "div"
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    options: {
      type: definePropType(Array)
    },
    props: {
      type: definePropType(Object),
      default: () => checkboxDefaultProps
    },
    type: {
      type: String,
      values: ["checkbox", "button"],
      default: "checkbox"
    },
    ...useAriaProps(["ariaLabel"])
  });
  const checkboxGroupEmits = {
    [UPDATE_MODEL_EVENT]: (val) => isArray$1(val),
    change: (val) => isArray$1(val)
  };
  const checkboxDefaultProps = {
    label: "label",
    value: "value",
    disabled: "disabled"
  };

  const __default__$1t = vue.defineComponent({
    name: "ElCheckboxGroup"
  });
  const _sfc_main$1V = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1t,
    props: checkboxGroupProps,
    emits: checkboxGroupEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("checkbox");
      const { formItem } = useFormItem();
      const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props, {
        formItemContext: formItem
      });
      const changeEvent = async (value) => {
        emit(UPDATE_MODEL_EVENT, value);
        await vue.nextTick();
        emit(CHANGE_EVENT, value);
      };
      const modelValue = vue.computed({
        get() {
          return props.modelValue;
        },
        set(val) {
          changeEvent(val);
        }
      });
      const aliasProps = vue.computed(() => ({
        ...checkboxDefaultProps,
        ...props.props
      }));
      const getOptionProps = (option) => {
        const { label, value, disabled } = aliasProps.value;
        const base = {
          label: option[label],
          value: option[value],
          disabled: option[disabled]
        };
        return { ...omit(option, [label, value, disabled]), ...base };
      };
      const optionComponent = vue.computed(() => props.type === "button" ? CheckboxButton : Checkbox);
      vue.provide(checkboxGroupContextKey, {
        ...pick(vue.toRefs(props), [
          "size",
          "min",
          "max",
          "disabled",
          "validateEvent",
          "fill",
          "textColor"
        ]),
        modelValue,
        changeEvent
      });
      vue.watch(() => props.modelValue, (newVal, oldValue) => {
        if (props.validateEvent && !isEqual$1(newVal, oldValue)) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
        }
      });
      return (_ctx, _cache) => {
        var _a;
        return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
          id: vue.unref(groupId),
          class: vue.normalizeClass(vue.unref(ns).b("group")),
          role: "group",
          "aria-label": !vue.unref(isLabeledByFormItem) ? _ctx.ariaLabel || "checkbox-group" : void 0,
          "aria-labelledby": vue.unref(isLabeledByFormItem) ? (_a = vue.unref(formItem)) == null ? void 0 : _a.labelId : void 0
        }, {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default", {}, () => [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.options, (item, index) => {
                return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(optionComponent)), vue.mergeProps({ key: index }, getOptionProps(item)), null, 16);
              }), 128))
            ])
          ]),
          _: 3
        }, 8, ["id", "class", "aria-label", "aria-labelledby"]);
      };
    }
  });
  var CheckboxGroup = /* @__PURE__ */ _export_sfc(_sfc_main$1V, [["__file", "checkbox-group.vue"]]);

  const ElCheckbox = withInstall(Checkbox, {
    CheckboxButton,
    CheckboxGroup
  });
  const ElCheckboxButton = withNoopInstall(CheckboxButton);
  const ElCheckboxGroup$1 = withNoopInstall(CheckboxGroup);

  const radioPropsBase = buildProps({
    modelValue: {
      type: [String, Number, Boolean],
      default: void 0
    },
    size: useSizeProp,
    disabled: Boolean,
    label: {
      type: [String, Number, Boolean],
      default: void 0
    },
    value: {
      type: [String, Number, Boolean],
      default: void 0
    },
    name: {
      type: String,
      default: void 0
    }
  });
  const radioProps = buildProps({
    ...radioPropsBase,
    border: Boolean
  });
  const radioEmits = {
    [UPDATE_MODEL_EVENT]: (val) => isString$1(val) || isNumber(val) || isBoolean(val),
    [CHANGE_EVENT]: (val) => isString$1(val) || isNumber(val) || isBoolean(val)
  };

  const radioGroupKey = Symbol("radioGroupKey");

  const useRadio = (props, emit) => {
    const radioRef = vue.ref();
    const radioGroup = vue.inject(radioGroupKey, void 0);
    const isGroup = vue.computed(() => !!radioGroup);
    const actualValue = vue.computed(() => {
      if (!isPropAbsent(props.value)) {
        return props.value;
      }
      return props.label;
    });
    const modelValue = vue.computed({
      get() {
        return isGroup.value ? radioGroup.modelValue : props.modelValue;
      },
      set(val) {
        if (isGroup.value) {
          radioGroup.changeEvent(val);
        } else {
          emit && emit(UPDATE_MODEL_EVENT, val);
        }
        radioRef.value.checked = props.modelValue === actualValue.value;
      }
    });
    const size = useFormSize(vue.computed(() => radioGroup == null ? void 0 : radioGroup.size));
    const disabled = useFormDisabled(vue.computed(() => radioGroup == null ? void 0 : radioGroup.disabled));
    const focus = vue.ref(false);
    const tabIndex = vue.computed(() => {
      return disabled.value || isGroup.value && modelValue.value !== actualValue.value ? -1 : 0;
    });
    useDeprecated({
      from: "label act as value",
      replacement: "value",
      version: "3.0.0",
      scope: "el-radio",
      ref: "https://element-plus.org/en-US/component/radio.html"
    }, vue.computed(() => isGroup.value && isPropAbsent(props.value)));
    return {
      radioRef,
      isGroup,
      radioGroup,
      focus,
      size,
      disabled,
      tabIndex,
      modelValue,
      actualValue
    };
  };

  const __default__$1s = vue.defineComponent({
    name: "ElRadio"
  });
  const _sfc_main$1U = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1s,
    props: radioProps,
    emits: radioEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("radio");
      const { radioRef, radioGroup, focus, size, disabled, modelValue, actualValue } = useRadio(props, emit);
      function handleChange() {
        vue.nextTick(() => emit(CHANGE_EVENT, modelValue.value));
      }
      return (_ctx, _cache) => {
        var _a;
        return vue.openBlock(), vue.createElementBlock("label", {
          class: vue.normalizeClass([
            vue.unref(ns).b(),
            vue.unref(ns).is("disabled", vue.unref(disabled)),
            vue.unref(ns).is("focus", vue.unref(focus)),
            vue.unref(ns).is("bordered", _ctx.border),
            vue.unref(ns).is("checked", vue.unref(modelValue) === vue.unref(actualValue)),
            vue.unref(ns).m(vue.unref(size))
          ])
        }, [
          vue.createElementVNode("span", {
            class: vue.normalizeClass([
              vue.unref(ns).e("input"),
              vue.unref(ns).is("disabled", vue.unref(disabled)),
              vue.unref(ns).is("checked", vue.unref(modelValue) === vue.unref(actualValue))
            ])
          }, [
            vue.withDirectives(vue.createElementVNode("input", {
              ref_key: "radioRef",
              ref: radioRef,
              "onUpdate:modelValue": ($event) => vue.isRef(modelValue) ? modelValue.value = $event : null,
              class: vue.normalizeClass(vue.unref(ns).e("original")),
              value: vue.unref(actualValue),
              name: _ctx.name || ((_a = vue.unref(radioGroup)) == null ? void 0 : _a.name),
              disabled: vue.unref(disabled),
              checked: vue.unref(modelValue) === vue.unref(actualValue),
              type: "radio",
              onFocus: ($event) => focus.value = true,
              onBlur: ($event) => focus.value = false,
              onChange: handleChange,
              onClick: vue.withModifiers(() => {
              }, ["stop"])
            }, null, 42, ["onUpdate:modelValue", "value", "name", "disabled", "checked", "onFocus", "onBlur", "onClick"]), [
              [vue.vModelRadio, vue.unref(modelValue)]
            ]),
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(ns).e("inner"))
            }, null, 2)
          ], 2),
          vue.createElementVNode("span", {
            class: vue.normalizeClass(vue.unref(ns).e("label")),
            onKeydown: vue.withModifiers(() => {
            }, ["stop"])
          }, [
            vue.renderSlot(_ctx.$slots, "default", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
            ])
          ], 42, ["onKeydown"])
        ], 2);
      };
    }
  });
  var Radio = /* @__PURE__ */ _export_sfc(_sfc_main$1U, [["__file", "radio.vue"]]);

  const radioButtonProps = buildProps({
    ...radioPropsBase
  });

  const __default__$1r = vue.defineComponent({
    name: "ElRadioButton"
  });
  const _sfc_main$1T = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1r,
    props: radioButtonProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("radio");
      const { radioRef, focus, size, disabled, modelValue, radioGroup, actualValue } = useRadio(props);
      const activeStyle = vue.computed(() => {
        return {
          backgroundColor: (radioGroup == null ? void 0 : radioGroup.fill) || "",
          borderColor: (radioGroup == null ? void 0 : radioGroup.fill) || "",
          boxShadow: (radioGroup == null ? void 0 : radioGroup.fill) ? `-1px 0 0 0 ${radioGroup.fill}` : "",
          color: (radioGroup == null ? void 0 : radioGroup.textColor) || ""
        };
      });
      return (_ctx, _cache) => {
        var _a;
        return vue.openBlock(), vue.createElementBlock("label", {
          class: vue.normalizeClass([
            vue.unref(ns).b("button"),
            vue.unref(ns).is("active", vue.unref(modelValue) === vue.unref(actualValue)),
            vue.unref(ns).is("disabled", vue.unref(disabled)),
            vue.unref(ns).is("focus", vue.unref(focus)),
            vue.unref(ns).bm("button", vue.unref(size))
          ])
        }, [
          vue.withDirectives(vue.createElementVNode("input", {
            ref_key: "radioRef",
            ref: radioRef,
            "onUpdate:modelValue": ($event) => vue.isRef(modelValue) ? modelValue.value = $event : null,
            class: vue.normalizeClass(vue.unref(ns).be("button", "original-radio")),
            value: vue.unref(actualValue),
            type: "radio",
            name: _ctx.name || ((_a = vue.unref(radioGroup)) == null ? void 0 : _a.name),
            disabled: vue.unref(disabled),
            onFocus: ($event) => focus.value = true,
            onBlur: ($event) => focus.value = false,
            onClick: vue.withModifiers(() => {
            }, ["stop"])
          }, null, 42, ["onUpdate:modelValue", "value", "name", "disabled", "onFocus", "onBlur", "onClick"]), [
            [vue.vModelRadio, vue.unref(modelValue)]
          ]),
          vue.createElementVNode("span", {
            class: vue.normalizeClass(vue.unref(ns).be("button", "inner")),
            style: vue.normalizeStyle(vue.unref(modelValue) === vue.unref(actualValue) ? vue.unref(activeStyle) : {}),
            onKeydown: vue.withModifiers(() => {
            }, ["stop"])
          }, [
            vue.renderSlot(_ctx.$slots, "default", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
            ])
          ], 46, ["onKeydown"])
        ], 2);
      };
    }
  });
  var RadioButton = /* @__PURE__ */ _export_sfc(_sfc_main$1T, [["__file", "radio-button.vue"]]);

  const radioGroupProps = buildProps({
    id: {
      type: String,
      default: void 0
    },
    size: useSizeProp,
    disabled: Boolean,
    modelValue: {
      type: [String, Number, Boolean],
      default: void 0
    },
    fill: {
      type: String,
      default: ""
    },
    textColor: {
      type: String,
      default: ""
    },
    name: {
      type: String,
      default: void 0
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    options: {
      type: definePropType(Array)
    },
    props: {
      type: definePropType(Object),
      default: () => radioDefaultProps
    },
    type: {
      type: String,
      values: ["radio", "button"],
      default: "radio"
    },
    ...useAriaProps(["ariaLabel"])
  });
  const radioGroupEmits = radioEmits;
  const radioDefaultProps = {
    label: "label",
    value: "value",
    disabled: "disabled"
  };

  const __default__$1q = vue.defineComponent({
    name: "ElRadioGroup"
  });
  const _sfc_main$1S = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1q,
    props: radioGroupProps,
    emits: radioGroupEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("radio");
      const radioId = useId();
      const radioGroupRef = vue.ref();
      const { formItem } = useFormItem();
      const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props, {
        formItemContext: formItem
      });
      const changeEvent = (value) => {
        emit(UPDATE_MODEL_EVENT, value);
        vue.nextTick(() => emit(CHANGE_EVENT, value));
      };
      vue.onMounted(() => {
        const radios = radioGroupRef.value.querySelectorAll("[type=radio]");
        const firstLabel = radios[0];
        if (!Array.from(radios).some((radio) => radio.checked) && firstLabel) {
          firstLabel.tabIndex = 0;
        }
      });
      const name = vue.computed(() => {
        return props.name || radioId.value;
      });
      const aliasProps = vue.computed(() => ({
        ...radioDefaultProps,
        ...props.props
      }));
      const getOptionProps = (option) => {
        const { label, value, disabled } = aliasProps.value;
        const base = {
          label: option[label],
          value: option[value],
          disabled: option[disabled]
        };
        return { ...omit(option, [label, value, disabled]), ...base };
      };
      const optionComponent = vue.computed(() => props.type === "button" ? RadioButton : Radio);
      vue.provide(radioGroupKey, vue.reactive({
        ...vue.toRefs(props),
        changeEvent,
        name
      }));
      vue.watch(() => props.modelValue, (newVal, oldValue) => {
        if (props.validateEvent && !isEqual$1(newVal, oldValue)) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
        }
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          id: vue.unref(groupId),
          ref_key: "radioGroupRef",
          ref: radioGroupRef,
          class: vue.normalizeClass(vue.unref(ns).b("group")),
          role: "radiogroup",
          "aria-label": !vue.unref(isLabeledByFormItem) ? _ctx.ariaLabel || "radio-group" : void 0,
          "aria-labelledby": vue.unref(isLabeledByFormItem) ? vue.unref(formItem).labelId : void 0
        }, [
          vue.renderSlot(_ctx.$slots, "default", {}, () => [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.options, (item, index) => {
              return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(optionComponent)), vue.mergeProps({ key: index }, getOptionProps(item)), null, 16);
            }), 128))
          ])
        ], 10, ["id", "aria-label", "aria-labelledby"]);
      };
    }
  });
  var RadioGroup = /* @__PURE__ */ _export_sfc(_sfc_main$1S, [["__file", "radio-group.vue"]]);

  const ElRadio = withInstall(Radio, {
    RadioButton,
    RadioGroup
  });
  const ElRadioGroup = withNoopInstall(RadioGroup);
  const ElRadioButton = withNoopInstall(RadioButton);

  const CASCADER_PANEL_INJECTION_KEY = Symbol();

  function isVNodeEmpty(vnodes) {
    return !!(isArray$1(vnodes) ? vnodes.every(({
      type
    }) => type === vue.Comment) : (vnodes == null ? void 0 : vnodes.type) === vue.Comment);
  }
  var NodeContent$1 = vue.defineComponent({
    name: "NodeContent",
    props: {
      node: {
        type: Object,
        required: true
      }
    },
    setup(props) {
      const ns = useNamespace("cascader-node");
      const {
        renderLabelFn
      } = vue.inject(CASCADER_PANEL_INJECTION_KEY);
      const {
        node
      } = props;
      const {
        data,
        label: nodeLabel
      } = node;
      const label = () => {
        const renderLabel = renderLabelFn == null ? void 0 : renderLabelFn({
          node,
          data
        });
        return isVNodeEmpty(renderLabel) ? nodeLabel : renderLabel != null ? renderLabel : nodeLabel;
      };
      return () => vue.createVNode("span", {
        "class": ns.e("label")
      }, [label()]);
    }
  });

  const __default__$1p = vue.defineComponent({
    name: "ElCascaderNode"
  });
  const _sfc_main$1R = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1p,
    props: {
      node: {
        type: Object,
        required: true
      },
      menuId: String
    },
    emits: ["expand"],
    setup(__props, { emit }) {
      const props = __props;
      const panel = vue.inject(CASCADER_PANEL_INJECTION_KEY);
      const ns = useNamespace("cascader-node");
      const isHoverMenu = vue.computed(() => panel.isHoverMenu);
      const multiple = vue.computed(() => panel.config.multiple);
      const checkStrictly = vue.computed(() => panel.config.checkStrictly);
      const showPrefix = vue.computed(() => panel.config.showPrefix);
      const checkedNodeId = vue.computed(() => {
        var _a;
        return (_a = panel.checkedNodes[0]) == null ? void 0 : _a.uid;
      });
      const isDisabled = vue.computed(() => props.node.isDisabled);
      const isLeaf = vue.computed(() => props.node.isLeaf);
      const expandable = vue.computed(() => checkStrictly.value && !isLeaf.value || !isDisabled.value);
      const inExpandingPath = vue.computed(() => isInPath(panel.expandingNode));
      const inCheckedPath = vue.computed(() => checkStrictly.value && panel.checkedNodes.some(isInPath));
      const isInPath = (node) => {
        var _a;
        const { level, uid } = props.node;
        return ((_a = node == null ? void 0 : node.pathNodes[level - 1]) == null ? void 0 : _a.uid) === uid;
      };
      const doExpand = () => {
        if (inExpandingPath.value)
          return;
        panel.expandNode(props.node);
      };
      const doCheck = (checked) => {
        const { node } = props;
        if (checked === node.checked)
          return;
        panel.handleCheckChange(node, checked);
      };
      const doLoad = () => {
        panel.lazyLoad(props.node, () => {
          if (!isLeaf.value)
            doExpand();
        });
      };
      const handleHoverExpand = (e) => {
        if (!isHoverMenu.value)
          return;
        handleExpand();
        !isLeaf.value && emit("expand", e);
      };
      const handleExpand = () => {
        const { node } = props;
        if (!expandable.value || node.loading)
          return;
        node.loaded ? doExpand() : doLoad();
      };
      const handleClick = () => {
        if (isLeaf.value && !isDisabled.value && !checkStrictly.value && !multiple.value) {
          handleCheck(true);
        } else if ((panel.config.checkOnClickNode && (multiple.value || checkStrictly.value) || isLeaf.value && panel.config.checkOnClickLeaf) && !isDisabled.value) {
          handleSelectCheck(!props.node.checked);
        } else if (!isHoverMenu.value) {
          handleExpand();
        }
      };
      const handleSelectCheck = (checked) => {
        if (checkStrictly.value) {
          doCheck(checked);
          if (props.node.loaded) {
            doExpand();
          }
        } else {
          handleCheck(checked);
        }
      };
      const handleCheck = (checked) => {
        if (!props.node.loaded) {
          doLoad();
        } else {
          doCheck(checked);
          !checkStrictly.value && doExpand();
        }
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("li", {
          id: `${__props.menuId}-${__props.node.uid}`,
          role: "menuitem",
          "aria-haspopup": !vue.unref(isLeaf),
          "aria-owns": vue.unref(isLeaf) ? void 0 : __props.menuId,
          "aria-expanded": vue.unref(inExpandingPath),
          tabindex: vue.unref(expandable) ? -1 : void 0,
          class: vue.normalizeClass([
            vue.unref(ns).b(),
            vue.unref(ns).is("selectable", vue.unref(checkStrictly)),
            vue.unref(ns).is("active", __props.node.checked),
            vue.unref(ns).is("disabled", !vue.unref(expandable)),
            vue.unref(inExpandingPath) && "in-active-path",
            vue.unref(inCheckedPath) && "in-checked-path"
          ]),
          onMouseenter: handleHoverExpand,
          onFocus: handleHoverExpand,
          onClick: handleClick
        }, [
          vue.createCommentVNode(" prefix "),
          vue.unref(multiple) && vue.unref(showPrefix) ? (vue.openBlock(), vue.createBlock(vue.unref(ElCheckbox), {
            key: 0,
            "model-value": __props.node.checked,
            indeterminate: __props.node.indeterminate,
            disabled: vue.unref(isDisabled),
            onClick: vue.withModifiers(() => {
            }, ["stop"]),
            "onUpdate:modelValue": handleSelectCheck
          }, null, 8, ["model-value", "indeterminate", "disabled", "onClick"])) : vue.unref(checkStrictly) && vue.unref(showPrefix) ? (vue.openBlock(), vue.createBlock(vue.unref(ElRadio), {
            key: 1,
            "model-value": vue.unref(checkedNodeId),
            label: __props.node.uid,
            disabled: vue.unref(isDisabled),
            "onUpdate:modelValue": handleSelectCheck,
            onClick: vue.withModifiers(() => {
            }, ["stop"])
          }, {
            default: vue.withCtx(() => [
              vue.createCommentVNode("\n        Add an empty element to avoid render label,\n        do not use empty fragment here for https://github.com/vuejs/vue-next/pull/2485\n      "),
              vue.createElementVNode("span")
            ]),
            _: 1
          }, 8, ["model-value", "label", "disabled", "onClick"])) : vue.unref(isLeaf) && __props.node.checked ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
            key: 2,
            class: vue.normalizeClass(vue.unref(ns).e("prefix"))
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(vue.unref(check_default))
            ]),
            _: 1
          }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
          vue.createCommentVNode(" content "),
          vue.createVNode(vue.unref(NodeContent$1), { node: __props.node }, null, 8, ["node"]),
          vue.createCommentVNode(" postfix "),
          !vue.unref(isLeaf) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 3 }, [
            __props.node.loading ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 0,
              class: vue.normalizeClass([vue.unref(ns).is("loading"), vue.unref(ns).e("postfix")])
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(vue.unref(loading_default))
              ]),
              _: 1
            }, 8, ["class"])) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 1,
              class: vue.normalizeClass(["arrow-right", vue.unref(ns).e("postfix")])
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(vue.unref(arrow_right_default))
              ]),
              _: 1
            }, 8, ["class"]))
          ], 64)) : vue.createCommentVNode("v-if", true)
        ], 42, ["id", "aria-haspopup", "aria-owns", "aria-expanded", "tabindex"]);
      };
    }
  });
  var ElCascaderNode = /* @__PURE__ */ _export_sfc(_sfc_main$1R, [["__file", "node.vue"]]);

  const __default__$1o = vue.defineComponent({
    name: "ElCascaderMenu"
  });
  const _sfc_main$1Q = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1o,
    props: {
      nodes: {
        type: Array,
        required: true
      },
      index: {
        type: Number,
        required: true
      }
    },
    setup(__props) {
      const props = __props;
      const instance = vue.getCurrentInstance();
      const ns = useNamespace("cascader-menu");
      const { t } = useLocale();
      const id = useId();
      let activeNode;
      let hoverTimer;
      const panel = vue.inject(CASCADER_PANEL_INJECTION_KEY);
      const hoverZone = vue.ref();
      const isEmpty = vue.computed(() => !props.nodes.length);
      const isLoading = vue.computed(() => !panel.initialLoaded);
      const menuId = vue.computed(() => `${id.value}-${props.index}`);
      const handleExpand = (e) => {
        activeNode = e.target;
      };
      const handleMouseMove = (e) => {
        if (!panel.isHoverMenu || !activeNode || !hoverZone.value)
          return;
        if (activeNode.contains(e.target)) {
          clearHoverTimer();
          const el = instance.vnode.el;
          const { left } = el.getBoundingClientRect();
          const { offsetWidth, offsetHeight } = el;
          const startX = e.clientX - left;
          const top = activeNode.offsetTop;
          const bottom = top + activeNode.offsetHeight;
          hoverZone.value.innerHTML = `
          <path style="pointer-events: auto;" fill="transparent" d="M${startX} ${top} L${offsetWidth} 0 V${top} Z" />
          <path style="pointer-events: auto;" fill="transparent" d="M${startX} ${bottom} L${offsetWidth} ${offsetHeight} V${bottom} Z" />
        `;
        } else if (!hoverTimer) {
          hoverTimer = window.setTimeout(clearHoverZone, panel.config.hoverThreshold);
        }
      };
      const clearHoverTimer = () => {
        if (!hoverTimer)
          return;
        clearTimeout(hoverTimer);
        hoverTimer = void 0;
      };
      const clearHoverZone = () => {
        if (!hoverZone.value)
          return;
        hoverZone.value.innerHTML = "";
        clearHoverTimer();
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElScrollbar), {
          key: vue.unref(menuId),
          tag: "ul",
          role: "menu",
          class: vue.normalizeClass(vue.unref(ns).b()),
          "wrap-class": vue.unref(ns).e("wrap"),
          "view-class": [vue.unref(ns).e("list"), vue.unref(ns).is("empty", vue.unref(isEmpty))],
          onMousemove: handleMouseMove,
          onMouseleave: clearHoverZone
        }, {
          default: vue.withCtx(() => {
            var _a;
            return [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.nodes, (node) => {
                return vue.openBlock(), vue.createBlock(ElCascaderNode, {
                  key: node.uid,
                  node,
                  "menu-id": vue.unref(menuId),
                  onExpand: handleExpand
                }, null, 8, ["node", "menu-id"]);
              }), 128)),
              vue.unref(isLoading) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("empty-text"))
              }, [
                vue.createVNode(vue.unref(ElIcon), {
                  size: "14",
                  class: vue.normalizeClass(vue.unref(ns).is("loading"))
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(loading_default))
                  ]),
                  _: 1
                }, 8, ["class"]),
                vue.createTextVNode(" " + vue.toDisplayString(vue.unref(t)("el.cascader.loading")), 1)
              ], 2)) : vue.unref(isEmpty) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                class: vue.normalizeClass(vue.unref(ns).e("empty-text"))
              }, [
                vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.cascader.noData")), 1)
                ])
              ], 2)) : ((_a = vue.unref(panel)) == null ? void 0 : _a.isHoverMenu) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
                vue.createCommentVNode(" eslint-disable-next-line vue/html-self-closing "),
                (vue.openBlock(), vue.createElementBlock("svg", {
                  ref_key: "hoverZone",
                  ref: hoverZone,
                  class: vue.normalizeClass(vue.unref(ns).e("hover-zone"))
                }, null, 2))
              ], 2112)) : vue.createCommentVNode("v-if", true)
            ];
          }),
          _: 3
        }, 8, ["class", "wrap-class", "view-class"]);
      };
    }
  });
  var ElCascaderMenu = /* @__PURE__ */ _export_sfc(_sfc_main$1Q, [["__file", "menu.vue"]]);

  let uid = 0;
  const calculatePathNodes = (node) => {
    const nodes = [node];
    let { parent } = node;
    while (parent) {
      nodes.unshift(parent);
      parent = parent.parent;
    }
    return nodes;
  };
  class Node$3 {
    constructor(data, config, parent, root = false) {
      this.data = data;
      this.config = config;
      this.parent = parent;
      this.root = root;
      this.uid = uid++;
      this.checked = false;
      this.indeterminate = false;
      this.loading = false;
      const { value: valueKey, label: labelKey, children: childrenKey } = config;
      const childrenData = data[childrenKey];
      const pathNodes = calculatePathNodes(this);
      this.level = root ? 0 : parent ? parent.level + 1 : 1;
      this.value = data[valueKey];
      this.label = data[labelKey];
      this.pathNodes = pathNodes;
      this.pathValues = pathNodes.map((node) => node.value);
      this.pathLabels = pathNodes.map((node) => node.label);
      this.childrenData = childrenData;
      this.children = (childrenData || []).map((child) => new Node$3(child, config, this));
      this.loaded = !config.lazy || this.isLeaf || !isEmpty(childrenData);
      this.text = "";
    }
    get isDisabled() {
      const { data, parent, config } = this;
      const { disabled, checkStrictly } = config;
      const isDisabled = isFunction$1(disabled) ? disabled(data, this) : !!data[disabled];
      return isDisabled || !checkStrictly && !!(parent == null ? void 0 : parent.isDisabled);
    }
    get isLeaf() {
      const { data, config, childrenData, loaded } = this;
      const { lazy, leaf } = config;
      const isLeaf = isFunction$1(leaf) ? leaf(data, this) : data[leaf];
      return isUndefined(isLeaf) ? lazy && !loaded ? false : !(isArray$1(childrenData) && childrenData.length) : !!isLeaf;
    }
    get valueByOption() {
      return this.config.emitPath ? this.pathValues : this.value;
    }
    appendChild(childData) {
      const { childrenData, children } = this;
      const node = new Node$3(childData, this.config, this);
      if (isArray$1(childrenData)) {
        childrenData.push(childData);
      } else {
        this.childrenData = [childData];
      }
      children.push(node);
      return node;
    }
    calcText(allLevels, separator) {
      const text = allLevels ? this.pathLabels.join(separator) : this.label;
      this.text = text;
      return text;
    }
    broadcast(checked) {
      this.children.forEach((child) => {
        var _a;
        if (child) {
          child.broadcast(checked);
          (_a = child.onParentCheck) == null ? void 0 : _a.call(child, checked);
        }
      });
    }
    emit() {
      var _a;
      const { parent } = this;
      if (parent) {
        (_a = parent.onChildCheck) == null ? void 0 : _a.call(parent);
        parent.emit();
      }
    }
    onParentCheck(checked) {
      if (!this.isDisabled) {
        this.setCheckState(checked);
      }
    }
    onChildCheck() {
      const { children } = this;
      const validChildren = children.filter((child) => !child.isDisabled);
      const checked = validChildren.length ? validChildren.every((child) => child.checked) : false;
      this.setCheckState(checked);
    }
    setCheckState(checked) {
      const totalNum = this.children.length;
      const checkedNum = this.children.reduce((c, p) => {
        const num = p.checked ? 1 : p.indeterminate ? 0.5 : 0;
        return c + num;
      }, 0);
      this.checked = this.loaded && this.children.filter((child) => !child.isDisabled).every((child) => child.loaded && child.checked) && checked;
      this.indeterminate = this.loaded && checkedNum !== totalNum && checkedNum > 0;
    }
    doCheck(checked) {
      if (this.checked === checked)
        return;
      const { checkStrictly, multiple } = this.config;
      if (checkStrictly || !multiple) {
        this.checked = checked;
      } else {
        this.broadcast(checked);
        this.setCheckState(checked);
        this.emit();
      }
    }
  }
  var Node$4 = Node$3;

  const flatNodes = (nodes, leafOnly) => {
    return nodes.reduce((res, node) => {
      if (node.isLeaf) {
        res.push(node);
      } else {
        !leafOnly && res.push(node);
        res = res.concat(flatNodes(node.children, leafOnly));
      }
      return res;
    }, []);
  };
  class Store {
    constructor(data, config) {
      this.config = config;
      const nodes = (data || []).map((nodeData) => new Node$4(nodeData, this.config));
      this.nodes = nodes;
      this.allNodes = flatNodes(nodes, false);
      this.leafNodes = flatNodes(nodes, true);
    }
    getNodes() {
      return this.nodes;
    }
    getFlattedNodes(leafOnly) {
      return leafOnly ? this.leafNodes : this.allNodes;
    }
    appendNode(nodeData, parentNode) {
      const node = parentNode ? parentNode.appendChild(nodeData) : new Node$4(nodeData, this.config);
      if (!parentNode)
        this.nodes.push(node);
      this.appendAllNodesAndLeafNodes(node);
    }
    appendNodes(nodeDataList, parentNode) {
      if (nodeDataList.length > 0) {
        nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
      } else {
        parentNode && parentNode.isLeaf && this.leafNodes.push(parentNode);
      }
    }
    appendAllNodesAndLeafNodes(node) {
      this.allNodes.push(node);
      node.isLeaf && this.leafNodes.push(node);
      if (node.children) {
        node.children.forEach((subNode) => {
          this.appendAllNodesAndLeafNodes(subNode);
        });
      }
    }
    getNodeByValue(value, leafOnly = false) {
      if (isPropAbsent(value))
        return null;
      const node = this.getFlattedNodes(leafOnly).find((node2) => isEqual$1(node2.value, value) || isEqual$1(node2.pathValues, value));
      return node || null;
    }
    getSameNode(node) {
      if (!node)
        return null;
      const node_ = this.getFlattedNodes(false).find(({ value, level }) => isEqual$1(node.value, value) && node.level === level);
      return node_ || null;
    }
  }

  const CommonProps = buildProps({
    modelValue: {
      type: definePropType([Number, String, Array, Object])
    },
    options: {
      type: definePropType(Array),
      default: () => []
    },
    props: {
      type: definePropType(Object),
      default: () => ({})
    }
  });
  const DefaultProps = {
    expandTrigger: "click",
    multiple: false,
    checkStrictly: false,
    emitPath: true,
    lazy: false,
    lazyLoad: NOOP,
    value: "value",
    label: "label",
    children: "children",
    leaf: "leaf",
    disabled: "disabled",
    hoverThreshold: 500,
    checkOnClickNode: false,
    checkOnClickLeaf: true,
    showPrefix: true
  };
  const cascaderPanelProps = buildProps({
    ...CommonProps,
    border: {
      type: Boolean,
      default: true
    },
    renderLabel: {
      type: Function
    }
  });
  const emitChangeFn$2 = (value) => true;
  const cascaderPanelEmits = {
    [UPDATE_MODEL_EVENT]: emitChangeFn$2,
    [CHANGE_EVENT]: emitChangeFn$2,
    close: () => true,
    "expand-change": (value) => value
  };
  const useCascaderConfig = (props) => {
    return vue.computed(() => ({
      ...DefaultProps,
      ...props.props
    }));
  };

  const getMenuIndex = (el) => {
    if (!el)
      return 0;
    const pieces = el.id.split("-");
    return Number(pieces[pieces.length - 2]);
  };
  const checkNode = (el) => {
    if (!el)
      return;
    const input = el.querySelector("input");
    if (input) {
      input.click();
    } else if (isLeaf(el)) {
      el.click();
    }
  };
  const sortByOriginalOrder = (oldNodes, newNodes) => {
    const newNodesCopy = newNodes.slice(0);
    const newIds = newNodesCopy.map((node) => node.uid);
    const res = oldNodes.reduce((acc, item) => {
      const index = newIds.indexOf(item.uid);
      if (index > -1) {
        acc.push(item);
        newNodesCopy.splice(index, 1);
        newIds.splice(index, 1);
      }
      return acc;
    }, []);
    res.push(...newNodesCopy);
    return res;
  };

  const __default__$1n = vue.defineComponent({
    name: "ElCascaderPanel",
    inheritAttrs: false
  });
  const _sfc_main$1P = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1n,
    props: cascaderPanelProps,
    emits: cascaderPanelEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      let manualChecked = false;
      const ns = useNamespace("cascader");
      const config = useCascaderConfig(props);
      const slots = vue.useSlots();
      let store;
      const initialLoaded = vue.ref(true);
      const initialLoadedOnce = vue.ref(false);
      const menuList = vue.ref([]);
      const checkedValue = vue.ref();
      const menus = vue.ref([]);
      const expandingNode = vue.ref();
      const checkedNodes = vue.ref([]);
      const isHoverMenu = vue.computed(() => config.value.expandTrigger === "hover");
      const renderLabelFn = vue.computed(() => props.renderLabel || slots.default);
      const initStore = () => {
        const { options } = props;
        const cfg = config.value;
        manualChecked = false;
        store = new Store(options, cfg);
        menus.value = [store.getNodes()];
        if (cfg.lazy && isEmpty(props.options)) {
          initialLoaded.value = false;
          lazyLoad(void 0, (list) => {
            if (list) {
              store = new Store(list, cfg);
              menus.value = [store.getNodes()];
            }
            initialLoaded.value = true;
            syncCheckedValue(false, true);
          });
        } else {
          syncCheckedValue(false, true);
        }
      };
      const lazyLoad = (node, cb) => {
        const cfg = config.value;
        node = node || new Node$4({}, cfg, void 0, true);
        node.loading = true;
        const resolve = (dataList) => {
          const _node = node;
          const parent = _node.root ? null : _node;
          _node.loading = false;
          _node.loaded = true;
          _node.childrenData = _node.childrenData || [];
          dataList && (store == null ? void 0 : store.appendNodes(dataList, parent));
          dataList && (cb == null ? void 0 : cb(dataList));
          if (node.level === 0) {
            initialLoadedOnce.value = true;
          }
        };
        const reject = () => {
          node.loading = false;
          node.loaded = false;
          if (node.level === 0) {
            initialLoaded.value = true;
          }
        };
        cfg.lazyLoad(node, resolve, reject);
      };
      const expandNode = (node, silent) => {
        var _a;
        const { level } = node;
        const newMenus = menus.value.slice(0, level);
        let newExpandingNode;
        if (node.isLeaf) {
          newExpandingNode = node.pathNodes[level - 2];
        } else {
          newExpandingNode = node;
          newMenus.push(node.children);
        }
        if (((_a = expandingNode.value) == null ? void 0 : _a.uid) !== (newExpandingNode == null ? void 0 : newExpandingNode.uid)) {
          expandingNode.value = node;
          menus.value = newMenus;
          !silent && emit("expand-change", (node == null ? void 0 : node.pathValues) || []);
        }
      };
      const handleCheckChange = (node, checked, emitClose = true) => {
        const { checkStrictly, multiple } = config.value;
        const oldNode = checkedNodes.value[0];
        manualChecked = true;
        !multiple && (oldNode == null ? void 0 : oldNode.doCheck(false));
        node.doCheck(checked);
        calculateCheckedValue();
        emitClose && !multiple && !checkStrictly && emit("close");
        !emitClose && !multiple && expandParentNode(node);
      };
      const expandParentNode = (node) => {
        if (!node)
          return;
        node = node.parent;
        expandParentNode(node);
        node && expandNode(node);
      };
      const getFlattedNodes = (leafOnly) => store == null ? void 0 : store.getFlattedNodes(leafOnly);
      const getCheckedNodes = (leafOnly) => {
        var _a;
        return (_a = getFlattedNodes(leafOnly)) == null ? void 0 : _a.filter(({ checked }) => checked !== false);
      };
      const clearCheckedNodes = () => {
        checkedNodes.value.forEach((node) => node.doCheck(false));
        calculateCheckedValue();
        menus.value = menus.value.slice(0, 1);
        expandingNode.value = void 0;
        emit("expand-change", []);
      };
      const calculateCheckedValue = () => {
        var _a;
        const { checkStrictly, multiple } = config.value;
        const oldNodes = checkedNodes.value;
        const newNodes = getCheckedNodes(!checkStrictly);
        const nodes = sortByOriginalOrder(oldNodes, newNodes);
        const values = nodes.map((node) => node.valueByOption);
        checkedNodes.value = nodes;
        checkedValue.value = multiple ? values : (_a = values[0]) != null ? _a : null;
      };
      const syncCheckedValue = (loaded = false, forced = false) => {
        const { modelValue } = props;
        const { lazy, multiple, checkStrictly } = config.value;
        const leafOnly = !checkStrictly;
        if (!initialLoaded.value || manualChecked || !forced && isEqual$1(modelValue, checkedValue.value))
          return;
        if (lazy && !loaded) {
          const values = unique(flattenDeep(castArray(modelValue)));
          const nodes = values.map((val) => store == null ? void 0 : store.getNodeByValue(val)).filter((node) => !!node && !node.loaded && !node.loading);
          if (nodes.length) {
            nodes.forEach((node) => {
              lazyLoad(node, () => syncCheckedValue(false, forced));
            });
          } else {
            syncCheckedValue(true, forced);
          }
        } else {
          const values = multiple ? castArray(modelValue) : [modelValue];
          const nodes = unique(values.map((val) => store == null ? void 0 : store.getNodeByValue(val, leafOnly)));
          syncMenuState(nodes, forced);
          checkedValue.value = cloneDeep(modelValue != null ? modelValue : void 0);
        }
      };
      const syncMenuState = (newCheckedNodes, reserveExpandingState = true) => {
        const { checkStrictly } = config.value;
        const oldNodes = checkedNodes.value;
        const newNodes = newCheckedNodes.filter((node) => !!node && (checkStrictly || node.isLeaf));
        const oldExpandingNode = store == null ? void 0 : store.getSameNode(expandingNode.value);
        const newExpandingNode = reserveExpandingState && oldExpandingNode || newNodes[0];
        if (newExpandingNode) {
          newExpandingNode.pathNodes.forEach((node) => expandNode(node, true));
        } else {
          expandingNode.value = void 0;
        }
        oldNodes.forEach((node) => node.doCheck(false));
        vue.reactive(newNodes).forEach((node) => node.doCheck(true));
        checkedNodes.value = newNodes;
        vue.nextTick(scrollToExpandingNode);
      };
      const scrollToExpandingNode = () => {
        if (!isClient)
          return;
        menuList.value.forEach((menu) => {
          const menuElement = menu == null ? void 0 : menu.$el;
          if (menuElement) {
            const container = menuElement.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
            const activeNode = menuElement.querySelector(`.${ns.b("node")}.${ns.is("active")}:last-child`) || menuElement.querySelector(`.${ns.b("node")}.in-active-path`);
            scrollIntoView(container, activeNode);
          }
        });
      };
      const handleKeyDown = (e) => {
        const target = e.target;
        const code = getEventCode(e);
        switch (code) {
          case EVENT_CODE.up:
          case EVENT_CODE.down: {
            e.preventDefault();
            const distance = code === EVENT_CODE.up ? -1 : 1;
            focusNode(getSibling(target, distance, `.${ns.b("node")}[tabindex="-1"]`));
            break;
          }
          case EVENT_CODE.left: {
            e.preventDefault();
            const preMenu = menuList.value[getMenuIndex(target) - 1];
            const expandedNode = preMenu == null ? void 0 : preMenu.$el.querySelector(`.${ns.b("node")}[aria-expanded="true"]`);
            focusNode(expandedNode);
            break;
          }
          case EVENT_CODE.right: {
            e.preventDefault();
            const nextMenu = menuList.value[getMenuIndex(target) + 1];
            const firstNode = nextMenu == null ? void 0 : nextMenu.$el.querySelector(`.${ns.b("node")}[tabindex="-1"]`);
            focusNode(firstNode);
            break;
          }
          case EVENT_CODE.enter:
          case EVENT_CODE.numpadEnter:
            checkNode(target);
            break;
        }
      };
      vue.provide(CASCADER_PANEL_INJECTION_KEY, vue.reactive({
        config,
        expandingNode,
        checkedNodes,
        isHoverMenu,
        initialLoaded,
        renderLabelFn,
        lazyLoad,
        expandNode,
        handleCheckChange
      }));
      vue.watch(config, (newVal, oldVal) => {
        if (isEqual$1(newVal, oldVal))
          return;
        initStore();
      }, {
        immediate: true
      });
      vue.watch(() => props.options, initStore, {
        deep: true
      });
      vue.watch(() => props.modelValue, () => {
        manualChecked = false;
        syncCheckedValue();
      }, {
        deep: true
      });
      vue.watch(() => checkedValue.value, (val) => {
        if (!isEqual$1(val, props.modelValue)) {
          emit(UPDATE_MODEL_EVENT, val);
          emit(CHANGE_EVENT, val);
        }
      });
      const loadLazyRootNodes = () => {
        if (initialLoadedOnce.value)
          return;
        initStore();
      };
      vue.onBeforeUpdate(() => menuList.value = []);
      vue.onMounted(() => !isEmpty(props.modelValue) && syncCheckedValue());
      expose({
        menuList,
        menus,
        checkedNodes,
        handleKeyDown,
        handleCheckChange,
        getFlattedNodes,
        getCheckedNodes,
        clearCheckedNodes,
        calculateCheckedValue,
        scrollToExpandingNode,
        loadLazyRootNodes
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b("panel"), vue.unref(ns).is("bordered", _ctx.border)]),
          onKeydown: handleKeyDown
        }, [
          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(menus.value, (menu, index) => {
            return vue.openBlock(), vue.createBlock(ElCascaderMenu, {
              key: index,
              ref_for: true,
              ref: (item) => menuList.value[index] = item,
              index,
              nodes: [...menu]
            }, {
              empty: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "empty")
              ]),
              _: 2
            }, 1032, ["index", "nodes"]);
          }), 128))
        ], 34);
      };
    }
  });
  var CascaderPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1P, [["__file", "index.vue"]]);

  const ElCascaderPanel = withInstall(CascaderPanel);

  const tagProps = buildProps({
    type: {
      type: String,
      values: ["primary", "success", "info", "warning", "danger"],
      default: "primary"
    },
    closable: Boolean,
    disableTransitions: Boolean,
    hit: Boolean,
    color: String,
    size: {
      type: String,
      values: componentSizes
    },
    effect: {
      type: String,
      values: ["dark", "light", "plain"],
      default: "light"
    },
    round: Boolean
  });
  const tagEmits = {
    close: (evt) => evt instanceof MouseEvent,
    click: (evt) => evt instanceof MouseEvent
  };

  const __default__$1m = vue.defineComponent({
    name: "ElTag"
  });
  const _sfc_main$1O = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1m,
    props: tagProps,
    emits: tagEmits,
    setup(__props, { emit }) {
      const props = __props;
      const tagSize = useFormSize();
      const ns = useNamespace("tag");
      const containerKls = vue.computed(() => {
        const { type, hit, effect, closable, round } = props;
        return [
          ns.b(),
          ns.is("closable", closable),
          ns.m(type || "primary"),
          ns.m(tagSize.value),
          ns.m(effect),
          ns.is("hit", hit),
          ns.is("round", round)
        ];
      });
      const handleClose = (event) => {
        emit("close", event);
      };
      const handleClick = (event) => {
        emit("click", event);
      };
      const handleVNodeMounted = (vnode) => {
        var _a, _b, _c;
        if ((_c = (_b = (_a = vnode == null ? void 0 : vnode.component) == null ? void 0 : _a.subTree) == null ? void 0 : _b.component) == null ? void 0 : _c.bum) {
          vnode.component.subTree.component.bum = null;
        }
      };
      return (_ctx, _cache) => {
        return _ctx.disableTransitions ? (vue.openBlock(), vue.createElementBlock("span", {
          key: 0,
          class: vue.normalizeClass(vue.unref(containerKls)),
          style: vue.normalizeStyle({ backgroundColor: _ctx.color }),
          onClick: handleClick
        }, [
          vue.createElementVNode("span", {
            class: vue.normalizeClass(vue.unref(ns).e("content"))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2),
          _ctx.closable ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("close")),
            onClick: vue.withModifiers(handleClose, ["stop"])
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(vue.unref(close_default))
            ]),
            _: 1
          }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
        ], 6)) : (vue.openBlock(), vue.createBlock(vue.Transition, {
          key: 1,
          name: `${vue.unref(ns).namespace.value}-zoom-in-center`,
          appear: "",
          onVnodeMounted: handleVNodeMounted
        }, {
          default: vue.withCtx(() => [
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(containerKls)),
              style: vue.normalizeStyle({ backgroundColor: _ctx.color }),
              onClick: handleClick
            }, [
              vue.createElementVNode("span", {
                class: vue.normalizeClass(vue.unref(ns).e("content"))
              }, [
                vue.renderSlot(_ctx.$slots, "default")
              ], 2),
              _ctx.closable ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("close")),
                onClick: vue.withModifiers(handleClose, ["stop"])
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(vue.unref(close_default))
                ]),
                _: 1
              }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
            ], 6)
          ]),
          _: 3
        }, 8, ["name"]));
      };
    }
  });
  var Tag = /* @__PURE__ */ _export_sfc(_sfc_main$1O, [["__file", "tag.vue"]]);

  const ElTag = withInstall(Tag);

  const cascaderProps = buildProps({
    ...CommonProps,
    size: useSizeProp,
    placeholder: String,
    disabled: Boolean,
    clearable: Boolean,
    clearIcon: {
      type: iconPropType,
      default: circle_close_default
    },
    filterable: Boolean,
    filterMethod: {
      type: definePropType(Function),
      default: (node, keyword) => node.text.includes(keyword)
    },
    separator: {
      type: String,
      default: " / "
    },
    showAllLevels: {
      type: Boolean,
      default: true
    },
    collapseTags: Boolean,
    maxCollapseTags: {
      type: Number,
      default: 1
    },
    collapseTagsTooltip: Boolean,
    maxCollapseTagsTooltipHeight: {
      type: [String, Number]
    },
    debounce: {
      type: Number,
      default: 300
    },
    beforeFilter: {
      type: definePropType(Function),
      default: () => true
    },
    placement: {
      type: definePropType(String),
      values: Ee,
      default: "bottom-start"
    },
    fallbackPlacements: {
      type: definePropType(Array),
      default: ["bottom-start", "bottom", "top-start", "top", "right", "left"]
    },
    popperClass: useTooltipContentProps.popperClass,
    popperStyle: useTooltipContentProps.popperStyle,
    teleported: useTooltipContentProps.teleported,
    effect: {
      type: definePropType(String),
      default: "light"
    },
    tagType: { ...tagProps.type, default: "info" },
    tagEffect: { ...tagProps.effect, default: "light" },
    validateEvent: {
      type: Boolean,
      default: true
    },
    persistent: {
      type: Boolean,
      default: true
    },
    showCheckedStrategy: {
      type: String,
      values: ["parent", "child"],
      default: "child"
    },
    checkOnClickNode: Boolean,
    showPrefix: {
      type: Boolean,
      default: true
    },
    ...useEmptyValuesProps
  });
  const emitChangeFn$1 = (value) => true;
  const cascaderEmits = {
    [UPDATE_MODEL_EVENT]: emitChangeFn$1,
    [CHANGE_EVENT]: emitChangeFn$1,
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent,
    clear: () => true,
    visibleChange: (val) => isBoolean(val),
    expandChange: (val) => !!val,
    removeTag: (val) => !!val
  };

  const __default__$1l = vue.defineComponent({
    name: "ElCascader"
  });
  const _sfc_main$1N = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1l,
    props: cascaderProps,
    emits: cascaderEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const popperOptions = {
        modifiers: [
          {
            name: "arrowPosition",
            enabled: true,
            phase: "main",
            fn: ({ state }) => {
              const { modifiersData, placement } = state;
              if (["right", "left", "bottom", "top"].includes(placement))
                return;
              if (modifiersData.arrow) {
                modifiersData.arrow.x = 35;
              }
            },
            requires: ["arrow"]
          }
        ]
      };
      const attrs = vue.useAttrs();
      let inputInitialHeight = 0;
      let pressDeleteCount = 0;
      const nsCascader = useNamespace("cascader");
      const nsInput = useNamespace("input");
      const { t } = useLocale();
      const { formItem } = useFormItem();
      const isDisabled = useFormDisabled();
      const { valueOnClear } = useEmptyValues(props);
      const { isComposing, handleComposition } = useComposition({
        afterComposition(event) {
          var _a;
          const text = (_a = event.target) == null ? void 0 : _a.value;
          handleInput(text);
        }
      });
      const tooltipRef = vue.ref();
      const tagTooltipRef = vue.ref();
      const inputRef = vue.ref();
      const tagWrapper = vue.ref();
      const cascaderPanelRef = vue.ref();
      const suggestionPanel = vue.ref();
      const popperVisible = vue.ref(false);
      const inputHover = vue.ref(false);
      const filtering = vue.ref(false);
      const inputValue = vue.ref("");
      const searchInputValue = vue.ref("");
      const tags = vue.ref([]);
      const suggestions = vue.ref([]);
      const showTagList = vue.computed(() => {
        if (!props.props.multiple) {
          return [];
        }
        return props.collapseTags ? tags.value.slice(0, props.maxCollapseTags) : tags.value;
      });
      const collapseTagList = vue.computed(() => {
        if (!props.props.multiple) {
          return [];
        }
        return props.collapseTags ? tags.value.slice(props.maxCollapseTags) : [];
      });
      const cascaderStyle = vue.computed(() => {
        return attrs.style;
      });
      const inputPlaceholder = vue.computed(() => {
        var _a;
        return (_a = props.placeholder) != null ? _a : t("el.cascader.placeholder");
      });
      const currentPlaceholder = vue.computed(() => searchInputValue.value || tags.value.length > 0 || isComposing.value ? "" : inputPlaceholder.value);
      const realSize = useFormSize();
      const tagSize = vue.computed(() => realSize.value === "small" ? "small" : "default");
      const multiple = vue.computed(() => !!props.props.multiple);
      const readonly = vue.computed(() => !props.filterable || multiple.value);
      const searchKeyword = vue.computed(() => multiple.value ? searchInputValue.value : inputValue.value);
      const checkedNodes = vue.computed(() => {
        var _a;
        return ((_a = cascaderPanelRef.value) == null ? void 0 : _a.checkedNodes) || [];
      });
      const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
        disabled: isDisabled,
        beforeBlur(event) {
          var _a, _b;
          return ((_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
        },
        afterBlur() {
          var _a;
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
          }
        }
      });
      const clearBtnVisible = vue.computed(() => {
        if (!props.clearable || isDisabled.value || filtering.value || !inputHover.value && !isFocused.value)
          return false;
        return !!checkedNodes.value.length;
      });
      const presentText = vue.computed(() => {
        const { showAllLevels, separator } = props;
        const nodes = checkedNodes.value;
        return nodes.length ? multiple.value ? "" : nodes[0].calcText(showAllLevels, separator) : "";
      });
      const validateState = vue.computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
      const checkedValue = vue.computed({
        get() {
          return cloneDeep(props.modelValue);
        },
        set(val) {
          const value = val != null ? val : valueOnClear.value;
          emit(UPDATE_MODEL_EVENT, value);
          emit(CHANGE_EVENT, value);
          if (props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
          }
        }
      });
      const cascaderKls = vue.computed(() => {
        return [
          nsCascader.b(),
          nsCascader.m(realSize.value),
          nsCascader.is("disabled", isDisabled.value),
          attrs.class
        ];
      });
      const cascaderIconKls = vue.computed(() => {
        return [
          nsInput.e("icon"),
          "icon-arrow-down",
          nsCascader.is("reverse", popperVisible.value)
        ];
      });
      const inputClass = vue.computed(() => nsCascader.is("focus", isFocused.value));
      const contentRef = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
      });
      const handleClickOutside = (event) => {
        if (isFocused.value) {
          const _event = new FocusEvent("blur", event);
          handleBlur(_event);
        }
        togglePopperVisible(false);
      };
      const togglePopperVisible = (visible) => {
        var _a, _b, _c;
        if (isDisabled.value)
          return;
        visible = visible != null ? visible : !popperVisible.value;
        if (visible !== popperVisible.value) {
          popperVisible.value = visible;
          (_b = (_a = inputRef.value) == null ? void 0 : _a.input) == null ? void 0 : _b.setAttribute("aria-expanded", `${visible}`);
          if (visible) {
            updatePopperPosition();
            vue.nextTick((_c = cascaderPanelRef.value) == null ? void 0 : _c.scrollToExpandingNode);
          } else if (props.filterable) {
            syncPresentTextValue();
          }
          emit("visibleChange", visible);
        }
      };
      const updatePopperPosition = () => {
        vue.nextTick(() => {
          var _a;
          (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper();
        });
      };
      const hideSuggestionPanel = () => {
        filtering.value = false;
      };
      const genTag = (node) => {
        const { showAllLevels, separator } = props;
        return {
          node,
          key: node.uid,
          text: node.calcText(showAllLevels, separator),
          hitState: false,
          closable: !isDisabled.value && !node.isDisabled
        };
      };
      const deleteTag = (tag) => {
        var _a;
        const node = tag.node;
        node.doCheck(false);
        (_a = cascaderPanelRef.value) == null ? void 0 : _a.calculateCheckedValue();
        emit("removeTag", node.valueByOption);
      };
      const getStrategyCheckedNodes = () => {
        switch (props.showCheckedStrategy) {
          case "child":
            return checkedNodes.value;
          case "parent": {
            const clickedNodes = getCheckedNodes(false);
            const clickedNodesValue = clickedNodes.map((o) => o.value);
            const parentNodes = clickedNodes.filter((o) => !o.parent || !clickedNodesValue.includes(o.parent.value));
            return parentNodes;
          }
          default:
            return [];
        }
      };
      const calculatePresentTags = () => {
        if (!multiple.value)
          return;
        const nodes = getStrategyCheckedNodes();
        const allTags = [];
        nodes.forEach((node) => allTags.push(genTag(node)));
        tags.value = allTags;
      };
      const calculateSuggestions = () => {
        var _a, _b;
        const { filterMethod, showAllLevels, separator } = props;
        const res = (_b = (_a = cascaderPanelRef.value) == null ? void 0 : _a.getFlattedNodes(!props.props.checkStrictly)) == null ? void 0 : _b.filter((node) => {
          if (node.isDisabled)
            return false;
          node.calcText(showAllLevels, separator);
          return filterMethod(node, searchKeyword.value);
        });
        if (multiple.value) {
          tags.value.forEach((tag) => {
            tag.hitState = false;
          });
        }
        filtering.value = true;
        suggestions.value = res;
        updatePopperPosition();
      };
      const focusFirstNode = () => {
        var _a;
        let firstNode;
        if (filtering.value && suggestionPanel.value) {
          firstNode = suggestionPanel.value.$el.querySelector(`.${nsCascader.e("suggestion-item")}`);
        } else {
          firstNode = (_a = cascaderPanelRef.value) == null ? void 0 : _a.$el.querySelector(`.${nsCascader.b("node")}[tabindex="-1"]`);
        }
        if (firstNode) {
          firstNode.focus();
          !filtering.value && firstNode.click();
        }
      };
      const updateStyle = () => {
        var _a, _b;
        const inputInner = (_a = inputRef.value) == null ? void 0 : _a.input;
        const tagWrapperEl = tagWrapper.value;
        const suggestionPanelEl = (_b = suggestionPanel.value) == null ? void 0 : _b.$el;
        if (!isClient || !inputInner)
          return;
        if (suggestionPanelEl) {
          const suggestionList = suggestionPanelEl.querySelector(`.${nsCascader.e("suggestion-list")}`);
          suggestionList.style.minWidth = `${inputInner.offsetWidth}px`;
        }
        if (tagWrapperEl) {
          const { offsetHeight } = tagWrapperEl;
          const height = tags.value.length > 0 ? `${Math.max(offsetHeight, inputInitialHeight) - 2}px` : `${inputInitialHeight}px`;
          inputInner.style.height = height;
          updatePopperPosition();
        }
      };
      const getCheckedNodes = (leafOnly) => {
        var _a;
        return (_a = cascaderPanelRef.value) == null ? void 0 : _a.getCheckedNodes(leafOnly);
      };
      const handleExpandChange = (value) => {
        updatePopperPosition();
        emit("expandChange", value);
      };
      const handleKeyDown = (e) => {
        if (isComposing.value)
          return;
        const code = getEventCode(e);
        switch (code) {
          case EVENT_CODE.enter:
          case EVENT_CODE.numpadEnter:
            togglePopperVisible();
            break;
          case EVENT_CODE.down:
            togglePopperVisible(true);
            vue.nextTick(focusFirstNode);
            e.preventDefault();
            break;
          case EVENT_CODE.esc:
            if (popperVisible.value === true) {
              e.preventDefault();
              e.stopPropagation();
              togglePopperVisible(false);
            }
            break;
          case EVENT_CODE.tab:
            togglePopperVisible(false);
            break;
        }
      };
      const handleClear = () => {
        var _a;
        (_a = cascaderPanelRef.value) == null ? void 0 : _a.clearCheckedNodes();
        if (!popperVisible.value && props.filterable) {
          syncPresentTextValue();
        }
        togglePopperVisible(false);
        emit("clear");
      };
      const syncPresentTextValue = () => {
        const { value } = presentText;
        inputValue.value = value;
        searchInputValue.value = value;
      };
      const handleSuggestionClick = (node) => {
        var _a, _b;
        const { checked } = node;
        if (multiple.value) {
          (_a = cascaderPanelRef.value) == null ? void 0 : _a.handleCheckChange(node, !checked, false);
        } else {
          !checked && ((_b = cascaderPanelRef.value) == null ? void 0 : _b.handleCheckChange(node, true, false));
          togglePopperVisible(false);
        }
      };
      const handleSuggestionKeyDown = (e) => {
        const target = e.target;
        const code = getEventCode(e);
        switch (code) {
          case EVENT_CODE.up:
          case EVENT_CODE.down: {
            e.preventDefault();
            const distance = code === EVENT_CODE.up ? -1 : 1;
            focusNode(getSibling(target, distance, `.${nsCascader.e("suggestion-item")}[tabindex="-1"]`));
            break;
          }
          case EVENT_CODE.enter:
          case EVENT_CODE.numpadEnter:
            target.click();
            break;
        }
      };
      const handleDelete = () => {
        const lastTag = tags.value[tags.value.length - 1];
        pressDeleteCount = searchInputValue.value ? 0 : pressDeleteCount + 1;
        if (!lastTag || !pressDeleteCount || props.collapseTags && tags.value.length > 1)
          return;
        if (lastTag.hitState) {
          deleteTag(lastTag);
        } else {
          lastTag.hitState = true;
        }
      };
      const debounce = vue.computed(() => props.debounce);
      const handleFilter = useDebounceFn(() => {
        const { value } = searchKeyword;
        if (!value)
          return;
        const passed = props.beforeFilter(value);
        if (isPromise(passed)) {
          passed.then(calculateSuggestions).catch(() => {
          });
        } else if (passed !== false) {
          calculateSuggestions();
        } else {
          hideSuggestionPanel();
        }
      }, debounce);
      const handleInput = (val, e) => {
        !popperVisible.value && togglePopperVisible(true);
        if (e == null ? void 0 : e.isComposing)
          return;
        val ? handleFilter() : hideSuggestionPanel();
      };
      const getInputInnerHeight = (inputInner) => Number.parseFloat(useCssVar(nsInput.cssVarName("input-height"), inputInner).value) - 2;
      vue.watch(filtering, updatePopperPosition);
      vue.watch([
        checkedNodes,
        isDisabled,
        () => props.collapseTags,
        () => props.maxCollapseTags
      ], calculatePresentTags);
      vue.watch(tags, () => {
        vue.nextTick(() => updateStyle());
      });
      vue.watch(realSize, async () => {
        await vue.nextTick();
        const inputInner = inputRef.value.input;
        inputInitialHeight = getInputInnerHeight(inputInner) || inputInitialHeight;
        updateStyle();
      });
      vue.watch(presentText, syncPresentTextValue, { immediate: true });
      vue.watch(() => popperVisible.value, (val) => {
        var _a;
        if (val && props.props.lazy && props.props.lazyLoad) {
          (_a = cascaderPanelRef.value) == null ? void 0 : _a.loadLazyRootNodes();
        }
      });
      vue.onMounted(() => {
        const inputInner = inputRef.value.input;
        const inputInnerHeight = getInputInnerHeight(inputInner);
        inputInitialHeight = inputInner.offsetHeight || inputInnerHeight;
        useResizeObserver(inputInner, updateStyle);
      });
      expose({
        getCheckedNodes,
        cascaderPanelRef,
        togglePopperVisible,
        contentRef,
        presentText
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
          ref_key: "tooltipRef",
          ref: tooltipRef,
          visible: popperVisible.value,
          teleported: _ctx.teleported,
          "popper-class": [vue.unref(nsCascader).e("dropdown"), _ctx.popperClass],
          "popper-style": _ctx.popperStyle,
          "popper-options": popperOptions,
          "fallback-placements": _ctx.fallbackPlacements,
          "stop-popper-mouse-event": false,
          "gpu-acceleration": false,
          placement: _ctx.placement,
          transition: `${vue.unref(nsCascader).namespace.value}-zoom-in-top`,
          effect: _ctx.effect,
          pure: "",
          persistent: _ctx.persistent,
          onHide: hideSuggestionPanel
        }, {
          default: vue.withCtx(() => [
            vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
              ref_key: "wrapperRef",
              ref: wrapperRef,
              class: vue.normalizeClass(vue.unref(cascaderKls)),
              style: vue.normalizeStyle(vue.unref(cascaderStyle)),
              onClick: () => togglePopperVisible(vue.unref(readonly) ? void 0 : true),
              onKeydown: handleKeyDown,
              onMouseenter: ($event) => inputHover.value = true,
              onMouseleave: ($event) => inputHover.value = false
            }, [
              vue.createVNode(vue.unref(ElInput), {
                ref_key: "inputRef",
                ref: inputRef,
                modelValue: inputValue.value,
                "onUpdate:modelValue": ($event) => inputValue.value = $event,
                placeholder: vue.unref(currentPlaceholder),
                readonly: vue.unref(readonly),
                disabled: vue.unref(isDisabled),
                "validate-event": false,
                size: vue.unref(realSize),
                class: vue.normalizeClass(vue.unref(inputClass)),
                tabindex: vue.unref(multiple) && _ctx.filterable && !vue.unref(isDisabled) ? -1 : void 0,
                onCompositionstart: vue.unref(handleComposition),
                onCompositionupdate: vue.unref(handleComposition),
                onCompositionend: vue.unref(handleComposition),
                onInput: handleInput
              }, vue.createSlots({
                suffix: vue.withCtx(() => [
                  vue.unref(clearBtnVisible) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: "clear",
                    class: vue.normalizeClass([vue.unref(nsInput).e("icon"), "icon-circle-close"]),
                    onClick: vue.withModifiers(handleClear, ["stop"])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"])) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: "arrow-down",
                    class: vue.normalizeClass(vue.unref(cascaderIconKls)),
                    onClick: vue.withModifiers(($event) => togglePopperVisible(), ["stop"])
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(arrow_down_default))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"]))
                ]),
                _: 2
              }, [
                _ctx.$slots.prefix ? {
                  name: "prefix",
                  fn: vue.withCtx(() => [
                    vue.renderSlot(_ctx.$slots, "prefix")
                  ])
                } : void 0
              ]), 1032, ["modelValue", "onUpdate:modelValue", "placeholder", "readonly", "disabled", "size", "class", "tabindex", "onCompositionstart", "onCompositionupdate", "onCompositionend"]),
              vue.unref(multiple) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                ref_key: "tagWrapper",
                ref: tagWrapper,
                class: vue.normalizeClass([
                  vue.unref(nsCascader).e("tags"),
                  vue.unref(nsCascader).is("validate", Boolean(vue.unref(validateState)))
                ])
              }, [
                vue.renderSlot(_ctx.$slots, "tag", {
                  data: tags.value,
                  deleteTag
                }, () => [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(showTagList), (tag) => {
                    return vue.openBlock(), vue.createBlock(vue.unref(ElTag), {
                      key: tag.key,
                      type: _ctx.tagType,
                      size: vue.unref(tagSize),
                      effect: _ctx.tagEffect,
                      hit: tag.hitState,
                      closable: tag.closable,
                      "disable-transitions": "",
                      onClose: ($event) => deleteTag(tag)
                    }, {
                      default: vue.withCtx(() => [
                        vue.createElementVNode("span", null, vue.toDisplayString(tag.text), 1)
                      ]),
                      _: 2
                    }, 1032, ["type", "size", "effect", "hit", "closable", "onClose"]);
                  }), 128))
                ]),
                _ctx.collapseTags && tags.value.length > _ctx.maxCollapseTags ? (vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
                  key: 0,
                  ref_key: "tagTooltipRef",
                  ref: tagTooltipRef,
                  disabled: popperVisible.value || !_ctx.collapseTagsTooltip,
                  "fallback-placements": ["bottom", "top", "right", "left"],
                  placement: "bottom",
                  "popper-class": _ctx.popperClass,
                  "popper-style": _ctx.popperStyle,
                  effect: _ctx.effect,
                  persistent: _ctx.persistent
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(ElTag), {
                      closable: false,
                      size: vue.unref(tagSize),
                      type: _ctx.tagType,
                      effect: _ctx.tagEffect,
                      "disable-transitions": ""
                    }, {
                      default: vue.withCtx(() => [
                        vue.createElementVNode("span", {
                          class: vue.normalizeClass(vue.unref(nsCascader).e("tags-text"))
                        }, " + " + vue.toDisplayString(tags.value.length - _ctx.maxCollapseTags), 3)
                      ]),
                      _: 1
                    }, 8, ["size", "type", "effect"])
                  ]),
                  content: vue.withCtx(() => [
                    vue.createVNode(vue.unref(ElScrollbar), { "max-height": _ctx.maxCollapseTagsTooltipHeight }, {
                      default: vue.withCtx(() => [
                        vue.createElementVNode("div", {
                          class: vue.normalizeClass(vue.unref(nsCascader).e("collapse-tags"))
                        }, [
                          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(collapseTagList), (tag, idx) => {
                            return vue.openBlock(), vue.createElementBlock("div", {
                              key: idx,
                              class: vue.normalizeClass(vue.unref(nsCascader).e("collapse-tag"))
                            }, [
                              (vue.openBlock(), vue.createBlock(vue.unref(ElTag), {
                                key: tag.key,
                                class: "in-tooltip",
                                type: _ctx.tagType,
                                size: vue.unref(tagSize),
                                effect: _ctx.tagEffect,
                                hit: tag.hitState,
                                closable: tag.closable,
                                "disable-transitions": "",
                                onClose: ($event) => deleteTag(tag)
                              }, {
                                default: vue.withCtx(() => [
                                  vue.createElementVNode("span", null, vue.toDisplayString(tag.text), 1)
                                ]),
                                _: 2
                              }, 1032, ["type", "size", "effect", "hit", "closable", "onClose"]))
                            ], 2);
                          }), 128))
                        ], 2)
                      ]),
                      _: 1
                    }, 8, ["max-height"])
                  ]),
                  _: 1
                }, 8, ["disabled", "popper-class", "popper-style", "effect", "persistent"])) : vue.createCommentVNode("v-if", true),
                _ctx.filterable && !vue.unref(isDisabled) ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
                  key: 1,
                  "onUpdate:modelValue": ($event) => searchInputValue.value = $event,
                  type: "text",
                  class: vue.normalizeClass(vue.unref(nsCascader).e("search-input")),
                  placeholder: vue.unref(presentText) ? "" : vue.unref(inputPlaceholder),
                  onInput: (e) => handleInput(searchInputValue.value, e),
                  onClick: vue.withModifiers(($event) => togglePopperVisible(true), ["stop"]),
                  onKeydown: vue.withKeys(handleDelete, ["delete"]),
                  onCompositionstart: vue.unref(handleComposition),
                  onCompositionupdate: vue.unref(handleComposition),
                  onCompositionend: vue.unref(handleComposition)
                }, null, 42, ["onUpdate:modelValue", "placeholder", "onInput", "onClick", "onKeydown", "onCompositionstart", "onCompositionupdate", "onCompositionend"])), [
                  [vue.vModelText, searchInputValue.value]
                ]) : vue.createCommentVNode("v-if", true)
              ], 2)) : vue.createCommentVNode("v-if", true)
            ], 46, ["onClick", "onMouseenter", "onMouseleave"])), [
              [vue.unref(ClickOutside), handleClickOutside, vue.unref(contentRef)]
            ])
          ]),
          content: vue.withCtx(() => [
            _ctx.$slots.header ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(nsCascader).e("header")),
              onClick: vue.withModifiers(() => {
              }, ["stop"])
            }, [
              vue.renderSlot(_ctx.$slots, "header")
            ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true),
            vue.withDirectives(vue.createVNode(vue.unref(ElCascaderPanel), {
              ref_key: "cascaderPanelRef",
              ref: cascaderPanelRef,
              modelValue: vue.unref(checkedValue),
              "onUpdate:modelValue": ($event) => vue.isRef(checkedValue) ? checkedValue.value = $event : null,
              options: _ctx.options,
              props: props.props,
              border: false,
              "render-label": _ctx.$slots.default,
              onExpandChange: handleExpandChange,
              onClose: ($event) => _ctx.$nextTick(() => togglePopperVisible(false))
            }, {
              empty: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "empty")
              ]),
              _: 3
            }, 8, ["modelValue", "onUpdate:modelValue", "options", "props", "render-label", "onClose"]), [
              [vue.vShow, !filtering.value]
            ]),
            _ctx.filterable ? vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElScrollbar), {
              key: 1,
              ref_key: "suggestionPanel",
              ref: suggestionPanel,
              tag: "ul",
              class: vue.normalizeClass(vue.unref(nsCascader).e("suggestion-panel")),
              "view-class": vue.unref(nsCascader).e("suggestion-list"),
              onKeydown: handleSuggestionKeyDown
            }, {
              default: vue.withCtx(() => [
                suggestions.value.length ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(suggestions.value, (item) => {
                  return vue.openBlock(), vue.createElementBlock("li", {
                    key: item.uid,
                    class: vue.normalizeClass([
                      vue.unref(nsCascader).e("suggestion-item"),
                      vue.unref(nsCascader).is("checked", item.checked)
                    ]),
                    tabindex: -1,
                    onClick: ($event) => handleSuggestionClick(item)
                  }, [
                    vue.renderSlot(_ctx.$slots, "suggestion-item", { item }, () => [
                      vue.createElementVNode("span", null, vue.toDisplayString(item.text), 1),
                      item.checked ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(check_default))
                        ]),
                        _: 1
                      })) : vue.createCommentVNode("v-if", true)
                    ])
                  ], 10, ["onClick"]);
                }), 128)) : vue.renderSlot(_ctx.$slots, "empty", { key: 1 }, () => [
                  vue.createElementVNode("li", {
                    class: vue.normalizeClass(vue.unref(nsCascader).e("empty-text"))
                  }, vue.toDisplayString(vue.unref(t)("el.cascader.noMatch")), 3)
                ])
              ]),
              _: 3
            }, 8, ["class", "view-class"])), [
              [vue.vShow, filtering.value]
            ]) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 2,
              class: vue.normalizeClass(vue.unref(nsCascader).e("footer")),
              onClick: vue.withModifiers(() => {
              }, ["stop"])
            }, [
              vue.renderSlot(_ctx.$slots, "footer")
            ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true)
          ]),
          _: 3
        }, 8, ["visible", "teleported", "popper-class", "popper-style", "fallback-placements", "placement", "transition", "effect", "persistent"]);
      };
    }
  });
  var Cascader = /* @__PURE__ */ _export_sfc(_sfc_main$1N, [["__file", "cascader.vue"]]);

  const ElCascader = withInstall(Cascader);

  const checkTagProps = buildProps({
    checked: Boolean,
    disabled: Boolean,
    type: {
      type: String,
      values: ["primary", "success", "info", "warning", "danger"],
      default: "primary"
    }
  });
  const checkTagEmits = {
    "update:checked": (value) => isBoolean(value),
    [CHANGE_EVENT]: (value) => isBoolean(value)
  };

  const __default__$1k = vue.defineComponent({
    name: "ElCheckTag"
  });
  const _sfc_main$1M = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1k,
    props: checkTagProps,
    emits: checkTagEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("check-tag");
      const containerKls = vue.computed(() => [
        ns.b(),
        ns.is("checked", props.checked),
        ns.is("disabled", props.disabled),
        ns.m(props.type || "primary")
      ]);
      const handleChange = () => {
        if (props.disabled)
          return;
        const checked = !props.checked;
        emit(CHANGE_EVENT, checked);
        emit("update:checked", checked);
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("span", {
          class: vue.normalizeClass(vue.unref(containerKls)),
          onClick: handleChange
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2);
      };
    }
  });
  var CheckTag = /* @__PURE__ */ _export_sfc(_sfc_main$1M, [["__file", "check-tag.vue"]]);

  const ElCheckTag = withInstall(CheckTag);

  const rowContextKey = Symbol("rowContextKey");

  const RowJustify = [
    "start",
    "center",
    "end",
    "space-around",
    "space-between",
    "space-evenly"
  ];
  const RowAlign = ["top", "middle", "bottom"];
  const rowProps = buildProps({
    tag: {
      type: String,
      default: "div"
    },
    gutter: {
      type: Number,
      default: 0
    },
    justify: {
      type: String,
      values: RowJustify,
      default: "start"
    },
    align: {
      type: String,
      values: RowAlign
    }
  });

  const __default__$1j = vue.defineComponent({
    name: "ElRow"
  });
  const _sfc_main$1L = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1j,
    props: rowProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("row");
      const gutter = vue.computed(() => props.gutter);
      vue.provide(rowContextKey, {
        gutter
      });
      const style = vue.computed(() => {
        const styles = {};
        if (!props.gutter) {
          return styles;
        }
        styles.marginRight = styles.marginLeft = `-${props.gutter / 2}px`;
        return styles;
      });
      const rowKls = vue.computed(() => [
        ns.b(),
        ns.is(`justify-${props.justify}`, props.justify !== "start"),
        ns.is(`align-${props.align}`, !!props.align)
      ]);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
          class: vue.normalizeClass(vue.unref(rowKls)),
          style: vue.normalizeStyle(vue.unref(style))
        }, {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 8, ["class", "style"]);
      };
    }
  });
  var Row$1 = /* @__PURE__ */ _export_sfc(_sfc_main$1L, [["__file", "row.vue"]]);

  const ElRow = withInstall(Row$1);

  const colProps = buildProps({
    tag: {
      type: String,
      default: "div"
    },
    span: {
      type: Number,
      default: 24
    },
    offset: {
      type: Number,
      default: 0
    },
    pull: {
      type: Number,
      default: 0
    },
    push: {
      type: Number,
      default: 0
    },
    xs: {
      type: definePropType([Number, Object]),
      default: () => mutable({})
    },
    sm: {
      type: definePropType([Number, Object]),
      default: () => mutable({})
    },
    md: {
      type: definePropType([Number, Object]),
      default: () => mutable({})
    },
    lg: {
      type: definePropType([Number, Object]),
      default: () => mutable({})
    },
    xl: {
      type: definePropType([Number, Object]),
      default: () => mutable({})
    }
  });

  const __default__$1i = vue.defineComponent({
    name: "ElCol"
  });
  const _sfc_main$1K = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1i,
    props: colProps,
    setup(__props) {
      const props = __props;
      const { gutter } = vue.inject(rowContextKey, { gutter: vue.computed(() => 0) });
      const ns = useNamespace("col");
      const style = vue.computed(() => {
        const styles = {};
        if (gutter.value) {
          styles.paddingLeft = styles.paddingRight = `${gutter.value / 2}px`;
        }
        return styles;
      });
      const colKls = vue.computed(() => {
        const classes = [];
        const pos = ["span", "offset", "pull", "push"];
        pos.forEach((prop) => {
          const size = props[prop];
          if (isNumber(size)) {
            if (prop === "span")
              classes.push(ns.b(`${props[prop]}`));
            else if (size > 0)
              classes.push(ns.b(`${prop}-${props[prop]}`));
          }
        });
        const sizes = ["xs", "sm", "md", "lg", "xl"];
        sizes.forEach((size) => {
          if (isNumber(props[size])) {
            classes.push(ns.b(`${size}-${props[size]}`));
          } else if (isObject$1(props[size])) {
            Object.entries(props[size]).forEach(([prop, sizeProp]) => {
              classes.push(prop !== "span" ? ns.b(`${size}-${prop}-${sizeProp}`) : ns.b(`${size}-${sizeProp}`));
            });
          }
        });
        if (gutter.value) {
          classes.push(ns.is("guttered"));
        }
        return [ns.b(), classes];
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
          class: vue.normalizeClass(vue.unref(colKls)),
          style: vue.normalizeStyle(vue.unref(style))
        }, {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 8, ["class", "style"]);
      };
    }
  });
  var Col = /* @__PURE__ */ _export_sfc(_sfc_main$1K, [["__file", "col.vue"]]);

  const ElCol = withInstall(Col);

  const emitChangeFn = (value) => isNumber(value) || isString$1(value) || isArray$1(value);
  const collapseProps = buildProps({
    accordion: Boolean,
    modelValue: {
      type: definePropType([Array, String, Number]),
      default: () => mutable([])
    },
    expandIconPosition: {
      type: definePropType([String]),
      default: "right"
    },
    beforeCollapse: {
      type: definePropType(Function)
    }
  });
  const collapseEmits = {
    [UPDATE_MODEL_EVENT]: emitChangeFn,
    [CHANGE_EVENT]: emitChangeFn
  };

  const collapseContextKey = Symbol("collapseContextKey");

  const SCOPE$3 = "ElCollapse";
  const useCollapse = (props, emit) => {
    const activeNames = vue.ref(castArray$1(props.modelValue));
    const setActiveNames = (_activeNames) => {
      activeNames.value = _activeNames;
      const value = props.accordion ? activeNames.value[0] : activeNames.value;
      emit(UPDATE_MODEL_EVENT, value);
      emit(CHANGE_EVENT, value);
    };
    const handleChange = (name) => {
      if (props.accordion) {
        setActiveNames([activeNames.value[0] === name ? "" : name]);
      } else {
        const _activeNames = [...activeNames.value];
        const index = _activeNames.indexOf(name);
        if (index > -1) {
          _activeNames.splice(index, 1);
        } else {
          _activeNames.push(name);
        }
        setActiveNames(_activeNames);
      }
    };
    const handleItemClick = async (name) => {
      const { beforeCollapse } = props;
      if (!beforeCollapse) {
        handleChange(name);
        return;
      }
      const shouldChange = beforeCollapse(name);
      const isPromiseOrBool = [
        isPromise(shouldChange),
        isBoolean(shouldChange)
      ].includes(true);
      if (!isPromiseOrBool) {
        throwError(SCOPE$3, "beforeCollapse must return type `Promise<boolean>` or `boolean`");
      }
      if (isPromise(shouldChange)) {
        shouldChange.then((result) => {
          if (result !== false) {
            handleChange(name);
          }
        }).catch((e) => {
          debugWarn(SCOPE$3, `some error occurred: ${e}`);
        });
      } else if (shouldChange) {
        handleChange(name);
      }
    };
    vue.watch(() => props.modelValue, () => activeNames.value = castArray$1(props.modelValue), { deep: true });
    vue.provide(collapseContextKey, {
      activeNames,
      handleItemClick
    });
    return {
      activeNames,
      setActiveNames
    };
  };
  const useCollapseDOM = (props) => {
    const ns = useNamespace("collapse");
    const rootKls = vue.computed(() => [
      ns.b(),
      ns.b(`icon-position-${props.expandIconPosition}`)
    ]);
    return {
      rootKls
    };
  };

  const __default__$1h = vue.defineComponent({
    name: "ElCollapse"
  });
  const _sfc_main$1J = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1h,
    props: collapseProps,
    emits: collapseEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const { activeNames, setActiveNames } = useCollapse(props, emit);
      const { rootKls } = useCollapseDOM(props);
      expose({
        activeNames,
        setActiveNames
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(rootKls))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2);
      };
    }
  });
  var Collapse = /* @__PURE__ */ _export_sfc(_sfc_main$1J, [["__file", "collapse.vue"]]);

  const __default__$1g = vue.defineComponent({
    name: "ElCollapseTransition"
  });
  const _sfc_main$1I = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1g,
    setup(__props) {
      const ns = useNamespace("collapse-transition");
      const reset = (el) => {
        el.style.maxHeight = "";
        el.style.overflow = el.dataset.oldOverflow;
        el.style.paddingTop = el.dataset.oldPaddingTop;
        el.style.paddingBottom = el.dataset.oldPaddingBottom;
      };
      const on = {
        beforeEnter(el) {
          if (!el.dataset)
            el.dataset = {};
          el.dataset.oldPaddingTop = el.style.paddingTop;
          el.dataset.oldPaddingBottom = el.style.paddingBottom;
          if (el.style.height)
            el.dataset.elExistsHeight = el.style.height;
          el.style.maxHeight = 0;
          el.style.paddingTop = 0;
          el.style.paddingBottom = 0;
        },
        enter(el) {
          requestAnimationFrame(() => {
            el.dataset.oldOverflow = el.style.overflow;
            if (el.dataset.elExistsHeight) {
              el.style.maxHeight = el.dataset.elExistsHeight;
            } else if (el.scrollHeight !== 0) {
              el.style.maxHeight = `${el.scrollHeight}px`;
            } else {
              el.style.maxHeight = 0;
            }
            el.style.paddingTop = el.dataset.oldPaddingTop;
            el.style.paddingBottom = el.dataset.oldPaddingBottom;
            el.style.overflow = "hidden";
          });
        },
        afterEnter(el) {
          el.style.maxHeight = "";
          el.style.overflow = el.dataset.oldOverflow;
        },
        enterCancelled(el) {
          reset(el);
        },
        beforeLeave(el) {
          if (!el.dataset)
            el.dataset = {};
          el.dataset.oldPaddingTop = el.style.paddingTop;
          el.dataset.oldPaddingBottom = el.style.paddingBottom;
          el.dataset.oldOverflow = el.style.overflow;
          el.style.maxHeight = `${el.scrollHeight}px`;
          el.style.overflow = "hidden";
        },
        leave(el) {
          if (el.scrollHeight !== 0) {
            el.style.maxHeight = 0;
            el.style.paddingTop = 0;
            el.style.paddingBottom = 0;
          }
        },
        afterLeave(el) {
          reset(el);
        },
        leaveCancelled(el) {
          reset(el);
        }
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, vue.mergeProps({
          name: vue.unref(ns).b()
        }, vue.toHandlers(on)), {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 16, ["name"]);
      };
    }
  });
  var CollapseTransition = /* @__PURE__ */ _export_sfc(_sfc_main$1I, [["__file", "collapse-transition.vue"]]);

  const ElCollapseTransition = withInstall(CollapseTransition);

  const collapseItemProps = buildProps({
    title: {
      type: String,
      default: ""
    },
    name: {
      type: definePropType([String, Number]),
      default: void 0
    },
    icon: {
      type: iconPropType,
      default: arrow_right_default
    },
    disabled: Boolean
  });

  const useCollapseItem = (props) => {
    const collapse = vue.inject(collapseContextKey);
    const { namespace } = useNamespace("collapse");
    const focusing = vue.ref(false);
    const isClick = vue.ref(false);
    const idInjection = useIdInjection();
    const id = vue.computed(() => idInjection.current++);
    const name = vue.computed(() => {
      var _a;
      return (_a = props.name) != null ? _a : `${namespace.value}-id-${idInjection.prefix}-${vue.unref(id)}`;
    });
    const isActive = vue.computed(() => collapse == null ? void 0 : collapse.activeNames.value.includes(vue.unref(name)));
    const handleFocus = () => {
      setTimeout(() => {
        if (!isClick.value) {
          focusing.value = true;
        } else {
          isClick.value = false;
        }
      }, 50);
    };
    const handleHeaderClick = (e) => {
      if (props.disabled)
        return;
      const target = e.target;
      if (target == null ? void 0 : target.closest("input, textarea, select"))
        return;
      collapse == null ? void 0 : collapse.handleItemClick(vue.unref(name));
      focusing.value = false;
      isClick.value = true;
    };
    const handleEnterClick = (e) => {
      const target = e.target;
      if (target == null ? void 0 : target.closest("input, textarea, select"))
        return;
      e.preventDefault();
      collapse == null ? void 0 : collapse.handleItemClick(vue.unref(name));
    };
    return {
      focusing,
      id,
      isActive,
      handleFocus,
      handleHeaderClick,
      handleEnterClick
    };
  };
  const useCollapseItemDOM = (props, { focusing, isActive, id }) => {
    const ns = useNamespace("collapse");
    const rootKls = vue.computed(() => [
      ns.b("item"),
      ns.is("active", vue.unref(isActive)),
      ns.is("disabled", props.disabled)
    ]);
    const headKls = vue.computed(() => [
      ns.be("item", "header"),
      ns.is("active", vue.unref(isActive)),
      { focusing: vue.unref(focusing) && !props.disabled }
    ]);
    const arrowKls = vue.computed(() => [
      ns.be("item", "arrow"),
      ns.is("active", vue.unref(isActive))
    ]);
    const itemTitleKls = vue.computed(() => [ns.be("item", "title")]);
    const itemWrapperKls = vue.computed(() => ns.be("item", "wrap"));
    const itemContentKls = vue.computed(() => ns.be("item", "content"));
    const scopedContentId = vue.computed(() => ns.b(`content-${vue.unref(id)}`));
    const scopedHeadId = vue.computed(() => ns.b(`head-${vue.unref(id)}`));
    return {
      itemTitleKls,
      arrowKls,
      headKls,
      rootKls,
      itemWrapperKls,
      itemContentKls,
      scopedContentId,
      scopedHeadId
    };
  };

  const __default__$1f = vue.defineComponent({
    name: "ElCollapseItem"
  });
  const _sfc_main$1H = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1f,
    props: collapseItemProps,
    setup(__props, { expose }) {
      const props = __props;
      const {
        focusing,
        id,
        isActive,
        handleFocus,
        handleHeaderClick,
        handleEnterClick
      } = useCollapseItem(props);
      const {
        arrowKls,
        headKls,
        rootKls,
        itemTitleKls,
        itemWrapperKls,
        itemContentKls,
        scopedContentId,
        scopedHeadId
      } = useCollapseItemDOM(props, { focusing, isActive, id });
      expose({
        isActive
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(rootKls))
        }, [
          vue.createElementVNode("div", {
            id: vue.unref(scopedHeadId),
            class: vue.normalizeClass(vue.unref(headKls)),
            "aria-expanded": vue.unref(isActive),
            "aria-controls": vue.unref(scopedContentId),
            "aria-describedby": vue.unref(scopedContentId),
            tabindex: _ctx.disabled ? void 0 : 0,
            "aria-disabled": _ctx.disabled,
            role: "button",
            onClick: vue.unref(handleHeaderClick),
            onKeydown: vue.withKeys(vue.withModifiers(vue.unref(handleEnterClick), ["stop"]), ["space", "enter"]),
            onFocus: vue.unref(handleFocus),
            onBlur: ($event) => focusing.value = false
          }, [
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(itemTitleKls))
            }, [
              vue.renderSlot(_ctx.$slots, "title", { isActive: vue.unref(isActive) }, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
              ])
            ], 2),
            vue.renderSlot(_ctx.$slots, "icon", { isActive: vue.unref(isActive) }, () => [
              vue.createVNode(vue.unref(ElIcon), {
                class: vue.normalizeClass(vue.unref(arrowKls))
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                ]),
                _: 1
              }, 8, ["class"])
            ])
          ], 42, ["id", "aria-expanded", "aria-controls", "aria-describedby", "tabindex", "aria-disabled", "onClick", "onKeydown", "onFocus", "onBlur"]),
          vue.createVNode(vue.unref(ElCollapseTransition), null, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("div", {
                id: vue.unref(scopedContentId),
                role: "region",
                class: vue.normalizeClass(vue.unref(itemWrapperKls)),
                "aria-hidden": !vue.unref(isActive),
                "aria-labelledby": vue.unref(scopedHeadId)
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(itemContentKls))
                }, [
                  vue.renderSlot(_ctx.$slots, "default")
                ], 2)
              ], 10, ["id", "aria-hidden", "aria-labelledby"]), [
                [vue.vShow, vue.unref(isActive)]
              ])
            ]),
            _: 3
          })
        ], 2);
      };
    }
  });
  var CollapseItem = /* @__PURE__ */ _export_sfc(_sfc_main$1H, [["__file", "collapse-item.vue"]]);

  const ElCollapse = withInstall(Collapse, {
    CollapseItem
  });
  const ElCollapseItem = withNoopInstall(CollapseItem);

  const alphaSliderProps = buildProps({
    color: {
      type: definePropType(Object),
      required: true
    },
    vertical: Boolean,
    disabled: Boolean
  });
  const hueSliderProps = alphaSliderProps;

  let isDragging = false;
  function draggable(element, options) {
    if (!isClient)
      return;
    const moveFn = function(event) {
      var _a;
      (_a = options.drag) == null ? void 0 : _a.call(options, event);
    };
    const upFn = function(event) {
      var _a;
      document.removeEventListener("mousemove", moveFn);
      document.removeEventListener("mouseup", upFn);
      document.removeEventListener("touchmove", moveFn);
      document.removeEventListener("touchend", upFn);
      document.onselectstart = null;
      document.ondragstart = null;
      isDragging = false;
      (_a = options.end) == null ? void 0 : _a.call(options, event);
    };
    const downFn = function(event) {
      var _a;
      if (isDragging)
        return;
      document.onselectstart = () => false;
      document.ondragstart = () => false;
      document.addEventListener("mousemove", moveFn);
      document.addEventListener("mouseup", upFn);
      document.addEventListener("touchmove", moveFn);
      document.addEventListener("touchend", upFn);
      isDragging = true;
      (_a = options.start) == null ? void 0 : _a.call(options, event);
    };
    element.addEventListener("mousedown", downFn);
    element.addEventListener("touchstart", downFn, { passive: false });
  }

  const useSlider = (props, { key, minValue, maxValue }) => {
    const instance = vue.getCurrentInstance();
    const thumb = vue.shallowRef();
    const bar = vue.shallowRef();
    const currentValue = vue.computed(() => props.color.get(key));
    function handleClick(event) {
      var _a;
      if (props.disabled)
        return;
      const target = event.target;
      if (target !== thumb.value) {
        handleDrag(event);
      }
      (_a = thumb.value) == null ? void 0 : _a.focus();
    }
    function handleDrag(event) {
      if (!bar.value || !thumb.value || props.disabled)
        return;
      const el = instance.vnode.el;
      const rect = el.getBoundingClientRect();
      const { clientX, clientY } = getClientXY(event);
      let value;
      if (!props.vertical) {
        let left = clientX - rect.left;
        left = Math.max(thumb.value.offsetWidth / 2, left);
        left = Math.min(left, rect.width - thumb.value.offsetWidth / 2);
        value = Math.round((left - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * maxValue);
      } else {
        let top = clientY - rect.top;
        top = Math.max(thumb.value.offsetHeight / 2, top);
        top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
        value = Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * maxValue);
      }
      props.color.set(key, value);
    }
    function handleKeydown(event) {
      if (props.disabled)
        return;
      const { shiftKey } = event;
      const code = getEventCode(event);
      const step = shiftKey ? 10 : 1;
      const reverse = key === "hue" ? -1 : 1;
      let isPreventDefault = true;
      switch (code) {
        case EVENT_CODE.left:
        case EVENT_CODE.down:
          incrementPosition(-step * reverse);
          break;
        case EVENT_CODE.right:
        case EVENT_CODE.up:
          incrementPosition(step * reverse);
          break;
        case EVENT_CODE.home:
          props.color.set(key, key === "hue" ? maxValue : minValue);
          break;
        case EVENT_CODE.end:
          props.color.set(key, key === "hue" ? minValue : maxValue);
          break;
        case EVENT_CODE.pageDown:
          incrementPosition(-4 * reverse);
          break;
        case EVENT_CODE.pageUp:
          incrementPosition(4 * reverse);
          break;
        default:
          isPreventDefault = false;
          break;
      }
      isPreventDefault && event.preventDefault();
    }
    function incrementPosition(step) {
      let next = currentValue.value + step;
      next = next < minValue ? minValue : next > maxValue ? maxValue : next;
      props.color.set(key, next);
    }
    return {
      thumb,
      bar,
      currentValue,
      handleDrag,
      handleClick,
      handleKeydown
    };
  };
  const useSliderDOM = (props, {
    namespace,
    maxValue,
    bar,
    thumb,
    currentValue,
    handleDrag,
    getBackground
  }) => {
    const instance = vue.getCurrentInstance();
    const ns = useNamespace(namespace);
    const thumbLeft = vue.ref(0);
    const thumbTop = vue.ref(0);
    const background = vue.ref();
    function getThumbLeft() {
      if (!thumb.value)
        return 0;
      if (props.vertical)
        return 0;
      const el = instance.vnode.el;
      const value = currentValue.value;
      if (!el)
        return 0;
      return Math.round(value * (el.offsetWidth - thumb.value.offsetWidth / 2) / maxValue);
    }
    function getThumbTop() {
      if (!thumb.value)
        return 0;
      const el = instance.vnode.el;
      if (!props.vertical)
        return 0;
      const value = currentValue.value;
      if (!el)
        return 0;
      return Math.round(value * (el.offsetHeight - thumb.value.offsetHeight / 2) / maxValue);
    }
    function update() {
      thumbLeft.value = getThumbLeft();
      thumbTop.value = getThumbTop();
      background.value = getBackground == null ? void 0 : getBackground();
    }
    vue.onMounted(() => {
      if (!bar.value || !thumb.value)
        return;
      const dragConfig = {
        drag: (event) => {
          handleDrag(event);
        },
        end: (event) => {
          handleDrag(event);
        }
      };
      draggable(bar.value, dragConfig);
      draggable(thumb.value, dragConfig);
      update();
    });
    vue.watch(currentValue, () => update());
    vue.watch(() => props.color.value, () => update());
    const rootKls = vue.computed(() => [
      ns.b(),
      ns.is("vertical", props.vertical),
      ns.is("disabled", props.disabled)
    ]);
    const barKls = vue.computed(() => ns.e("bar"));
    const thumbKls = vue.computed(() => ns.e("thumb"));
    const barStyle = vue.computed(() => ({ background: background.value }));
    const thumbStyle = vue.computed(() => ({
      left: addUnit(thumbLeft.value),
      top: addUnit(thumbTop.value)
    }));
    return {
      rootKls,
      barKls,
      barStyle,
      thumbKls,
      thumbStyle,
      thumbLeft,
      thumbTop,
      update
    };
  };

  const minValue$1 = 0;
  const maxValue$1 = 100;
  const __default__$1e = vue.defineComponent({
    name: "ElColorAlphaSlider"
  });
  const _sfc_main$1G = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1e,
    props: alphaSliderProps,
    setup(__props, { expose }) {
      const props = __props;
      const { currentValue, bar, thumb, handleDrag, handleClick, handleKeydown } = useSlider(props, { key: "alpha", minValue: minValue$1, maxValue: maxValue$1 });
      const { rootKls, barKls, barStyle, thumbKls, thumbStyle, update } = useSliderDOM(props, {
        namespace: "color-alpha-slider",
        maxValue: maxValue$1,
        currentValue,
        bar,
        thumb,
        handleDrag,
        getBackground
      });
      const { t } = useLocale();
      const ariaLabel = vue.computed(() => t("el.colorpicker.alphaLabel"));
      const ariaValuetext = vue.computed(() => {
        return t("el.colorpicker.alphaDescription", {
          alpha: currentValue.value,
          color: props.color.value
        });
      });
      function getBackground() {
        if (props.color && props.color.value) {
          const { r, g, b } = props.color.toRgb();
          return `linear-gradient(to right, rgba(${r}, ${g}, ${b}, 0) 0%, rgba(${r}, ${g}, ${b}, 1) 100%)`;
        }
        return "";
      }
      expose({
        update,
        bar,
        thumb
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(rootKls))
        }, [
          vue.createElementVNode("div", {
            ref_key: "bar",
            ref: bar,
            class: vue.normalizeClass(vue.unref(barKls)),
            style: vue.normalizeStyle(vue.unref(barStyle)),
            onClick: vue.unref(handleClick)
          }, null, 14, ["onClick"]),
          vue.createElementVNode("div", {
            ref_key: "thumb",
            ref: thumb,
            class: vue.normalizeClass(vue.unref(thumbKls)),
            style: vue.normalizeStyle(vue.unref(thumbStyle)),
            "aria-label": vue.unref(ariaLabel),
            "aria-valuenow": vue.unref(currentValue),
            "aria-valuetext": vue.unref(ariaValuetext),
            "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
            "aria-valuemin": minValue$1,
            "aria-valuemax": maxValue$1,
            role: "slider",
            tabindex: "0",
            onKeydown: vue.unref(handleKeydown)
          }, null, 46, ["aria-label", "aria-valuenow", "aria-valuetext", "aria-orientation", "onKeydown"])
        ], 2);
      };
    }
  });
  var AlphaSlider = /* @__PURE__ */ _export_sfc(_sfc_main$1G, [["__file", "alpha-slider.vue"]]);

  const minValue = 0;
  const maxValue = 360;
  const __default__$1d = vue.defineComponent({
    name: "ElColorHueSlider"
  });
  const _sfc_main$1F = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1d,
    props: hueSliderProps,
    setup(__props, { expose }) {
      const props = __props;
      const { currentValue, bar, thumb, handleDrag, handleClick, handleKeydown } = useSlider(props, { key: "hue", minValue, maxValue });
      const { rootKls, barKls, thumbKls, thumbStyle, thumbTop, update } = useSliderDOM(props, {
        namespace: "color-hue-slider",
        maxValue,
        currentValue,
        bar,
        thumb,
        handleDrag
      });
      const { t } = useLocale();
      const ariaLabel = vue.computed(() => t("el.colorpicker.hueLabel"));
      const ariaValuetext = vue.computed(() => {
        return t("el.colorpicker.hueDescription", {
          hue: currentValue.value,
          color: props.color.value
        });
      });
      expose({
        bar,
        thumb,
        thumbTop,
        update
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(rootKls))
        }, [
          vue.createElementVNode("div", {
            ref_key: "bar",
            ref: bar,
            class: vue.normalizeClass(vue.unref(barKls)),
            onClick: vue.unref(handleClick)
          }, null, 10, ["onClick"]),
          vue.createElementVNode("div", {
            ref_key: "thumb",
            ref: thumb,
            class: vue.normalizeClass(vue.unref(thumbKls)),
            style: vue.normalizeStyle(vue.unref(thumbStyle)),
            "aria-label": vue.unref(ariaLabel),
            "aria-valuenow": vue.unref(currentValue),
            "aria-valuetext": vue.unref(ariaValuetext),
            "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
            "aria-valuemin": minValue,
            "aria-valuemax": maxValue,
            role: "slider",
            tabindex: "0",
            onKeydown: vue.unref(handleKeydown)
          }, null, 46, ["aria-label", "aria-valuenow", "aria-valuetext", "aria-orientation", "onKeydown"])
        ], 2);
      };
    }
  });
  var HueSlider = /* @__PURE__ */ _export_sfc(_sfc_main$1F, [["__file", "hue-slider.vue"]]);

  const predefineProps = buildProps({
    colors: {
      type: definePropType(Array),
      required: true
    },
    color: {
      type: definePropType(Object),
      required: true
    },
    enableAlpha: {
      type: Boolean,
      required: true
    },
    disabled: Boolean
  });

  const colorPickerPanelProps = buildProps({
    modelValue: {
      type: definePropType(String),
      default: void 0
    },
    border: {
      type: Boolean,
      default: true
    },
    showAlpha: Boolean,
    colorFormat: String,
    disabled: Boolean,
    predefine: {
      type: definePropType(Array)
    },
    validateEvent: {
      type: Boolean,
      default: true
    }
  });
  const colorPickerPanelEmits = {
    [UPDATE_MODEL_EVENT]: (val) => isString$1(val) || isNil(val)
  };
  const ROOT_COMMON_COLOR_INJECTION_KEY = Symbol("colorCommonPickerKey");
  const colorPickerPanelContextKey = Symbol("colorPickerPanelContextKey");

  class Color {
    constructor(options = {}) {
      this._hue = 0;
      this._saturation = 100;
      this._value = 100;
      this._alpha = 100;
      this._tiny = new TinyColor();
      this._isValid = false;
      this.enableAlpha = false;
      this.format = "";
      this.value = "";
      for (const option in options) {
        if (hasOwn(options, option)) {
          this[option] = options[option];
        }
      }
      if (options.value) {
        this.fromString(options.value);
      } else {
        this.doOnChange();
      }
    }
    set(prop, value) {
      if (arguments.length === 1 && typeof prop === "object") {
        for (const p in prop) {
          if (hasOwn(prop, p)) {
            this.set(p, prop[p]);
          }
        }
        return;
      }
      this[`_${prop}`] = value;
      this._isValid = true;
      this.doOnChange();
    }
    get(prop) {
      if (["hue", "saturation", "value", "alpha"].includes(prop)) {
        return Math.round(this[`_${prop}`]);
      }
      return this[`_${prop}`];
    }
    toRgb() {
      return this._isValid ? this._tiny.toRgb() : { r: 255, g: 255, b: 255, a: 0 };
    }
    fromString(value) {
      const color = new TinyColor(value);
      this._isValid = color.isValid;
      if (color.isValid) {
        const { h, s, v, a } = color.toHsv();
        this._hue = h;
        this._saturation = s * 100;
        this._value = v * 100;
        this._alpha = a * 100;
      } else {
        this._hue = 0;
        this._saturation = 100;
        this._value = 100;
        this._alpha = 100;
      }
      this.doOnChange();
    }
    clear() {
      this._isValid = false;
      this.value = "";
      this._hue = 0;
      this._saturation = 100;
      this._value = 100;
      this._alpha = 100;
    }
    compare(color) {
      const compareColor = new TinyColor({
        h: color._hue,
        s: color._saturation / 100,
        v: color._value / 100,
        a: color._alpha / 100
      });
      return this._tiny.equals(compareColor);
    }
    doOnChange() {
      const { _hue, _saturation, _value, _alpha, format, enableAlpha } = this;
      let _format = format || (enableAlpha ? "rgb" : "hex");
      if (format === "hex" && enableAlpha) {
        _format = "hex8";
      }
      this._tiny = new TinyColor({
        h: _hue,
        s: _saturation / 100,
        v: _value / 100,
        a: _alpha / 100
      });
      this.value = this._isValid ? this._tiny.toString(_format) : "";
    }
  }

  const usePredefine = (props) => {
    const { currentColor } = vue.inject(colorPickerPanelContextKey);
    const rgbaColors = vue.ref(parseColors(props.colors, props.color));
    vue.watch(() => currentColor.value, (val) => {
      const color = new Color({
        value: val,
        enableAlpha: props.enableAlpha
      });
      rgbaColors.value.forEach((item) => {
        item.selected = color.compare(item);
      });
    });
    vue.watchEffect(() => {
      rgbaColors.value = parseColors(props.colors, props.color);
    });
    function handleSelect(index) {
      props.color.fromString(props.colors[index]);
    }
    function parseColors(colors, color) {
      return colors.map((value) => {
        const c = new Color({
          value,
          enableAlpha: props.enableAlpha
        });
        c.selected = c.compare(color);
        return c;
      });
    }
    return {
      rgbaColors,
      handleSelect
    };
  };
  const usePredefineDOM = (props) => {
    const ns = useNamespace("color-predefine");
    const rootKls = vue.computed(() => [ns.b(), ns.is("disabled", props.disabled)]);
    const colorsKls = vue.computed(() => ns.e("colors"));
    function colorSelectorKls(item) {
      return [
        ns.e("color-selector"),
        ns.is("alpha", item.get("alpha") < 100),
        { selected: item.selected }
      ];
    }
    return {
      rootKls,
      colorsKls,
      colorSelectorKls
    };
  };

  const __default__$1c = vue.defineComponent({
    name: "ElColorPredefine"
  });
  const _sfc_main$1E = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1c,
    props: predefineProps,
    setup(__props) {
      const props = __props;
      const { rgbaColors, handleSelect } = usePredefine(props);
      const { rootKls, colorsKls, colorSelectorKls } = usePredefineDOM(props);
      const { t } = useLocale();
      const ariaLabel = (value) => {
        return t("el.colorpicker.predefineDescription", { value });
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(rootKls))
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(colorsKls))
          }, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rgbaColors), (item, index) => {
              return vue.openBlock(), vue.createElementBlock("button", {
                key: _ctx.colors[index],
                type: "button",
                disabled: _ctx.disabled,
                "aria-label": ariaLabel(item.value),
                class: vue.normalizeClass(vue.unref(colorSelectorKls)(item)),
                onClick: ($event) => vue.unref(handleSelect)(index)
              }, [
                vue.createElementVNode("div", {
                  style: vue.normalizeStyle({ backgroundColor: item.value })
                }, null, 4)
              ], 10, ["disabled", "aria-label", "onClick"]);
            }), 128))
          ], 2)
        ], 2);
      };
    }
  });
  var Predefine = /* @__PURE__ */ _export_sfc(_sfc_main$1E, [["__file", "predefine.vue"]]);

  const svPanelProps = buildProps({
    color: {
      type: definePropType(Object),
      required: true
    },
    disabled: Boolean
  });

  const useSvPanel = (props) => {
    const instance = vue.getCurrentInstance();
    const cursorRef = vue.ref();
    const cursorTop = vue.ref(0);
    const cursorLeft = vue.ref(0);
    const background = vue.ref("hsl(0, 100%, 50%)");
    const saturation = vue.computed(() => props.color.get("saturation"));
    const brightness = vue.computed(() => props.color.get("value"));
    const hue = vue.computed(() => props.color.get("hue"));
    function handleClick(event) {
      var _a;
      if (props.disabled)
        return;
      const target = event.target;
      if (target !== cursorRef.value) {
        handleDrag(event);
      }
      (_a = cursorRef.value) == null ? void 0 : _a.focus({ preventScroll: true });
    }
    function handleDrag(event) {
      if (props.disabled)
        return;
      const el = instance.vnode.el;
      const rect = el.getBoundingClientRect();
      const { clientX, clientY } = getClientXY(event);
      let left = clientX - rect.left;
      let top = clientY - rect.top;
      left = Math.max(0, left);
      left = Math.min(left, rect.width);
      top = Math.max(0, top);
      top = Math.min(top, rect.height);
      cursorLeft.value = left;
      cursorTop.value = top;
      props.color.set({
        saturation: left / rect.width * 100,
        value: 100 - top / rect.height * 100
      });
    }
    function handleKeydown(event) {
      if (props.disabled)
        return;
      const { shiftKey } = event;
      const code = getEventCode(event);
      const step = shiftKey ? 10 : 1;
      let isPreventDefault = true;
      switch (code) {
        case EVENT_CODE.left:
          incrementSaturation(-step);
          break;
        case EVENT_CODE.right:
          incrementSaturation(step);
          break;
        case EVENT_CODE.up:
          incrementBrightness(step);
          break;
        case EVENT_CODE.down:
          incrementBrightness(-step);
          break;
        default:
          isPreventDefault = false;
          break;
      }
      isPreventDefault && event.preventDefault();
    }
    function incrementSaturation(step) {
      let next = saturation.value + step;
      next = next < 0 ? 0 : next > 100 ? 100 : next;
      props.color.set("saturation", next);
    }
    function incrementBrightness(step) {
      let next = brightness.value + step;
      next = next < 0 ? 0 : next > 100 ? 100 : next;
      props.color.set("value", next);
    }
    return {
      cursorRef,
      cursorTop,
      cursorLeft,
      background,
      saturation,
      brightness,
      hue,
      handleClick,
      handleDrag,
      handleKeydown
    };
  };
  const useSvPanelDOM = (props, {
    cursorTop,
    cursorLeft,
    background,
    handleDrag
  }) => {
    const instance = vue.getCurrentInstance();
    const ns = useNamespace("color-svpanel");
    function update() {
      const saturation = props.color.get("saturation");
      const brightness = props.color.get("value");
      const el = instance.vnode.el;
      const { clientWidth: width, clientHeight: height } = el;
      cursorLeft.value = saturation * width / 100;
      cursorTop.value = (100 - brightness) * height / 100;
      background.value = `hsl(${props.color.get("hue")}, 100%, 50%)`;
    }
    vue.onMounted(() => {
      draggable(instance.vnode.el, {
        drag: (event) => {
          handleDrag(event);
        },
        end: (event) => {
          handleDrag(event);
        }
      });
      update();
    });
    vue.watch([
      () => props.color.get("hue"),
      () => props.color.get("value"),
      () => props.color.value
    ], () => update());
    const rootKls = vue.computed(() => ns.b());
    const cursorKls = vue.computed(() => ns.e("cursor"));
    const rootStyle = vue.computed(() => ({
      backgroundColor: background.value
    }));
    const cursorStyle = vue.computed(() => ({
      top: addUnit(cursorTop.value),
      left: addUnit(cursorLeft.value)
    }));
    return {
      rootKls,
      cursorKls,
      rootStyle,
      cursorStyle,
      update
    };
  };

  const __default__$1b = vue.defineComponent({
    name: "ElSvPanel"
  });
  const _sfc_main$1D = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1b,
    props: svPanelProps,
    setup(__props, { expose }) {
      const props = __props;
      const {
        cursorRef,
        cursorTop,
        cursorLeft,
        background,
        saturation,
        brightness,
        handleClick,
        handleDrag,
        handleKeydown
      } = useSvPanel(props);
      const { rootKls, cursorKls, rootStyle, cursorStyle, update } = useSvPanelDOM(props, {
        cursorTop,
        cursorLeft,
        background,
        handleDrag
      });
      const { t } = useLocale();
      const ariaLabel = vue.computed(() => t("el.colorpicker.svLabel"));
      const ariaValuetext = vue.computed(() => {
        return t("el.colorpicker.svDescription", {
          saturation: saturation.value,
          brightness: brightness.value,
          color: props.color.value
        });
      });
      expose({
        update
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(rootKls)),
          style: vue.normalizeStyle(vue.unref(rootStyle)),
          onClick: vue.unref(handleClick)
        }, [
          vue.createElementVNode("div", {
            ref_key: "cursorRef",
            ref: cursorRef,
            class: vue.normalizeClass(vue.unref(cursorKls)),
            style: vue.normalizeStyle(vue.unref(cursorStyle)),
            tabindex: "0",
            role: "slider",
            "aria-valuemin": "0,0",
            "aria-valuemax": "100,100",
            "aria-label": vue.unref(ariaLabel),
            "aria-valuenow": `${vue.unref(saturation)},${vue.unref(brightness)}`,
            "aria-valuetext": vue.unref(ariaValuetext),
            onKeydown: vue.unref(handleKeydown)
          }, null, 46, ["aria-label", "aria-valuenow", "aria-valuetext", "onKeydown"])
        ], 14, ["onClick"]);
      };
    }
  });
  var SvPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1D, [["__file", "sv-panel.vue"]]);

  const useCommonColor = (props, emit) => {
    const color = vue.reactive(new Color({
      enableAlpha: props.showAlpha,
      format: props.colorFormat || "",
      value: props.modelValue
    }));
    vue.watch(() => [props.colorFormat, props.showAlpha], () => {
      color.enableAlpha = props.showAlpha;
      color.format = props.colorFormat || color.format;
      color.doOnChange();
      emit(UPDATE_MODEL_EVENT, color.value);
    });
    return {
      color
    };
  };

  const __default__$1a = vue.defineComponent({
    name: "ElColorPickerPanel"
  });
  const _sfc_main$1C = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1a,
    props: colorPickerPanelProps,
    emits: colorPickerPanelEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("color-picker-panel");
      const { formItem } = useFormItem();
      const disabled = useFormDisabled();
      const hueRef = vue.ref();
      const svRef = vue.ref();
      const alphaRef = vue.ref();
      const inputRef = vue.ref();
      const customInput = vue.ref("");
      const { color } = vue.inject(ROOT_COMMON_COLOR_INJECTION_KEY, () => useCommonColor(props, emit), true);
      function handleConfirm() {
        color.fromString(customInput.value);
        if (color.value !== customInput.value) {
          customInput.value = color.value;
        }
      }
      function handleFocusout() {
        var _a;
        if (props.validateEvent) {
          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
        }
      }
      function update() {
        var _a, _b, _c;
        (_a = hueRef.value) == null ? void 0 : _a.update();
        (_b = svRef.value) == null ? void 0 : _b.update();
        (_c = alphaRef.value) == null ? void 0 : _c.update();
      }
      vue.onMounted(() => {
        if (props.modelValue) {
          customInput.value = color.value;
        }
        vue.nextTick(update);
      });
      vue.watch(() => props.modelValue, (newVal) => {
        if (newVal !== color.value) {
          newVal ? color.fromString(newVal) : color.clear();
        }
      });
      vue.watch(() => color.value, (val) => {
        emit(UPDATE_MODEL_EVENT, val);
        customInput.value = val;
        if (props.validateEvent) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
        }
      });
      vue.provide(colorPickerPanelContextKey, {
        currentColor: vue.computed(() => color.value)
      });
      expose({
        color,
        inputRef,
        update
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).is("disabled", vue.unref(disabled)), vue.unref(ns).is("border", _ctx.border)]),
          onFocusout: handleFocusout
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("wrapper"))
          }, [
            vue.createVNode(HueSlider, {
              ref_key: "hueRef",
              ref: hueRef,
              class: "hue-slider",
              color: vue.unref(color),
              vertical: "",
              disabled: vue.unref(disabled)
            }, null, 8, ["color", "disabled"]),
            vue.createVNode(SvPanel, {
              ref_key: "svRef",
              ref: svRef,
              color: vue.unref(color),
              disabled: vue.unref(disabled)
            }, null, 8, ["color", "disabled"])
          ], 2),
          _ctx.showAlpha ? (vue.openBlock(), vue.createBlock(AlphaSlider, {
            key: 0,
            ref_key: "alphaRef",
            ref: alphaRef,
            color: vue.unref(color),
            disabled: vue.unref(disabled)
          }, null, 8, ["color", "disabled"])) : vue.createCommentVNode("v-if", true),
          _ctx.predefine ? (vue.openBlock(), vue.createBlock(Predefine, {
            key: 1,
            ref: "predefine",
            "enable-alpha": _ctx.showAlpha,
            color: vue.unref(color),
            colors: _ctx.predefine,
            disabled: vue.unref(disabled)
          }, null, 8, ["enable-alpha", "color", "colors", "disabled"])) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("footer"))
          }, [
            vue.createVNode(vue.unref(ElInput), {
              ref_key: "inputRef",
              ref: inputRef,
              modelValue: customInput.value,
              "onUpdate:modelValue": ($event) => customInput.value = $event,
              "validate-event": false,
              size: "small",
              disabled: vue.unref(disabled),
              onChange: handleConfirm
            }, null, 8, ["modelValue", "onUpdate:modelValue", "disabled"]),
            vue.renderSlot(_ctx.$slots, "footer")
          ], 2)
        ], 34);
      };
    }
  });
  var ColorPickerPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1C, [["__file", "color-picker-panel.vue"]]);

  const ElColorPickerPanel = withInstall(ColorPickerPanel);

  const colorPickerProps = buildProps({
    persistent: {
      type: Boolean,
      default: true
    },
    modelValue: {
      type: definePropType(String),
      default: void 0
    },
    id: String,
    showAlpha: Boolean,
    colorFormat: String,
    disabled: Boolean,
    size: useSizeProp,
    popperClass: useTooltipContentProps.popperClass,
    popperStyle: useTooltipContentProps.popperStyle,
    tabindex: {
      type: [String, Number],
      default: 0
    },
    teleported: useTooltipContentProps.teleported,
    appendTo: useTooltipContentProps.appendTo,
    predefine: {
      type: definePropType(Array)
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    ...useEmptyValuesProps,
    ...useAriaProps(["ariaLabel"])
  });
  const colorPickerEmits = {
    [UPDATE_MODEL_EVENT]: (val) => isString$1(val) || isNil(val),
    [CHANGE_EVENT]: (val) => isString$1(val) || isNil(val),
    activeChange: (val) => isString$1(val) || isNil(val),
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent
  };

  const __default__$19 = vue.defineComponent({
    name: "ElColorPicker"
  });
  const _sfc_main$1B = /* @__PURE__ */ vue.defineComponent({
    ...__default__$19,
    props: colorPickerProps,
    emits: colorPickerEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const { t } = useLocale();
      const ns = useNamespace("color");
      const { formItem } = useFormItem();
      const colorSize = useFormSize();
      const colorDisabled = useFormDisabled();
      const { valueOnClear, isEmptyValue } = useEmptyValues(props, null);
      const commonColor = useCommonColor(props, emit);
      const { inputId: buttonId, isLabeledByFormItem } = useFormItemInputId(props, {
        formItemContext: formItem
      });
      const popper = vue.ref();
      const triggerRef = vue.ref();
      const pickerPanelRef = vue.ref();
      const showPicker = vue.ref(false);
      const showPanelColor = vue.ref(false);
      let shouldActiveChange = true;
      const { isFocused, handleFocus, handleBlur } = useFocusController(triggerRef, {
        disabled: colorDisabled,
        beforeBlur(event) {
          var _a;
          return (_a = popper.value) == null ? void 0 : _a.isFocusInsideContent(event);
        },
        afterBlur() {
          var _a;
          setShowPicker(false);
          resetColor();
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
          }
        }
      });
      const color = reactiveComputed(() => {
        var _a, _b;
        return (_b = (_a = pickerPanelRef.value) == null ? void 0 : _a.color) != null ? _b : commonColor.color;
      });
      const panelProps = vue.computed(() => pick(props, Object.keys(colorPickerPanelProps)));
      const displayedColor = vue.computed(() => {
        if (!props.modelValue && !showPanelColor.value) {
          return "transparent";
        }
        return displayedRgb(color, props.showAlpha);
      });
      const currentColor = vue.computed(() => {
        return !props.modelValue && !showPanelColor.value ? "" : color.value;
      });
      const buttonAriaLabel = vue.computed(() => {
        return !isLabeledByFormItem.value ? props.ariaLabel || t("el.colorpicker.defaultLabel") : void 0;
      });
      const buttonAriaLabelledby = vue.computed(() => {
        return isLabeledByFormItem.value ? formItem == null ? void 0 : formItem.labelId : void 0;
      });
      const btnKls = vue.computed(() => {
        return [
          ns.b("picker"),
          ns.is("disabled", colorDisabled.value),
          ns.bm("picker", colorSize.value),
          ns.is("focused", isFocused.value)
        ];
      });
      function displayedRgb(color2, showAlpha) {
        const { r, g, b, a } = color2.toRgb();
        return showAlpha ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`;
      }
      function setShowPicker(value) {
        showPicker.value = value;
      }
      const debounceSetShowPicker = debounce(setShowPicker, 100, { leading: true });
      function show() {
        if (colorDisabled.value)
          return;
        setShowPicker(true);
      }
      function hide() {
        debounceSetShowPicker(false);
        resetColor();
      }
      function resetColor() {
        vue.nextTick(() => {
          if (props.modelValue) {
            color.fromString(props.modelValue);
          } else {
            color.value = "";
            vue.nextTick(() => {
              showPanelColor.value = false;
            });
          }
        });
      }
      function handleTrigger() {
        if (colorDisabled.value)
          return;
        if (showPicker.value) {
          resetColor();
        }
        debounceSetShowPicker(!showPicker.value);
      }
      function confirmValue() {
        const value = isEmptyValue(color.value) ? valueOnClear.value : color.value;
        emit(UPDATE_MODEL_EVENT, value);
        emit(CHANGE_EVENT, value);
        if (props.validateEvent) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
        }
        debounceSetShowPicker(false);
        vue.nextTick(() => {
          const newColor = new Color({
            enableAlpha: props.showAlpha,
            format: props.colorFormat || "",
            value: props.modelValue
          });
          if (!color.compare(newColor)) {
            resetColor();
          }
        });
      }
      function clear() {
        debounceSetShowPicker(false);
        emit(UPDATE_MODEL_EVENT, valueOnClear.value);
        emit(CHANGE_EVENT, valueOnClear.value);
        if (props.modelValue !== valueOnClear.value && props.validateEvent) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
        }
        resetColor();
      }
      function handleShowTooltip() {
        var _a, _b;
        (_b = (_a = pickerPanelRef == null ? void 0 : pickerPanelRef.value) == null ? void 0 : _a.inputRef) == null ? void 0 : _b.focus();
      }
      function handleClickOutside() {
        if (!showPicker.value)
          return;
        hide();
        isFocused.value && focus();
      }
      function handleEsc(event) {
        event.preventDefault();
        event.stopPropagation();
        setShowPicker(false);
        resetColor();
      }
      function handleKeyDown(event) {
        const code = getEventCode(event);
        switch (code) {
          case EVENT_CODE.enter:
          case EVENT_CODE.numpadEnter:
          case EVENT_CODE.space:
            event.preventDefault();
            event.stopPropagation();
            show();
            break;
          case EVENT_CODE.esc:
            handleEsc(event);
            break;
        }
      }
      function focus() {
        triggerRef.value.focus();
      }
      function blur() {
        triggerRef.value.blur();
      }
      vue.watch(() => currentColor.value, (val) => {
        shouldActiveChange && emit("activeChange", val);
        shouldActiveChange = true;
      });
      vue.watch(() => color.value, () => {
        if (!props.modelValue && !showPanelColor.value) {
          showPanelColor.value = true;
        }
      });
      vue.watch(() => props.modelValue, (newVal) => {
        if (!newVal) {
          showPanelColor.value = false;
        } else if (newVal && newVal !== color.value) {
          shouldActiveChange = false;
          color.fromString(newVal);
        }
      });
      vue.watch(() => showPicker.value, () => {
        var _a;
        vue.nextTick((_a = pickerPanelRef.value) == null ? void 0 : _a.update);
      });
      vue.provide(ROOT_COMMON_COLOR_INJECTION_KEY, commonColor);
      expose({
        color,
        show,
        hide,
        focus,
        blur
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
          ref_key: "popper",
          ref: popper,
          visible: showPicker.value,
          "show-arrow": false,
          "fallback-placements": ["bottom", "top", "right", "left"],
          offset: 0,
          "gpu-acceleration": false,
          "popper-class": [vue.unref(ns).be("picker", "panel"), _ctx.popperClass],
          "popper-style": _ctx.popperStyle,
          "stop-popper-mouse-event": false,
          pure: "",
          loop: "",
          role: "dialog",
          effect: "light",
          trigger: "click",
          teleported: _ctx.teleported,
          transition: `${vue.unref(ns).namespace.value}-zoom-in-top`,
          persistent: _ctx.persistent,
          "append-to": _ctx.appendTo,
          onShow: handleShowTooltip,
          onHide: ($event) => setShowPicker(false)
        }, {
          content: vue.withCtx(() => [
            vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElColorPickerPanel), vue.mergeProps({
              ref_key: "pickerPanelRef",
              ref: pickerPanelRef
            }, vue.unref(panelProps), {
              border: false,
              "validate-event": false,
              onKeydown: vue.withKeys(handleEsc, ["esc"])
            }), {
              footer: vue.withCtx(() => [
                vue.createElementVNode("div", null, [
                  vue.createVNode(vue.unref(ElButton), {
                    class: vue.normalizeClass(vue.unref(ns).be("footer", "link-btn")),
                    text: "",
                    size: "small",
                    onClick: clear
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.colorpicker.clear")), 1)
                    ]),
                    _: 1
                  }, 8, ["class"]),
                  vue.createVNode(vue.unref(ElButton), {
                    plain: "",
                    size: "small",
                    class: vue.normalizeClass(vue.unref(ns).be("footer", "btn")),
                    onClick: confirmValue
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.colorpicker.confirm")), 1)
                    ]),
                    _: 1
                  }, 8, ["class"])
                ])
              ]),
              _: 1
            }, 16, ["onKeydown"])), [
              [vue.unref(ClickOutside), handleClickOutside, triggerRef.value]
            ])
          ]),
          default: vue.withCtx(() => [
            vue.createElementVNode("div", vue.mergeProps({
              id: vue.unref(buttonId),
              ref_key: "triggerRef",
              ref: triggerRef
            }, _ctx.$attrs, {
              class: vue.unref(btnKls),
              role: "button",
              "aria-label": vue.unref(buttonAriaLabel),
              "aria-labelledby": vue.unref(buttonAriaLabelledby),
              "aria-description": vue.unref(t)("el.colorpicker.description", { color: _ctx.modelValue || "" }),
              "aria-disabled": vue.unref(colorDisabled),
              tabindex: vue.unref(colorDisabled) ? void 0 : _ctx.tabindex,
              onKeydown: handleKeyDown,
              onFocus: vue.unref(handleFocus),
              onBlur: vue.unref(handleBlur)
            }), [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).be("picker", "trigger")),
                onClick: handleTrigger
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass([vue.unref(ns).be("picker", "color"), vue.unref(ns).is("alpha", _ctx.showAlpha)])
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(ns).be("picker", "color-inner")),
                    style: vue.normalizeStyle({
                      backgroundColor: vue.unref(displayedColor)
                    })
                  }, [
                    vue.withDirectives(vue.createVNode(vue.unref(ElIcon), {
                      class: vue.normalizeClass([vue.unref(ns).be("picker", "icon"), vue.unref(ns).is("icon-arrow-down")])
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(arrow_down_default))
                      ]),
                      _: 1
                    }, 8, ["class"]), [
                      [vue.vShow, _ctx.modelValue || showPanelColor.value]
                    ]),
                    vue.withDirectives(vue.createVNode(vue.unref(ElIcon), {
                      class: vue.normalizeClass([vue.unref(ns).be("picker", "empty"), vue.unref(ns).is("icon-close")])
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(close_default))
                      ]),
                      _: 1
                    }, 8, ["class"]), [
                      [vue.vShow, !_ctx.modelValue && !showPanelColor.value]
                    ])
                  ], 6)
                ], 2)
              ], 2)
            ], 16, ["id", "aria-label", "aria-labelledby", "aria-description", "aria-disabled", "tabindex", "onFocus", "onBlur"])
          ]),
          _: 1
        }, 8, ["visible", "popper-class", "popper-style", "teleported", "transition", "persistent", "append-to", "onHide"]);
      };
    }
  });
  var ColorPicker = /* @__PURE__ */ _export_sfc(_sfc_main$1B, [["__file", "color-picker.vue"]]);

  const ElColorPicker = withInstall(ColorPicker);

  const __default__$18 = vue.defineComponent({
    name: "ElContainer"
  });
  const _sfc_main$1A = /* @__PURE__ */ vue.defineComponent({
    ...__default__$18,
    props: buildProps({
      direction: {
        type: String,
        values: ["horizontal", "vertical"]
      }
    }),
    setup(__props) {
      const props = __props;
      const slots = vue.useSlots();
      const ns = useNamespace("container");
      const isVertical = vue.computed(() => {
        if (props.direction === "vertical") {
          return true;
        } else if (props.direction === "horizontal") {
          return false;
        }
        if (slots && slots.default) {
          const vNodes = slots.default();
          return vNodes.some((vNode) => {
            const tag = vNode.type.name;
            return tag === "ElHeader" || tag === "ElFooter";
          });
        } else {
          return false;
        }
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("section", {
          class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).is("vertical", vue.unref(isVertical))])
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2);
      };
    }
  });
  var Container = /* @__PURE__ */ _export_sfc(_sfc_main$1A, [["__file", "container.vue"]]);

  const __default__$17 = vue.defineComponent({
    name: "ElAside"
  });
  const _sfc_main$1z = /* @__PURE__ */ vue.defineComponent({
    ...__default__$17,
    props: {
      width: {
        type: String,
        default: null
      }
    },
    setup(__props) {
      const props = __props;
      const ns = useNamespace("aside");
      const style = vue.computed(() => props.width ? ns.cssVarBlock({ width: props.width }) : {});
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("aside", {
          class: vue.normalizeClass(vue.unref(ns).b()),
          style: vue.normalizeStyle(vue.unref(style))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 6);
      };
    }
  });
  var Aside = /* @__PURE__ */ _export_sfc(_sfc_main$1z, [["__file", "aside.vue"]]);

  const __default__$16 = vue.defineComponent({
    name: "ElFooter"
  });
  const _sfc_main$1y = /* @__PURE__ */ vue.defineComponent({
    ...__default__$16,
    props: {
      height: {
        type: String,
        default: null
      }
    },
    setup(__props) {
      const props = __props;
      const ns = useNamespace("footer");
      const style = vue.computed(() => props.height ? ns.cssVarBlock({ height: props.height }) : {});
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("footer", {
          class: vue.normalizeClass(vue.unref(ns).b()),
          style: vue.normalizeStyle(vue.unref(style))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 6);
      };
    }
  });
  var Footer$2 = /* @__PURE__ */ _export_sfc(_sfc_main$1y, [["__file", "footer.vue"]]);

  const __default__$15 = vue.defineComponent({
    name: "ElHeader"
  });
  const _sfc_main$1x = /* @__PURE__ */ vue.defineComponent({
    ...__default__$15,
    props: {
      height: {
        type: String,
        default: null
      }
    },
    setup(__props) {
      const props = __props;
      const ns = useNamespace("header");
      const style = vue.computed(() => {
        return props.height ? ns.cssVarBlock({
          height: props.height
        }) : {};
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("header", {
          class: vue.normalizeClass(vue.unref(ns).b()),
          style: vue.normalizeStyle(vue.unref(style))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 6);
      };
    }
  });
  var Header$1 = /* @__PURE__ */ _export_sfc(_sfc_main$1x, [["__file", "header.vue"]]);

  const __default__$14 = vue.defineComponent({
    name: "ElMain"
  });
  const _sfc_main$1w = /* @__PURE__ */ vue.defineComponent({
    ...__default__$14,
    setup(__props) {
      const ns = useNamespace("main");
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("main", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2);
      };
    }
  });
  var Main = /* @__PURE__ */ _export_sfc(_sfc_main$1w, [["__file", "main.vue"]]);

  const ElContainer = withInstall(Container, {
    Aside,
    Footer: Footer$2,
    Header: Header$1,
    Main
  });
  const ElAside = withNoopInstall(Aside);
  const ElFooter = withNoopInstall(Footer$2);
  const ElHeader = withNoopInstall(Header$1);
  const ElMain = withNoopInstall(Main);

  var advancedFormat$1 = {exports: {}};

  (function(module, exports) {
    !function(e, t) {
      module.exports = t() ;
    }(commonjsGlobal, function() {
      return function(e, t) {
        var r = t.prototype, n = r.format;
        r.format = function(e2) {
          var t2 = this, r2 = this.$locale();
          if (!this.isValid())
            return n.bind(this)(e2);
          var s = this.$utils(), a = (e2 || "YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g, function(e3) {
            switch (e3) {
              case "Q":
                return Math.ceil((t2.$M + 1) / 3);
              case "Do":
                return r2.ordinal(t2.$D);
              case "gggg":
                return t2.weekYear();
              case "GGGG":
                return t2.isoWeekYear();
              case "wo":
                return r2.ordinal(t2.week(), "W");
              case "w":
              case "ww":
                return s.s(t2.week(), e3 === "w" ? 1 : 2, "0");
              case "W":
              case "WW":
                return s.s(t2.isoWeek(), e3 === "W" ? 1 : 2, "0");
              case "k":
              case "kk":
                return s.s(String(t2.$H === 0 ? 24 : t2.$H), e3 === "k" ? 1 : 2, "0");
              case "X":
                return Math.floor(t2.$d.getTime() / 1e3);
              case "x":
                return t2.$d.getTime();
              case "z":
                return "[" + t2.offsetName() + "]";
              case "zzz":
                return "[" + t2.offsetName("long") + "]";
              default:
                return e3;
            }
          });
          return n.bind(this)(a);
        };
      };
    });
  })(advancedFormat$1);
  var advancedFormat = advancedFormat$1.exports;

  var weekOfYear$1 = {exports: {}};

  (function(module, exports) {
    !function(e, t) {
      module.exports = t() ;
    }(commonjsGlobal, function() {
      var e = "week", t = "year";
      return function(i, n, r) {
        var f = n.prototype;
        f.week = function(i2) {
          if (i2 === void 0 && (i2 = null), i2 !== null)
            return this.add(7 * (i2 - this.week()), "day");
          var n2 = this.$locale().yearStart || 1;
          if (this.month() === 11 && this.date() > 25) {
            var f2 = r(this).startOf(t).add(1, t).date(n2), s = r(this).endOf(e);
            if (f2.isBefore(s))
              return 1;
          }
          var a = r(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o = this.diff(a, e, true);
          return o < 0 ? r(this).startOf("week").week() : Math.ceil(o);
        }, f.weeks = function(e2) {
          return e2 === void 0 && (e2 = null), this.week(e2);
        };
      };
    });
  })(weekOfYear$1);
  var weekOfYear = weekOfYear$1.exports;

  var weekYear$1 = {exports: {}};

  (function(module, exports) {
    !function(e, t) {
      module.exports = t() ;
    }(commonjsGlobal, function() {
      return function(e, t) {
        t.prototype.weekYear = function() {
          var e2 = this.month(), t2 = this.week(), n = this.year();
          return t2 === 1 && e2 === 11 ? n + 1 : e2 === 0 && t2 >= 52 ? n - 1 : n;
        };
      };
    });
  })(weekYear$1);
  var weekYear = weekYear$1.exports;

  var dayOfYear$1 = {exports: {}};

  (function(module, exports) {
    !function(e, t) {
      module.exports = t() ;
    }(commonjsGlobal, function() {
      return function(e, t, n) {
        t.prototype.dayOfYear = function(e2) {
          var t2 = Math.round((n(this).startOf("day") - n(this).startOf("year")) / 864e5) + 1;
          return e2 == null ? t2 : this.add(e2 - t2, "day");
        };
      };
    });
  })(dayOfYear$1);
  var dayOfYear = dayOfYear$1.exports;

  var isSameOrAfter$1 = {exports: {}};

  (function(module, exports) {
    !function(e, t) {
      module.exports = t() ;
    }(commonjsGlobal, function() {
      return function(e, t) {
        t.prototype.isSameOrAfter = function(e2, t2) {
          return this.isSame(e2, t2) || this.isAfter(e2, t2);
        };
      };
    });
  })(isSameOrAfter$1);
  var isSameOrAfter = isSameOrAfter$1.exports;

  var isSameOrBefore$1 = {exports: {}};

  (function(module, exports) {
    !function(e, i) {
      module.exports = i() ;
    }(commonjsGlobal, function() {
      return function(e, i) {
        i.prototype.isSameOrBefore = function(e2, i2) {
          return this.isSame(e2, i2) || this.isBefore(e2, i2);
        };
      };
    });
  })(isSameOrBefore$1);
  var isSameOrBefore = isSameOrBefore$1.exports;

  const datePickerPanelProps = buildProps({
    valueFormat: String,
    dateFormat: String,
    timeFormat: String,
    disabled: Boolean,
    modelValue: {
      type: definePropType([Date, Array, String, Number]),
      default: ""
    },
    defaultValue: {
      type: definePropType([Date, Array])
    },
    defaultTime: {
      type: definePropType([Date, Array])
    },
    isRange: Boolean,
    ...disabledTimeListsProps,
    disabledDate: {
      type: Function
    },
    cellClassName: {
      type: Function
    },
    shortcuts: {
      type: Array,
      default: () => []
    },
    arrowControl: Boolean,
    unlinkPanels: Boolean,
    showNow: {
      type: Boolean,
      default: true
    },
    showConfirm: Boolean,
    showFooter: Boolean,
    showWeekNumber: Boolean,
    type: {
      type: definePropType(String),
      default: "date"
    },
    clearable: {
      type: Boolean,
      default: true
    },
    border: {
      type: Boolean,
      default: true
    }
  });

  const ROOT_PICKER_INJECTION_KEY = Symbol("rootPickerContextKey");
  const ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = "ElIsDefaultFormat";

  const selectionModes = [
    "date",
    "dates",
    "year",
    "years",
    "month",
    "months",
    "week",
    "range"
  ];
  const datePickerSharedProps = buildProps({
    cellClassName: {
      type: definePropType(Function)
    },
    disabledDate: {
      type: definePropType(Function)
    },
    date: {
      type: definePropType(Object),
      required: true
    },
    minDate: {
      type: definePropType(Object)
    },
    maxDate: {
      type: definePropType(Object)
    },
    parsedValue: {
      type: definePropType([Object, Array])
    },
    rangeState: {
      type: definePropType(Object),
      default: () => ({
        endDate: null,
        selecting: false
      })
    },
    disabled: Boolean
  });
  const panelSharedProps = buildProps({
    type: {
      type: definePropType(String),
      required: true,
      values: datePickTypes
    },
    dateFormat: String,
    timeFormat: String,
    showNow: {
      type: Boolean,
      default: true
    },
    showConfirm: Boolean,
    showFooter: {
      type: Boolean,
      default: true
    },
    showWeekNumber: Boolean,
    border: Boolean,
    disabled: Boolean
  });
  const panelRangeSharedProps = buildProps({
    unlinkPanels: Boolean,
    visible: {
      type: Boolean,
      default: true
    },
    showConfirm: Boolean,
    showFooter: {
      type: Boolean,
      default: true
    },
    border: Boolean,
    disabled: Boolean,
    parsedValue: {
      type: definePropType(Array)
    }
  });
  const selectionModeWithDefault = (mode) => {
    return {
      type: String,
      values: selectionModes,
      default: mode
    };
  };

  const panelDatePickProps = buildProps({
    ...panelSharedProps,
    parsedValue: {
      type: definePropType([Object, Array])
    },
    visible: {
      type: Boolean,
      default: true
    },
    format: {
      type: String,
      default: ""
    }
  });

  const isValidRange = (range) => {
    if (!isArray$1(range))
      return false;
    const [left, right] = range;
    return dayjs.isDayjs(left) && dayjs.isDayjs(right) && dayjs(left).isValid() && dayjs(right).isValid() && left.isSameOrBefore(right);
  };
  const getDefaultValue = (defaultValue, { lang, step = 1, unit, unlinkPanels }) => {
    let start;
    if (isArray$1(defaultValue)) {
      let [left, right] = defaultValue.map((d) => dayjs(d).locale(lang));
      if (!unlinkPanels) {
        right = left.add(step, unit);
      }
      return [left, right];
    } else if (defaultValue) {
      start = dayjs(defaultValue);
    } else {
      start = dayjs();
    }
    start = start.locale(lang);
    return [start, start.add(step, unit)];
  };
  const buildPickerTable = (dimension, rows, {
    columnIndexOffset,
    startDate,
    nextEndDate,
    now,
    unit,
    relativeDateGetter,
    setCellMetadata,
    setRowMetadata
  }) => {
    for (let rowIndex = 0; rowIndex < dimension.row; rowIndex++) {
      const row = rows[rowIndex];
      for (let columnIndex = 0; columnIndex < dimension.column; columnIndex++) {
        let cell = row[columnIndex + columnIndexOffset];
        if (!cell) {
          cell = {
            row: rowIndex,
            column: columnIndex,
            type: "normal",
            inRange: false,
            start: false,
            end: false
          };
        }
        const index = rowIndex * dimension.column + columnIndex;
        const nextStartDate = relativeDateGetter(index);
        cell.dayjs = nextStartDate;
        cell.date = nextStartDate.toDate();
        cell.timestamp = nextStartDate.valueOf();
        cell.type = "normal";
        cell.inRange = !!(startDate && nextStartDate.isSameOrAfter(startDate, unit) && nextEndDate && nextStartDate.isSameOrBefore(nextEndDate, unit)) || !!(startDate && nextStartDate.isSameOrBefore(startDate, unit) && nextEndDate && nextStartDate.isSameOrAfter(nextEndDate, unit));
        if (startDate == null ? void 0 : startDate.isSameOrAfter(nextEndDate)) {
          cell.start = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit);
          cell.end = startDate && nextStartDate.isSame(startDate, unit);
        } else {
          cell.start = !!startDate && nextStartDate.isSame(startDate, unit);
          cell.end = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit);
        }
        const isToday = nextStartDate.isSame(now, unit);
        if (isToday) {
          cell.type = "today";
        }
        setCellMetadata == null ? void 0 : setCellMetadata(cell, { rowIndex, columnIndex });
        row[columnIndex + columnIndexOffset] = cell;
      }
      setRowMetadata == null ? void 0 : setRowMetadata(row);
    }
  };
  const datesInMonth = (date, year, month, lang) => {
    const firstDay = dayjs().locale(lang).startOf("month").month(month).year(year).hour(date.hour()).minute(date.minute()).second(date.second());
    const numOfDays = firstDay.daysInMonth();
    return rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
  };
  const getValidDateOfMonth = (date, year, month, lang, disabledDate) => {
    const _value = dayjs().year(year).month(month).startOf("month").hour(date.hour()).minute(date.minute()).second(date.second());
    const _date = datesInMonth(date, year, month, lang).find((date2) => {
      return !(disabledDate == null ? void 0 : disabledDate(date2));
    });
    if (_date) {
      return dayjs(_date).locale(lang);
    }
    return _value.locale(lang);
  };
  const getValidDateOfYear = (value, lang, disabledDate) => {
    const year = value.year();
    if (!(disabledDate == null ? void 0 : disabledDate(value.toDate()))) {
      return value.locale(lang);
    }
    const month = value.month();
    if (!datesInMonth(value, year, month, lang).every(disabledDate)) {
      return getValidDateOfMonth(value, year, month, lang, disabledDate);
    }
    for (let i = 0; i < 12; i++) {
      if (!datesInMonth(value, year, i, lang).every(disabledDate)) {
        return getValidDateOfMonth(value, year, i, lang, disabledDate);
      }
    }
    return value;
  };
  const correctlyParseUserInput = (value, format, lang, defaultFormat) => {
    if (isArray$1(value)) {
      return value.map((v) => correctlyParseUserInput(v, format, lang, defaultFormat));
    }
    if (isString$1(value)) {
      const dayjsValue = (defaultFormat == null ? void 0 : defaultFormat.value) ? dayjs(value) : dayjs(value, format);
      if (!dayjsValue.isValid()) {
        return dayjsValue;
      }
    }
    return dayjs(value, format).locale(lang);
  };

  const basicDateTableProps = buildProps({
    ...datePickerSharedProps,
    showWeekNumber: Boolean,
    selectionMode: selectionModeWithDefault("date")
  });
  const basicDateTableEmits = ["changerange", "pick", "select"];

  const isNormalDay = (type = "") => {
    return ["normal", "today"].includes(type);
  };
  const useBasicDateTable = (props, emit) => {
    const { lang } = useLocale();
    const tbodyRef = vue.ref();
    const currentCellRef = vue.ref();
    const lastRow = vue.ref();
    const lastColumn = vue.ref();
    const tableRows = vue.ref([[], [], [], [], [], []]);
    let focusWithClick = false;
    const firstDayOfWeek = props.date.$locale().weekStart || 7;
    const WEEKS_CONSTANT = props.date.locale("en").localeData().weekdaysShort().map((_) => _.toLowerCase());
    const offsetDay = vue.computed(() => {
      return firstDayOfWeek > 3 ? 7 - firstDayOfWeek : -firstDayOfWeek;
    });
    const startDate = vue.computed(() => {
      const startDayOfMonth = props.date.startOf("month");
      return startDayOfMonth.subtract(startDayOfMonth.day() || 7, "day");
    });
    const WEEKS = vue.computed(() => {
      return WEEKS_CONSTANT.concat(WEEKS_CONSTANT).slice(firstDayOfWeek, firstDayOfWeek + 7);
    });
    const hasCurrent = vue.computed(() => {
      return flatten(vue.unref(rows)).some((row) => {
        return row.isCurrent;
      });
    });
    const days = vue.computed(() => {
      const startOfMonth = props.date.startOf("month");
      const startOfMonthDay = startOfMonth.day() || 7;
      const dateCountOfMonth = startOfMonth.daysInMonth();
      const dateCountOfLastMonth = startOfMonth.subtract(1, "month").daysInMonth();
      return {
        startOfMonthDay,
        dateCountOfMonth,
        dateCountOfLastMonth
      };
    });
    const selectedDate = vue.computed(() => {
      return props.selectionMode === "dates" ? castArray(props.parsedValue) : [];
    });
    const setDateText = (cell, { count, rowIndex, columnIndex }) => {
      const { startOfMonthDay, dateCountOfMonth, dateCountOfLastMonth } = vue.unref(days);
      const offset = vue.unref(offsetDay);
      if (rowIndex >= 0 && rowIndex <= 1) {
        const numberOfDaysFromPreviousMonth = startOfMonthDay + offset < 0 ? 7 + startOfMonthDay + offset : startOfMonthDay + offset;
        if (columnIndex + rowIndex * 7 >= numberOfDaysFromPreviousMonth) {
          cell.text = count;
          return true;
        } else {
          cell.text = dateCountOfLastMonth - (numberOfDaysFromPreviousMonth - columnIndex % 7) + 1 + rowIndex * 7;
          cell.type = "prev-month";
        }
      } else {
        if (count <= dateCountOfMonth) {
          cell.text = count;
        } else {
          cell.text = count - dateCountOfMonth;
          cell.type = "next-month";
        }
        return true;
      }
      return false;
    };
    const setCellMetadata = (cell, { columnIndex, rowIndex }, count) => {
      const { disabledDate, cellClassName } = props;
      const _selectedDate = vue.unref(selectedDate);
      const shouldIncrement = setDateText(cell, { count, rowIndex, columnIndex });
      const cellDate = cell.dayjs.toDate();
      cell.selected = _selectedDate.find((d) => d.isSame(cell.dayjs, "day"));
      cell.isSelected = !!cell.selected;
      cell.isCurrent = isCurrent(cell);
      cell.disabled = disabledDate == null ? void 0 : disabledDate(cellDate);
      cell.customClass = cellClassName == null ? void 0 : cellClassName(cellDate);
      return shouldIncrement;
    };
    const setRowMetadata = (row) => {
      if (props.selectionMode === "week") {
        const [start, end] = props.showWeekNumber ? [1, 7] : [0, 6];
        const isActive = isWeekActive(row[start + 1]);
        row[start].inRange = isActive;
        row[start].start = isActive;
        row[end].inRange = isActive;
        row[end].end = isActive;
      }
    };
    const rows = vue.computed(() => {
      const { minDate, maxDate, rangeState, showWeekNumber } = props;
      const offset = vue.unref(offsetDay);
      const rows_ = vue.unref(tableRows);
      const dateUnit = "day";
      let count = 1;
      buildPickerTable({ row: 6, column: 7 }, rows_, {
        startDate: minDate,
        columnIndexOffset: showWeekNumber ? 1 : 0,
        nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
        now: dayjs().locale(vue.unref(lang)).startOf(dateUnit),
        unit: dateUnit,
        relativeDateGetter: (idx) => vue.unref(startDate).add(idx - offset, dateUnit),
        setCellMetadata: (...args) => {
          if (setCellMetadata(...args, count)) {
            count += 1;
          }
        },
        setRowMetadata
      });
      if (showWeekNumber) {
        for (let rowIndex = 0; rowIndex < 6; rowIndex++) {
          if (rows_[rowIndex][1].dayjs) {
            rows_[rowIndex][0] = {
              type: "week",
              text: rows_[rowIndex][1].dayjs.week()
            };
          }
        }
      }
      return rows_;
    });
    vue.watch(() => props.date, async () => {
      var _a;
      if ((_a = vue.unref(tbodyRef)) == null ? void 0 : _a.contains(document.activeElement)) {
        await vue.nextTick();
        await focus();
      }
    });
    const focus = async () => {
      var _a;
      return (_a = vue.unref(currentCellRef)) == null ? void 0 : _a.focus();
    };
    const isCurrent = (cell) => {
      return props.selectionMode === "date" && isNormalDay(cell.type) && cellMatchesDate(cell, props.parsedValue);
    };
    const cellMatchesDate = (cell, date) => {
      if (!date)
        return false;
      return dayjs(date).locale(vue.unref(lang)).isSame(props.date.date(Number(cell.text)), "day");
    };
    const getDateOfCell = (row, column) => {
      const offsetFromStart = row * 7 + (column - (props.showWeekNumber ? 1 : 0)) - vue.unref(offsetDay);
      return vue.unref(startDate).add(offsetFromStart, "day");
    };
    const handleMouseMove = (event) => {
      var _a;
      if (!props.rangeState.selecting)
        return;
      let target = event.target;
      if (target.tagName === "SPAN") {
        target = (_a = target.parentNode) == null ? void 0 : _a.parentNode;
      }
      if (target.tagName === "DIV") {
        target = target.parentNode;
      }
      if (target.tagName !== "TD")
        return;
      const row = target.parentNode.rowIndex - 1;
      const column = target.cellIndex;
      if (vue.unref(rows)[row][column].disabled)
        return;
      if (row !== vue.unref(lastRow) || column !== vue.unref(lastColumn)) {
        lastRow.value = row;
        lastColumn.value = column;
        emit("changerange", {
          selecting: true,
          endDate: getDateOfCell(row, column)
        });
      }
    };
    const isSelectedCell = (cell) => {
      return !vue.unref(hasCurrent) && (cell == null ? void 0 : cell.text) === 1 && cell.type === "normal" || cell.isCurrent;
    };
    const handleFocus = (event) => {
      if (focusWithClick || vue.unref(hasCurrent) || props.selectionMode !== "date")
        return;
      handlePickDate(event, true);
    };
    const handleMouseDown = (event) => {
      const target = event.target.closest("td");
      if (!target)
        return;
      focusWithClick = true;
    };
    const handleMouseUp = (event) => {
      const target = event.target.closest("td");
      if (!target)
        return;
      focusWithClick = false;
    };
    const handleRangePick = (newDate) => {
      if (!props.rangeState.selecting || !props.minDate) {
        emit("pick", { minDate: newDate, maxDate: null });
        emit("select", true);
      } else {
        if (newDate >= props.minDate) {
          emit("pick", { minDate: props.minDate, maxDate: newDate });
        } else {
          emit("pick", { minDate: newDate, maxDate: props.minDate });
        }
        emit("select", false);
      }
    };
    const handleWeekPick = (newDate) => {
      const weekNumber = newDate.week();
      const value = `${newDate.year()}w${weekNumber}`;
      emit("pick", {
        year: newDate.year(),
        week: weekNumber,
        value,
        date: newDate.startOf("week")
      });
    };
    const handleDatesPick = (newDate, selected) => {
      const newValue = selected ? castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.valueOf()) !== newDate.valueOf()) : castArray(props.parsedValue).concat([newDate]);
      emit("pick", newValue);
    };
    const handlePickDate = (event, isKeyboardMovement = false) => {
      if (props.disabled)
        return;
      const target = event.target.closest("td");
      if (!target)
        return;
      const row = target.parentNode.rowIndex - 1;
      const column = target.cellIndex;
      const cell = vue.unref(rows)[row][column];
      if (cell.disabled || cell.type === "week")
        return;
      const newDate = getDateOfCell(row, column);
      switch (props.selectionMode) {
        case "range": {
          handleRangePick(newDate);
          break;
        }
        case "date": {
          emit("pick", newDate, isKeyboardMovement);
          break;
        }
        case "week": {
          handleWeekPick(newDate);
          break;
        }
        case "dates": {
          handleDatesPick(newDate, !!cell.selected);
          break;
        }
      }
    };
    const isWeekActive = (cell) => {
      if (props.selectionMode !== "week")
        return false;
      let newDate = props.date.startOf("day");
      if (cell.type === "prev-month") {
        newDate = newDate.subtract(1, "month");
      }
      if (cell.type === "next-month") {
        newDate = newDate.add(1, "month");
      }
      newDate = newDate.date(Number.parseInt(cell.text, 10));
      if (props.parsedValue && !isArray$1(props.parsedValue)) {
        const dayOffset = (props.parsedValue.day() - firstDayOfWeek + 7) % 7 - 1;
        const weekDate = props.parsedValue.subtract(dayOffset, "day");
        return weekDate.isSame(newDate, "day");
      }
      return false;
    };
    return {
      WEEKS,
      rows,
      tbodyRef,
      currentCellRef,
      focus,
      isCurrent,
      isWeekActive,
      isSelectedCell,
      handlePickDate,
      handleMouseUp,
      handleMouseDown,
      handleMouseMove,
      handleFocus
    };
  };
  const useBasicDateTableDOM = (props, {
    isCurrent,
    isWeekActive
  }) => {
    const ns = useNamespace("date-table");
    const { t } = useLocale();
    const tableKls = vue.computed(() => [
      ns.b(),
      ns.is("week-mode", props.selectionMode === "week" && !props.disabled)
    ]);
    const tableLabel = vue.computed(() => t("el.datepicker.dateTablePrompt"));
    const getCellClasses = (cell) => {
      const classes = [];
      if (isNormalDay(cell.type) && !cell.disabled) {
        classes.push("available");
        if (cell.type === "today") {
          classes.push("today");
        }
      } else {
        classes.push(cell.type);
      }
      if (isCurrent(cell)) {
        classes.push("current");
      }
      if (cell.inRange && (isNormalDay(cell.type) || props.selectionMode === "week")) {
        classes.push("in-range");
        if (cell.start) {
          classes.push("start-date");
        }
        if (cell.end) {
          classes.push("end-date");
        }
      }
      if (cell.disabled || props.disabled) {
        classes.push("disabled");
      }
      if (cell.selected) {
        classes.push("selected");
      }
      if (cell.customClass) {
        classes.push(cell.customClass);
      }
      return classes.join(" ");
    };
    const getRowKls = (cell) => [
      ns.e("row"),
      { current: isWeekActive(cell) }
    ];
    return {
      tableKls,
      tableLabel,
      weekHeaderClass: ns.e("week-header"),
      getCellClasses,
      getRowKls,
      t
    };
  };

  const basicCellProps = buildProps({
    cell: {
      type: definePropType(Object)
    }
  });

  var ElDatePickerCell = vue.defineComponent({
    name: "ElDatePickerCell",
    props: basicCellProps,
    setup(props) {
      const ns = useNamespace("date-table-cell");
      const {
        slots
      } = vue.inject(ROOT_PICKER_INJECTION_KEY);
      return () => {
        const {
          cell
        } = props;
        return vue.renderSlot(slots, "default", {
          ...cell
        }, () => {
          var _a;
          return [vue.createVNode("div", {
            "class": ns.b()
          }, [vue.createVNode("span", {
            "class": ns.e("text")
          }, [(_a = cell == null ? void 0 : cell.renderText) != null ? _a : cell == null ? void 0 : cell.text])])];
        });
      };
    }
  });

  const _sfc_main$1v = /* @__PURE__ */ vue.defineComponent({
    __name: "basic-date-table",
    props: basicDateTableProps,
    emits: basicDateTableEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const {
        WEEKS,
        rows,
        tbodyRef,
        currentCellRef,
        focus,
        isCurrent,
        isWeekActive,
        isSelectedCell,
        handlePickDate,
        handleMouseUp,
        handleMouseDown,
        handleMouseMove,
        handleFocus
      } = useBasicDateTable(props, emit);
      const { tableLabel, tableKls, getCellClasses, getRowKls, weekHeaderClass, t } = useBasicDateTableDOM(props, {
        isCurrent,
        isWeekActive
      });
      let isUnmounting = false;
      vue.onBeforeUnmount(() => {
        isUnmounting = true;
      });
      expose({
        focus
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("table", {
          "aria-label": vue.unref(tableLabel),
          class: vue.normalizeClass(vue.unref(tableKls)),
          cellspacing: "0",
          cellpadding: "0",
          role: "grid",
          onClick: vue.unref(handlePickDate),
          onMousemove: vue.unref(handleMouseMove),
          onMousedown: vue.unref(handleMouseDown),
          onMouseup: vue.unref(handleMouseUp)
        }, [
          vue.createElementVNode("tbody", {
            ref_key: "tbodyRef",
            ref: tbodyRef
          }, [
            vue.createElementVNode("tr", null, [
              _ctx.showWeekNumber ? (vue.openBlock(), vue.createElementBlock("th", {
                key: 0,
                scope: "col",
                class: vue.normalizeClass(vue.unref(weekHeaderClass))
              }, null, 2)) : vue.createCommentVNode("v-if", true),
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(WEEKS), (week, key) => {
                return vue.openBlock(), vue.createElementBlock("th", {
                  key,
                  "aria-label": vue.unref(t)("el.datepicker.weeksFull." + week),
                  scope: "col"
                }, vue.toDisplayString(vue.unref(t)("el.datepicker.weeks." + week)), 9, ["aria-label"]);
              }), 128))
            ]),
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, rowKey) => {
              return vue.openBlock(), vue.createElementBlock("tr", {
                key: rowKey,
                class: vue.normalizeClass(vue.unref(getRowKls)(_ctx.showWeekNumber ? row[2] : row[1]))
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, columnKey) => {
                  return vue.openBlock(), vue.createElementBlock("td", {
                    key: `${rowKey}.${columnKey}`,
                    ref_for: true,
                    ref: (el) => !vue.unref(isUnmounting) && vue.unref(isSelectedCell)(cell) && (currentCellRef.value = el),
                    class: vue.normalizeClass(vue.unref(getCellClasses)(cell)),
                    "aria-current": cell.isCurrent ? "date" : void 0,
                    "aria-selected": cell.isCurrent,
                    tabindex: vue.unref(isSelectedCell)(cell) ? 0 : -1,
                    onFocus: vue.unref(handleFocus)
                  }, [
                    vue.createVNode(vue.unref(ElDatePickerCell), { cell }, null, 8, ["cell"])
                  ], 42, ["aria-current", "aria-selected", "tabindex", "onFocus"]);
                }), 128))
              ], 2);
            }), 128))
          ], 512)
        ], 42, ["aria-label", "onClick", "onMousemove", "onMousedown", "onMouseup"]);
      };
    }
  });
  var DateTable = /* @__PURE__ */ _export_sfc(_sfc_main$1v, [["__file", "basic-date-table.vue"]]);

  const basicMonthTableProps = buildProps({
    ...datePickerSharedProps,
    selectionMode: selectionModeWithDefault("month")
  });

  const _sfc_main$1u = /* @__PURE__ */ vue.defineComponent({
    __name: "basic-month-table",
    props: basicMonthTableProps,
    emits: ["changerange", "pick", "select"],
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("month-table");
      const { t, lang } = useLocale();
      const tbodyRef = vue.ref();
      const currentCellRef = vue.ref();
      const months = vue.ref(props.date.locale("en").localeData().monthsShort().map((_) => _.toLowerCase()));
      const tableRows = vue.ref([[], [], []]);
      const lastRow = vue.ref();
      const lastColumn = vue.ref();
      const rows = vue.computed(() => {
        var _a, _b, _c;
        const rows2 = tableRows.value;
        const now = dayjs().locale(lang.value).startOf("month");
        for (let i = 0; i < 3; i++) {
          const row = rows2[i];
          for (let j = 0; j < 4; j++) {
            const cell = row[j] || (row[j] = {
              row: i,
              column: j,
              type: "normal",
              inRange: false,
              start: false,
              end: false,
              text: -1,
              disabled: false,
              isSelected: false,
              customClass: void 0,
              date: void 0,
              dayjs: void 0,
              isCurrent: void 0,
              selected: void 0,
              renderText: void 0,
              timestamp: void 0
            });
            cell.type = "normal";
            const index = i * 4 + j;
            const calTime = props.date.startOf("year").month(index);
            const calEndDate = props.rangeState.endDate || props.maxDate || props.rangeState.selecting && props.minDate || null;
            cell.inRange = !!(props.minDate && calTime.isSameOrAfter(props.minDate, "month") && calEndDate && calTime.isSameOrBefore(calEndDate, "month")) || !!(props.minDate && calTime.isSameOrBefore(props.minDate, "month") && calEndDate && calTime.isSameOrAfter(calEndDate, "month"));
            if ((_a = props.minDate) == null ? void 0 : _a.isSameOrAfter(calEndDate)) {
              cell.start = !!(calEndDate && calTime.isSame(calEndDate, "month"));
              cell.end = props.minDate && calTime.isSame(props.minDate, "month");
            } else {
              cell.start = !!(props.minDate && calTime.isSame(props.minDate, "month"));
              cell.end = !!(calEndDate && calTime.isSame(calEndDate, "month"));
            }
            const isToday = now.isSame(calTime);
            if (isToday) {
              cell.type = "today";
            }
            const cellDate = calTime.toDate();
            cell.text = index;
            cell.disabled = ((_b = props.disabledDate) == null ? void 0 : _b.call(props, cellDate)) || false;
            cell.date = cellDate;
            cell.customClass = (_c = props.cellClassName) == null ? void 0 : _c.call(props, cellDate);
            cell.dayjs = calTime;
            cell.timestamp = calTime.valueOf();
            cell.isSelected = isSelectedCell(cell);
          }
        }
        return rows2;
      });
      const focus = () => {
        var _a;
        (_a = currentCellRef.value) == null ? void 0 : _a.focus();
      };
      const getCellStyle = (cell) => {
        const style = {};
        const year = props.date.year();
        const today = /* @__PURE__ */ new Date();
        const month = cell.text;
        style.disabled = props.disabled || (props.disabledDate ? datesInMonth(props.date, year, month, lang.value).every(props.disabledDate) : false);
        style.current = castArray(props.parsedValue).some((date) => dayjs.isDayjs(date) && date.year() === year && date.month() === month);
        style.today = today.getFullYear() === year && today.getMonth() === month;
        if (cell.customClass) {
          style[cell.customClass] = true;
        }
        if (cell.inRange) {
          style["in-range"] = true;
          if (cell.start) {
            style["start-date"] = true;
          }
          if (cell.end) {
            style["end-date"] = true;
          }
        }
        return style;
      };
      const isSelectedCell = (cell) => {
        const year = props.date.year();
        const month = cell.text;
        return castArray(props.date).some((date) => date.year() === year && date.month() === month);
      };
      const handleMouseMove = (event) => {
        var _a;
        if (!props.rangeState.selecting)
          return;
        let target = event.target;
        if (target.tagName === "SPAN") {
          target = (_a = target.parentNode) == null ? void 0 : _a.parentNode;
        }
        if (target.tagName === "DIV") {
          target = target.parentNode;
        }
        if (target.tagName !== "TD")
          return;
        const row = target.parentNode.rowIndex;
        const column = target.cellIndex;
        if (rows.value[row][column].disabled)
          return;
        if (row !== lastRow.value || column !== lastColumn.value) {
          lastRow.value = row;
          lastColumn.value = column;
          emit("changerange", {
            selecting: true,
            endDate: props.date.startOf("year").month(row * 4 + column)
          });
        }
      };
      const handleMonthTableClick = (event) => {
        var _a;
        if (props.disabled)
          return;
        const target = (_a = event.target) == null ? void 0 : _a.closest("td");
        if ((target == null ? void 0 : target.tagName) !== "TD")
          return;
        if (hasClass(target, "disabled"))
          return;
        const column = target.cellIndex;
        const row = target.parentNode.rowIndex;
        const month = row * 4 + column;
        const newDate = props.date.startOf("year").month(month);
        if (props.selectionMode === "months") {
          if (event.type === "keydown") {
            emit("pick", castArray(props.parsedValue), false);
            return;
          }
          const newMonth = getValidDateOfMonth(props.date, props.date.year(), month, lang.value, props.disabledDate);
          const newValue = hasClass(target, "current") ? castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.year()) !== newMonth.year() || (d == null ? void 0 : d.month()) !== newMonth.month()) : castArray(props.parsedValue).concat([dayjs(newMonth)]);
          emit("pick", newValue);
        } else if (props.selectionMode === "range") {
          if (!props.rangeState.selecting) {
            emit("pick", { minDate: newDate, maxDate: null });
            emit("select", true);
          } else {
            if (props.minDate && newDate >= props.minDate) {
              emit("pick", { minDate: props.minDate, maxDate: newDate });
            } else {
              emit("pick", { minDate: newDate, maxDate: props.minDate });
            }
            emit("select", false);
          }
        } else {
          emit("pick", month);
        }
      };
      vue.watch(() => props.date, async () => {
        var _a, _b;
        if ((_a = tbodyRef.value) == null ? void 0 : _a.contains(document.activeElement)) {
          await vue.nextTick();
          (_b = currentCellRef.value) == null ? void 0 : _b.focus();
        }
      });
      expose({
        focus
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("table", {
          role: "grid",
          "aria-label": vue.unref(t)("el.datepicker.monthTablePrompt"),
          class: vue.normalizeClass(vue.unref(ns).b()),
          onClick: handleMonthTableClick,
          onMousemove: handleMouseMove
        }, [
          vue.createElementVNode("tbody", {
            ref_key: "tbodyRef",
            ref: tbodyRef
          }, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, key) => {
              return vue.openBlock(), vue.createElementBlock("tr", { key }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, key_) => {
                  return vue.openBlock(), vue.createElementBlock("td", {
                    key: key_,
                    ref_for: true,
                    ref: (el) => cell.isSelected && (currentCellRef.value = el),
                    class: vue.normalizeClass(getCellStyle(cell)),
                    "aria-selected": !!cell.isSelected,
                    "aria-label": vue.unref(t)(`el.datepicker.month${+cell.text + 1}`),
                    tabindex: cell.isSelected ? 0 : -1,
                    onKeydown: [
                      vue.withKeys(vue.withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["space"]),
                      vue.withKeys(vue.withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["enter"])
                    ]
                  }, [
                    vue.createVNode(vue.unref(ElDatePickerCell), {
                      cell: {
                        ...cell,
                        renderText: vue.unref(t)("el.datepicker.months." + months.value[cell.text])
                      }
                    }, null, 8, ["cell"])
                  ], 42, ["aria-selected", "aria-label", "tabindex", "onKeydown"]);
                }), 128))
              ]);
            }), 128))
          ], 512)
        ], 42, ["aria-label"]);
      };
    }
  });
  var MonthTable = /* @__PURE__ */ _export_sfc(_sfc_main$1u, [["__file", "basic-month-table.vue"]]);

  const basicYearTableProps = buildProps({
    ...datePickerSharedProps,
    selectionMode: selectionModeWithDefault("year")
  });

  const _sfc_main$1t = /* @__PURE__ */ vue.defineComponent({
    __name: "basic-year-table",
    props: basicYearTableProps,
    emits: ["changerange", "pick", "select"],
    setup(__props, { expose, emit }) {
      const props = __props;
      const datesInYear = (year, lang2) => {
        const firstDay = dayjs(String(year)).locale(lang2).startOf("year");
        const lastDay = firstDay.endOf("year");
        const numOfDays = lastDay.dayOfYear();
        return rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
      };
      const ns = useNamespace("year-table");
      const { t, lang } = useLocale();
      const tbodyRef = vue.ref();
      const currentCellRef = vue.ref();
      const startYear = vue.computed(() => {
        return Math.floor(props.date.year() / 10) * 10;
      });
      const tableRows = vue.ref([[], [], []]);
      const lastRow = vue.ref();
      const lastColumn = vue.ref();
      const rows = vue.computed(() => {
        var _a, _b, _c;
        const rows2 = tableRows.value;
        const now = dayjs().locale(lang.value).startOf("year");
        for (let i = 0; i < 3; i++) {
          const row = rows2[i];
          for (let j = 0; j < 4; j++) {
            if (i * 4 + j >= 10) {
              break;
            }
            let cell = row[j];
            if (!cell) {
              cell = {
                row: i,
                column: j,
                type: "normal",
                inRange: false,
                start: false,
                end: false,
                text: -1,
                disabled: false,
                isSelected: false,
                customClass: void 0,
                date: void 0,
                dayjs: void 0,
                isCurrent: void 0,
                selected: void 0,
                renderText: void 0,
                timestamp: void 0
              };
            }
            cell.type = "normal";
            const index = i * 4 + j + startYear.value;
            const calTime = dayjs().year(index);
            const calEndDate = props.rangeState.endDate || props.maxDate || props.rangeState.selecting && props.minDate || null;
            cell.inRange = !!(props.minDate && calTime.isSameOrAfter(props.minDate, "year") && calEndDate && calTime.isSameOrBefore(calEndDate, "year")) || !!(props.minDate && calTime.isSameOrBefore(props.minDate, "year") && calEndDate && calTime.isSameOrAfter(calEndDate, "year"));
            if ((_a = props.minDate) == null ? void 0 : _a.isSameOrAfter(calEndDate)) {
              cell.start = !!(calEndDate && calTime.isSame(calEndDate, "year"));
              cell.end = !!(props.minDate && calTime.isSame(props.minDate, "year"));
            } else {
              cell.start = !!(props.minDate && calTime.isSame(props.minDate, "year"));
              cell.end = !!(calEndDate && calTime.isSame(calEndDate, "year"));
            }
            const isToday = now.isSame(calTime);
            if (isToday) {
              cell.type = "today";
            }
            cell.text = index;
            const cellDate = calTime.toDate();
            cell.disabled = ((_b = props.disabledDate) == null ? void 0 : _b.call(props, cellDate)) || false;
            cell.date = cellDate;
            cell.customClass = (_c = props.cellClassName) == null ? void 0 : _c.call(props, cellDate);
            cell.dayjs = calTime;
            cell.timestamp = calTime.valueOf();
            cell.isSelected = isSelectedCell(cell);
            row[j] = cell;
          }
        }
        return rows2;
      });
      const focus = () => {
        var _a;
        (_a = currentCellRef.value) == null ? void 0 : _a.focus();
      };
      const getCellKls = (cell) => {
        const kls = {};
        const today = dayjs().locale(lang.value);
        const year = cell.text;
        kls.disabled = props.disabled || (props.disabledDate ? datesInYear(year, lang.value).every(props.disabledDate) : false);
        kls.today = today.year() === year;
        kls.current = castArray(props.parsedValue).some((d) => d.year() === year);
        if (cell.customClass) {
          kls[cell.customClass] = true;
        }
        if (cell.inRange) {
          kls["in-range"] = true;
          if (cell.start) {
            kls["start-date"] = true;
          }
          if (cell.end) {
            kls["end-date"] = true;
          }
        }
        return kls;
      };
      const isSelectedCell = (cell) => {
        const year = cell.text;
        return castArray(props.date).some((date) => date.year() === year);
      };
      const handleYearTableClick = (event) => {
        var _a;
        if (props.disabled)
          return;
        const target = (_a = event.target) == null ? void 0 : _a.closest("td");
        if (!target || !target.textContent || hasClass(target, "disabled"))
          return;
        const column = target.cellIndex;
        const row = target.parentNode.rowIndex;
        const selectedYear = row * 4 + column + startYear.value;
        const newDate = dayjs().year(selectedYear);
        if (props.selectionMode === "range") {
          if (!props.rangeState.selecting) {
            emit("pick", { minDate: newDate, maxDate: null });
            emit("select", true);
          } else {
            if (props.minDate && newDate >= props.minDate) {
              emit("pick", { minDate: props.minDate, maxDate: newDate });
            } else {
              emit("pick", { minDate: newDate, maxDate: props.minDate });
            }
            emit("select", false);
          }
        } else if (props.selectionMode === "years") {
          if (event.type === "keydown") {
            emit("pick", castArray(props.parsedValue), false);
            return;
          }
          const vaildYear = getValidDateOfYear(newDate.startOf("year"), lang.value, props.disabledDate);
          const newValue = hasClass(target, "current") ? castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.year()) !== selectedYear) : castArray(props.parsedValue).concat([vaildYear]);
          emit("pick", newValue);
        } else {
          emit("pick", selectedYear);
        }
      };
      const handleMouseMove = (event) => {
        var _a;
        if (!props.rangeState.selecting)
          return;
        const target = (_a = event.target) == null ? void 0 : _a.closest("td");
        if (!target)
          return;
        const row = target.parentNode.rowIndex;
        const column = target.cellIndex;
        if (rows.value[row][column].disabled)
          return;
        if (row !== lastRow.value || column !== lastColumn.value) {
          lastRow.value = row;
          lastColumn.value = column;
          emit("changerange", {
            selecting: true,
            endDate: dayjs().year(startYear.value).add(row * 4 + column, "year")
          });
        }
      };
      vue.watch(() => props.date, async () => {
        var _a, _b;
        if ((_a = tbodyRef.value) == null ? void 0 : _a.contains(document.activeElement)) {
          await vue.nextTick();
          (_b = currentCellRef.value) == null ? void 0 : _b.focus();
        }
      });
      expose({
        focus
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("table", {
          role: "grid",
          "aria-label": vue.unref(t)("el.datepicker.yearTablePrompt"),
          class: vue.normalizeClass(vue.unref(ns).b()),
          onClick: handleYearTableClick,
          onMousemove: handleMouseMove
        }, [
          vue.createElementVNode("tbody", {
            ref_key: "tbodyRef",
            ref: tbodyRef
          }, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, rowKey) => {
              return vue.openBlock(), vue.createElementBlock("tr", { key: rowKey }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, cellKey) => {
                  return vue.openBlock(), vue.createElementBlock("td", {
                    key: `${rowKey}_${cellKey}`,
                    ref_for: true,
                    ref: (el) => cell.isSelected && (currentCellRef.value = el),
                    class: vue.normalizeClass(["available", getCellKls(cell)]),
                    "aria-selected": cell.isSelected,
                    "aria-label": String(cell.text),
                    tabindex: cell.isSelected ? 0 : -1,
                    onKeydown: [
                      vue.withKeys(vue.withModifiers(handleYearTableClick, ["prevent", "stop"]), ["space"]),
                      vue.withKeys(vue.withModifiers(handleYearTableClick, ["prevent", "stop"]), ["enter"])
                    ]
                  }, [
                    vue.createVNode(vue.unref(ElDatePickerCell), { cell }, null, 8, ["cell"])
                  ], 42, ["aria-selected", "aria-label", "tabindex", "onKeydown"]);
                }), 128))
              ]);
            }), 128))
          ], 512)
        ], 42, ["aria-label"]);
      };
    }
  });
  var YearTable = /* @__PURE__ */ _export_sfc(_sfc_main$1t, [["__file", "basic-year-table.vue"]]);

  const _sfc_main$1s = /* @__PURE__ */ vue.defineComponent({
    __name: "panel-date-pick",
    props: panelDatePickProps,
    emits: ["pick", "set-picker-option", "panel-change"],
    setup(__props, { emit: contextEmit }) {
      const props = __props;
      const timeWithinRange = (_, __, ___) => true;
      const ppNs = useNamespace("picker-panel");
      const dpNs = useNamespace("date-picker");
      const attrs = vue.useAttrs();
      const slots = vue.useSlots();
      const { t, lang } = useLocale();
      const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
      const isDefaultFormat = vue.inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
      const { shortcuts, disabledDate, cellClassName, defaultTime } = pickerBase.props;
      const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
      const currentViewRef = vue.ref();
      const innerDate = vue.ref(dayjs().locale(lang.value));
      const isChangeToNow = vue.ref(false);
      let isShortcut = false;
      const defaultTimeD = vue.computed(() => {
        return dayjs(defaultTime).locale(lang.value);
      });
      const month = vue.computed(() => {
        return innerDate.value.month();
      });
      const year = vue.computed(() => {
        return innerDate.value.year();
      });
      const selectableRange = vue.ref([]);
      const userInputDate = vue.ref(null);
      const userInputTime = vue.ref(null);
      const checkDateWithinRange = (date) => {
        return selectableRange.value.length > 0 ? timeWithinRange(date, selectableRange.value, props.format || "HH:mm:ss") : true;
      };
      const formatEmit = (emitDayjs) => {
        if (defaultTime && !visibleTime.value && !isChangeToNow.value && !isShortcut) {
          return defaultTimeD.value.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
        }
        if (showTime.value)
          return emitDayjs.millisecond(0);
        return emitDayjs.startOf("day");
      };
      const emit = (value, ...args) => {
        if (!value) {
          contextEmit("pick", value, ...args);
        } else if (isArray$1(value)) {
          const dates = value.map(formatEmit);
          contextEmit("pick", dates, ...args);
        } else {
          contextEmit("pick", formatEmit(value), ...args);
        }
        userInputDate.value = null;
        userInputTime.value = null;
        isChangeToNow.value = false;
        isShortcut = false;
      };
      const handleDatePick = async (value, keepOpen) => {
        if (selectionMode.value === "date" && dayjs.isDayjs(value)) {
          const parsedDateValue = extractFirst(props.parsedValue);
          let newDate = parsedDateValue ? parsedDateValue.year(value.year()).month(value.month()).date(value.date()) : value;
          if (!checkDateWithinRange(newDate)) {
            newDate = selectableRange.value[0][0].year(value.year()).month(value.month()).date(value.date());
          }
          innerDate.value = newDate;
          emit(newDate, showTime.value || keepOpen);
        } else if (selectionMode.value === "week") {
          emit(value.date);
        } else if (selectionMode.value === "dates") {
          emit(value, true);
        }
      };
      const moveByMonth = (forward) => {
        const action = forward ? "add" : "subtract";
        innerDate.value = innerDate.value[action](1, "month");
        handlePanelChange("month");
      };
      const moveByYear = (forward) => {
        const currentDate = innerDate.value;
        const action = forward ? "add" : "subtract";
        innerDate.value = currentView.value === "year" ? currentDate[action](10, "year") : currentDate[action](1, "year");
        handlePanelChange("year");
      };
      const currentView = vue.ref("date");
      const yearLabel = vue.computed(() => {
        const yearTranslation = t("el.datepicker.year");
        if (currentView.value === "year") {
          const startYear = Math.floor(year.value / 10) * 10;
          if (yearTranslation) {
            return `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}`;
          }
          return `${startYear} - ${startYear + 9}`;
        }
        return `${year.value} ${yearTranslation}`;
      });
      const handleShortcutClick = (shortcut) => {
        const shortcutValue = isFunction$1(shortcut.value) ? shortcut.value() : shortcut.value;
        if (shortcutValue) {
          isShortcut = true;
          emit(dayjs(shortcutValue).locale(lang.value));
          return;
        }
        if (shortcut.onClick) {
          shortcut.onClick({
            attrs,
            slots,
            emit: contextEmit
          });
        }
      };
      const selectionMode = vue.computed(() => {
        const { type } = props;
        if (["week", "month", "months", "year", "years", "dates"].includes(type))
          return type;
        return "date";
      });
      const isMultipleType = vue.computed(() => {
        return selectionMode.value === "dates" || selectionMode.value === "months" || selectionMode.value === "years";
      });
      const keyboardMode = vue.computed(() => {
        return selectionMode.value === "date" ? currentView.value : selectionMode.value;
      });
      const hasShortcuts = vue.computed(() => !!shortcuts.length);
      const handleMonthPick = async (month2, keepOpen) => {
        if (selectionMode.value === "month") {
          innerDate.value = getValidDateOfMonth(innerDate.value, innerDate.value.year(), month2, lang.value, disabledDate);
          emit(innerDate.value, false);
        } else if (selectionMode.value === "months") {
          emit(month2, keepOpen != null ? keepOpen : true);
        } else {
          innerDate.value = getValidDateOfMonth(innerDate.value, innerDate.value.year(), month2, lang.value, disabledDate);
          currentView.value = "date";
          if (["month", "year", "date", "week"].includes(selectionMode.value)) {
            emit(innerDate.value, true);
            await vue.nextTick();
            handleFocusPicker();
          }
        }
        handlePanelChange("month");
      };
      const handleYearPick = async (year2, keepOpen) => {
        if (selectionMode.value === "year") {
          const data = innerDate.value.startOf("year").year(year2);
          innerDate.value = getValidDateOfYear(data, lang.value, disabledDate);
          emit(innerDate.value, false);
        } else if (selectionMode.value === "years") {
          emit(year2, keepOpen != null ? keepOpen : true);
        } else {
          const data = innerDate.value.year(year2);
          innerDate.value = getValidDateOfYear(data, lang.value, disabledDate);
          currentView.value = "month";
          if (["month", "year", "date", "week"].includes(selectionMode.value)) {
            emit(innerDate.value, true);
            await vue.nextTick();
            handleFocusPicker();
          }
        }
        handlePanelChange("year");
      };
      const showPicker = async (view) => {
        if (props.disabled)
          return;
        currentView.value = view;
        await vue.nextTick();
        handleFocusPicker();
      };
      const showTime = vue.computed(() => props.type === "datetime" || props.type === "datetimerange");
      const footerVisible = vue.computed(() => {
        const showDateFooter = showTime.value || selectionMode.value === "dates";
        const showYearFooter = selectionMode.value === "years";
        const showMonthFooter = selectionMode.value === "months";
        const isDateView = currentView.value === "date";
        const isYearView = currentView.value === "year";
        const isMonthView = currentView.value === "month";
        return showDateFooter && isDateView || showYearFooter && isYearView || showMonthFooter && isMonthView;
      });
      const footerFilled = vue.computed(() => !isMultipleType.value && props.showNow || props.showConfirm);
      const disabledConfirm = vue.computed(() => {
        if (!disabledDate)
          return false;
        if (!props.parsedValue)
          return true;
        if (isArray$1(props.parsedValue)) {
          return disabledDate(props.parsedValue[0].toDate());
        }
        return disabledDate(props.parsedValue.toDate());
      });
      const onConfirm = () => {
        if (isMultipleType.value) {
          emit(props.parsedValue);
        } else {
          let result = extractFirst(props.parsedValue);
          if (!result) {
            const defaultTimeD2 = dayjs(defaultTime).locale(lang.value);
            const defaultValueD = getDefaultValue();
            result = defaultTimeD2.year(defaultValueD.year()).month(defaultValueD.month()).date(defaultValueD.date());
          }
          innerDate.value = result;
          emit(result);
        }
      };
      const disabledNow = vue.computed(() => {
        if (!disabledDate)
          return false;
        return disabledDate(dayjs().locale(lang.value).toDate());
      });
      const changeToNow = () => {
        const now = dayjs().locale(lang.value);
        const nowDate = now.toDate();
        isChangeToNow.value = true;
        if ((!disabledDate || !disabledDate(nowDate)) && checkDateWithinRange(nowDate)) {
          innerDate.value = dayjs().locale(lang.value);
          emit(innerDate.value);
        }
      };
      const timeFormat = vue.computed(() => {
        return props.timeFormat || extractTimeFormat(props.format) || DEFAULT_FORMATS_TIME;
      });
      const dateFormat = vue.computed(() => {
        return props.dateFormat || extractDateFormat(props.format) || DEFAULT_FORMATS_DATE;
      });
      const visibleTime = vue.computed(() => {
        if (userInputTime.value)
          return userInputTime.value;
        if (!props.parsedValue && !defaultValue.value)
          return;
        const dateValue = extractFirst(props.parsedValue) || innerDate.value;
        return dateValue.format(timeFormat.value);
      });
      const visibleDate = vue.computed(() => {
        if (userInputDate.value)
          return userInputDate.value;
        if (!props.parsedValue && !defaultValue.value)
          return;
        const dateValue = extractFirst(props.parsedValue) || innerDate.value;
        return dateValue.format(dateFormat.value);
      });
      const timePickerVisible = vue.ref(false);
      const onTimePickerInputFocus = () => {
        timePickerVisible.value = true;
      };
      const handleTimePickClose = () => {
        timePickerVisible.value = false;
      };
      const getUnits = (date) => {
        return {
          hour: date.hour(),
          minute: date.minute(),
          second: date.second(),
          year: date.year(),
          month: date.month(),
          date: date.date()
        };
      };
      const handleTimePick = (value, visible, first) => {
        const { hour, minute, second } = getUnits(value);
        const parsedDateValue = extractFirst(props.parsedValue);
        const newDate = parsedDateValue ? parsedDateValue.hour(hour).minute(minute).second(second) : value;
        innerDate.value = newDate;
        emit(innerDate.value, true);
        if (!first) {
          timePickerVisible.value = visible;
        }
      };
      const handleVisibleTimeChange = (value) => {
        const newDate = dayjs(value, timeFormat.value).locale(lang.value);
        if (newDate.isValid() && checkDateWithinRange(newDate)) {
          const { year: year2, month: month2, date } = getUnits(innerDate.value);
          innerDate.value = newDate.year(year2).month(month2).date(date);
          userInputTime.value = null;
          timePickerVisible.value = false;
          emit(innerDate.value, true);
        }
      };
      const handleVisibleDateChange = (value) => {
        const newDate = correctlyParseUserInput(value, dateFormat.value, lang.value, isDefaultFormat);
        if (newDate.isValid()) {
          if (disabledDate && disabledDate(newDate.toDate())) {
            return;
          }
          const { hour, minute, second } = getUnits(innerDate.value);
          innerDate.value = newDate.hour(hour).minute(minute).second(second);
          userInputDate.value = null;
          emit(innerDate.value, true);
        }
      };
      const isValidValue = (date) => {
        return dayjs.isDayjs(date) && date.isValid() && (disabledDate ? !disabledDate(date.toDate()) : true);
      };
      const parseUserInput = (value) => {
        return correctlyParseUserInput(value, props.format, lang.value, isDefaultFormat);
      };
      const getDefaultValue = () => {
        const parseDate = dayjs(defaultValue.value).locale(lang.value);
        if (!defaultValue.value) {
          const defaultTimeDValue = defaultTimeD.value;
          return dayjs().hour(defaultTimeDValue.hour()).minute(defaultTimeDValue.minute()).second(defaultTimeDValue.second()).locale(lang.value);
        }
        return parseDate;
      };
      const handleFocusPicker = () => {
        var _a;
        if (["week", "month", "year", "date"].includes(selectionMode.value)) {
          (_a = currentViewRef.value) == null ? void 0 : _a.focus();
        }
      };
      const _handleFocusPicker = () => {
        handleFocusPicker();
        if (selectionMode.value === "week") {
          handleKeyControl(EVENT_CODE.down);
        }
      };
      const handleKeydownTable = (event) => {
        const code = getEventCode(event);
        const validCode = [
          EVENT_CODE.up,
          EVENT_CODE.down,
          EVENT_CODE.left,
          EVENT_CODE.right,
          EVENT_CODE.home,
          EVENT_CODE.end,
          EVENT_CODE.pageUp,
          EVENT_CODE.pageDown
        ];
        if (validCode.includes(code)) {
          handleKeyControl(code);
          event.stopPropagation();
          event.preventDefault();
        }
        if ([EVENT_CODE.enter, EVENT_CODE.space, EVENT_CODE.numpadEnter].includes(code) && userInputDate.value === null && userInputTime.value === null) {
          event.preventDefault();
          emit(innerDate.value, false);
        }
      };
      const handleKeyControl = (code) => {
        var _a;
        const { up, down, left, right, home, end, pageUp, pageDown } = EVENT_CODE;
        const mapping = {
          year: {
            [up]: -4,
            [down]: 4,
            [left]: -1,
            [right]: 1,
            offset: (date, step) => date.setFullYear(date.getFullYear() + step)
          },
          month: {
            [up]: -4,
            [down]: 4,
            [left]: -1,
            [right]: 1,
            offset: (date, step) => date.setMonth(date.getMonth() + step)
          },
          week: {
            [up]: -1,
            [down]: 1,
            [left]: -1,
            [right]: 1,
            offset: (date, step) => date.setDate(date.getDate() + step * 7)
          },
          date: {
            [up]: -7,
            [down]: 7,
            [left]: -1,
            [right]: 1,
            [home]: (date) => -date.getDay(),
            [end]: (date) => -date.getDay() + 6,
            [pageUp]: (date) => -new Date(date.getFullYear(), date.getMonth(), 0).getDate(),
            [pageDown]: (date) => new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate(),
            offset: (date, step) => date.setDate(date.getDate() + step)
          }
        };
        const newDate = innerDate.value.toDate();
        while (Math.abs(innerDate.value.diff(newDate, "year", true)) < 1) {
          const map = mapping[keyboardMode.value];
          if (!map)
            return;
          map.offset(newDate, isFunction$1(map[code]) ? map[code](newDate) : (_a = map[code]) != null ? _a : 0);
          if (disabledDate && disabledDate(newDate)) {
            break;
          }
          const result = dayjs(newDate).locale(lang.value);
          innerDate.value = result;
          contextEmit("pick", result, true);
          break;
        }
      };
      const handlePanelChange = (mode) => {
        contextEmit("panel-change", innerDate.value.toDate(), mode, currentView.value);
      };
      vue.watch(() => selectionMode.value, (val) => {
        if (["month", "year"].includes(val)) {
          currentView.value = val;
          return;
        } else if (val === "years") {
          currentView.value = "year";
          return;
        } else if (val === "months") {
          currentView.value = "month";
          return;
        }
        currentView.value = "date";
      }, { immediate: true });
      vue.watch(() => defaultValue.value, (val) => {
        if (val) {
          innerDate.value = getDefaultValue();
        }
      }, { immediate: true });
      vue.watch(() => props.parsedValue, (val) => {
        if (val) {
          if (isMultipleType.value)
            return;
          if (isArray$1(val))
            return;
          innerDate.value = val;
        } else {
          innerDate.value = getDefaultValue();
        }
      }, { immediate: true });
      contextEmit("set-picker-option", ["isValidValue", isValidValue]);
      contextEmit("set-picker-option", ["parseUserInput", parseUserInput]);
      contextEmit("set-picker-option", ["handleFocusPicker", _handleFocusPicker]);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ppNs).b(),
            vue.unref(dpNs).b(),
            vue.unref(ppNs).is("border", _ctx.border),
            vue.unref(ppNs).is("disabled", _ctx.disabled),
            {
              "has-sidebar": _ctx.$slots.sidebar || vue.unref(hasShortcuts),
              "has-time": vue.unref(showTime)
            }
          ])
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
          }, [
            vue.renderSlot(_ctx.$slots, "sidebar", {
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }),
            vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
                return vue.openBlock(), vue.createElementBlock("button", {
                  key,
                  type: "button",
                  disabled: _ctx.disabled,
                  class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
                  onClick: ($event) => handleShortcutClick(shortcut)
                }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
              }), 128))
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("body"))
            }, [
              vue.unref(showTime) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(dpNs).e("time-header"))
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(dpNs).e("editor-wrap"))
                }, [
                  vue.createVNode(vue.unref(ElInput), {
                    placeholder: vue.unref(t)("el.datepicker.selectDate"),
                    "model-value": vue.unref(visibleDate),
                    size: "small",
                    "validate-event": false,
                    disabled: _ctx.disabled,
                    onInput: (val) => userInputDate.value = val,
                    onChange: handleVisibleDateChange
                  }, null, 8, ["placeholder", "model-value", "disabled", "onInput"])
                ], 2),
                vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
                  class: vue.normalizeClass(vue.unref(dpNs).e("editor-wrap"))
                }, [
                  vue.createVNode(vue.unref(ElInput), {
                    placeholder: vue.unref(t)("el.datepicker.selectTime"),
                    "model-value": vue.unref(visibleTime),
                    size: "small",
                    "validate-event": false,
                    disabled: _ctx.disabled,
                    onFocus: onTimePickerInputFocus,
                    onInput: (val) => userInputTime.value = val,
                    onChange: handleVisibleTimeChange
                  }, null, 8, ["placeholder", "model-value", "disabled", "onInput"]),
                  vue.createVNode(vue.unref(TimePickPanel), {
                    visible: timePickerVisible.value,
                    format: vue.unref(timeFormat),
                    "parsed-value": innerDate.value,
                    onPick: handleTimePick
                  }, null, 8, ["visible", "format", "parsed-value"])
                ], 2)), [
                  [vue.unref(ClickOutside), handleTimePickClose]
                ])
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.withDirectives(vue.createElementVNode("div", {
                class: vue.normalizeClass([
                  vue.unref(dpNs).e("header"),
                  (currentView.value === "year" || currentView.value === "month") && vue.unref(dpNs).em("header", "bordered")
                ])
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(dpNs).e("prev-btn"))
                }, [
                  vue.createElementVNode("button", {
                    type: "button",
                    "aria-label": vue.unref(t)(`el.datepicker.prevYear`),
                    class: vue.normalizeClass(["d-arrow-left", vue.unref(ppNs).e("icon-btn")]),
                    disabled: _ctx.disabled,
                    onClick: ($event) => moveByYear(false)
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["aria-label", "disabled", "onClick"]),
                  vue.withDirectives(vue.createElementVNode("button", {
                    type: "button",
                    "aria-label": vue.unref(t)(`el.datepicker.prevMonth`),
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
                    disabled: _ctx.disabled,
                    onClick: ($event) => moveByMonth(false)
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-month", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["aria-label", "disabled", "onClick"]), [
                    [vue.vShow, currentView.value === "date"]
                  ])
                ], 2),
                vue.createElementVNode("span", {
                  role: "button",
                  class: vue.normalizeClass(vue.unref(dpNs).e("header-label")),
                  "aria-live": "polite",
                  tabindex: "0",
                  onKeydown: vue.withKeys(($event) => showPicker("year"), ["enter"]),
                  onClick: ($event) => showPicker("year")
                }, vue.toDisplayString(vue.unref(yearLabel)), 43, ["onKeydown", "onClick"]),
                vue.withDirectives(vue.createElementVNode("span", {
                  role: "button",
                  "aria-live": "polite",
                  tabindex: "0",
                  class: vue.normalizeClass([
                    vue.unref(dpNs).e("header-label"),
                    { active: currentView.value === "month" }
                  ]),
                  onKeydown: vue.withKeys(($event) => showPicker("month"), ["enter"]),
                  onClick: ($event) => showPicker("month")
                }, vue.toDisplayString(vue.unref(t)(`el.datepicker.month${vue.unref(month) + 1}`)), 43, ["onKeydown", "onClick"]), [
                  [vue.vShow, currentView.value === "date"]
                ]),
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(dpNs).e("next-btn"))
                }, [
                  vue.withDirectives(vue.createElementVNode("button", {
                    type: "button",
                    "aria-label": vue.unref(t)(`el.datepicker.nextMonth`),
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-right"]),
                    disabled: _ctx.disabled,
                    onClick: ($event) => moveByMonth(true)
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-month", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["aria-label", "disabled", "onClick"]), [
                    [vue.vShow, currentView.value === "date"]
                  ]),
                  vue.createElementVNode("button", {
                    type: "button",
                    "aria-label": vue.unref(t)(`el.datepicker.nextYear`),
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                    disabled: _ctx.disabled,
                    onClick: ($event) => moveByYear(true)
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["aria-label", "disabled", "onClick"])
                ], 2)
              ], 2), [
                [vue.vShow, currentView.value !== "time"]
              ]),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ppNs).e("content")),
                onKeydown: handleKeydownTable
              }, [
                currentView.value === "date" ? (vue.openBlock(), vue.createBlock(DateTable, {
                  key: 0,
                  ref_key: "currentViewRef",
                  ref: currentViewRef,
                  "selection-mode": vue.unref(selectionMode),
                  date: innerDate.value,
                  "parsed-value": _ctx.parsedValue,
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  "cell-class-name": vue.unref(cellClassName),
                  "show-week-number": _ctx.showWeekNumber,
                  onPick: handleDatePick
                }, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date", "disabled", "cell-class-name", "show-week-number"])) : vue.createCommentVNode("v-if", true),
                currentView.value === "year" ? (vue.openBlock(), vue.createBlock(YearTable, {
                  key: 1,
                  ref_key: "currentViewRef",
                  ref: currentViewRef,
                  "selection-mode": vue.unref(selectionMode),
                  date: innerDate.value,
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  "parsed-value": _ctx.parsedValue,
                  "cell-class-name": vue.unref(cellClassName),
                  onPick: handleYearPick
                }, null, 8, ["selection-mode", "date", "disabled-date", "disabled", "parsed-value", "cell-class-name"])) : vue.createCommentVNode("v-if", true),
                currentView.value === "month" ? (vue.openBlock(), vue.createBlock(MonthTable, {
                  key: 2,
                  ref_key: "currentViewRef",
                  ref: currentViewRef,
                  "selection-mode": vue.unref(selectionMode),
                  date: innerDate.value,
                  "parsed-value": _ctx.parsedValue,
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  "cell-class-name": vue.unref(cellClassName),
                  onPick: handleMonthPick
                }, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date", "disabled", "cell-class-name"])) : vue.createCommentVNode("v-if", true)
              ], 34)
            ], 2)
          ], 2),
          _ctx.showFooter && vue.unref(footerVisible) && vue.unref(footerFilled) ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ppNs).e("footer"))
          }, [
            vue.withDirectives(vue.createVNode(vue.unref(ElButton), {
              text: "",
              size: "small",
              class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
              disabled: vue.unref(disabledNow),
              onClick: changeToNow
            }, {
              default: vue.withCtx(() => [
                vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.now")), 1)
              ]),
              _: 1
            }, 8, ["class", "disabled"]), [
              [vue.vShow, !vue.unref(isMultipleType) && _ctx.showNow]
            ]),
            _ctx.showConfirm ? (vue.openBlock(), vue.createBlock(vue.unref(ElButton), {
              key: 0,
              plain: "",
              size: "small",
              class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
              disabled: vue.unref(disabledConfirm),
              onClick: onConfirm
            }, {
              default: vue.withCtx(() => [
                vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 1)
              ]),
              _: 1
            }, 8, ["class", "disabled"])) : vue.createCommentVNode("v-if", true)
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var DatePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1s, [["__file", "panel-date-pick.vue"]]);

  const panelDateRangeProps = buildProps({
    ...panelSharedProps,
    ...panelRangeSharedProps
  });

  const useShortcut = (lang) => {
    const { emit } = vue.getCurrentInstance();
    const attrs = vue.useAttrs();
    const slots = vue.useSlots();
    const handleShortcutClick = (shortcut) => {
      const shortcutValues = isFunction$1(shortcut.value) ? shortcut.value() : shortcut.value;
      if (shortcutValues) {
        emit("pick", [
          dayjs(shortcutValues[0]).locale(lang.value),
          dayjs(shortcutValues[1]).locale(lang.value)
        ]);
        return;
      }
      if (shortcut.onClick) {
        shortcut.onClick({
          attrs,
          slots,
          emit
        });
      }
    };
    return handleShortcutClick;
  };

  const useRangePicker = (props, {
    defaultValue,
    defaultTime,
    leftDate,
    rightDate,
    step,
    unit,
    sortDates
  }) => {
    const { emit } = vue.getCurrentInstance();
    const { pickerNs } = vue.inject(ROOT_PICKER_INJECTION_KEY);
    const drpNs = useNamespace("date-range-picker");
    const { t, lang } = useLocale();
    const handleShortcutClick = useShortcut(lang);
    const minDate = vue.ref();
    const maxDate = vue.ref();
    const rangeState = vue.ref({
      endDate: null,
      selecting: false
    });
    const handleChangeRange = (val) => {
      rangeState.value = val;
    };
    const handleRangeConfirm = (visible = false) => {
      const _minDate = vue.unref(minDate);
      const _maxDate = vue.unref(maxDate);
      if (isValidRange([_minDate, _maxDate])) {
        emit("pick", [_minDate, _maxDate], visible);
      }
    };
    const onSelect = (selecting) => {
      rangeState.value.selecting = selecting;
      if (!selecting) {
        rangeState.value.endDate = null;
      }
    };
    const parseValue = (parsedValue) => {
      if (isArray$1(parsedValue) && parsedValue.length === 2) {
        const [start, end] = parsedValue;
        minDate.value = start;
        leftDate.value = start;
        maxDate.value = end;
        sortDates(vue.unref(minDate), vue.unref(maxDate));
      } else {
        restoreDefault();
      }
    };
    const restoreDefault = () => {
      let [start, end] = getDefaultValue(vue.unref(defaultValue), {
        lang: vue.unref(lang),
        step,
        unit,
        unlinkPanels: props.unlinkPanels
      });
      const getShift = (day) => {
        return day.diff(day.startOf("d"), "ms");
      };
      const maybeTimes = vue.unref(defaultTime);
      if (maybeTimes) {
        let leftShift = 0;
        let rightShift = 0;
        if (isArray$1(maybeTimes)) {
          const [timeStart, timeEnd] = maybeTimes.map(dayjs);
          leftShift = getShift(timeStart);
          rightShift = getShift(timeEnd);
        } else {
          const shift = getShift(dayjs(maybeTimes));
          leftShift = shift;
          rightShift = shift;
        }
        start = start.startOf("d").add(leftShift, "ms");
        end = end.startOf("d").add(rightShift, "ms");
      }
      minDate.value = void 0;
      maxDate.value = void 0;
      leftDate.value = start;
      rightDate.value = end;
    };
    vue.watch(defaultValue, (val) => {
      if (val) {
        restoreDefault();
      }
    }, { immediate: true });
    vue.watch(() => props.parsedValue, (parsedValue) => {
      if (!(parsedValue == null ? void 0 : parsedValue.length) || !isEqual$1(parsedValue, [minDate.value, maxDate.value])) {
        parseValue(parsedValue);
      }
    }, {
      immediate: true
    });
    vue.watch(() => props.visible, () => {
      if (props.visible) {
        parseValue(props.parsedValue);
      }
    }, { immediate: true });
    return {
      minDate,
      maxDate,
      rangeState,
      lang,
      ppNs: pickerNs,
      drpNs,
      handleChangeRange,
      handleRangeConfirm,
      handleShortcutClick,
      onSelect,
      parseValue,
      t
    };
  };

  const usePanelDateRange = (props, emit, leftDate, rightDate) => {
    const leftCurrentView = vue.ref("date");
    const leftCurrentViewRef = vue.ref();
    const rightCurrentView = vue.ref("date");
    const rightCurrentViewRef = vue.ref();
    const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
    const { disabledDate } = pickerBase.props;
    const { t, lang } = useLocale();
    const leftYear = vue.computed(() => {
      return leftDate.value.year();
    });
    const leftMonth = vue.computed(() => {
      return leftDate.value.month();
    });
    const rightYear = vue.computed(() => {
      return rightDate.value.year();
    });
    const rightMonth = vue.computed(() => {
      return rightDate.value.month();
    });
    function computedYearLabel(currentView, yearValue) {
      const yearTranslation = t("el.datepicker.year");
      if (currentView.value === "year") {
        const startYear = Math.floor(yearValue.value / 10) * 10;
        return yearTranslation ? `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}` : `${startYear} - ${startYear + 9}`;
      }
      return `${yearValue.value} ${yearTranslation}`;
    }
    function focusPicker(currentViewRef) {
      currentViewRef == null ? void 0 : currentViewRef.focus();
    }
    async function showPicker(pickerType, view) {
      if (props.disabled)
        return;
      const currentView = pickerType === "left" ? leftCurrentView : rightCurrentView;
      const currentViewRef = pickerType === "left" ? leftCurrentViewRef : rightCurrentViewRef;
      currentView.value = view;
      await vue.nextTick();
      focusPicker(currentViewRef.value);
    }
    async function handlePick(mode, pickerType, value) {
      if (props.disabled)
        return;
      const isLeftPicker = pickerType === "left";
      const startDate = isLeftPicker ? leftDate : rightDate;
      const endDate = isLeftPicker ? rightDate : leftDate;
      const currentView = isLeftPicker ? leftCurrentView : rightCurrentView;
      const currentViewRef = isLeftPicker ? leftCurrentViewRef : rightCurrentViewRef;
      if (mode === "year") {
        const data = startDate.value.year(value);
        startDate.value = getValidDateOfYear(data, lang.value, disabledDate);
      }
      if (mode === "month") {
        startDate.value = getValidDateOfMonth(startDate.value, startDate.value.year(), value, lang.value, disabledDate);
      }
      if (!props.unlinkPanels) {
        endDate.value = pickerType === "left" ? startDate.value.add(1, "month") : startDate.value.subtract(1, "month");
      }
      currentView.value = mode === "year" ? "month" : "date";
      await vue.nextTick();
      focusPicker(currentViewRef.value);
      handlePanelChange(mode);
    }
    function handlePanelChange(mode) {
      emit("panel-change", [leftDate.value.toDate(), rightDate.value.toDate()], mode);
    }
    function adjustDateByView(currentView, date, forward) {
      const action = forward ? "add" : "subtract";
      return currentView === "year" ? date[action](10, "year") : date[action](1, "year");
    }
    return {
      leftCurrentView,
      rightCurrentView,
      leftCurrentViewRef,
      rightCurrentViewRef,
      leftYear,
      rightYear,
      leftMonth,
      rightMonth,
      leftYearLabel: vue.computed(() => computedYearLabel(leftCurrentView, leftYear)),
      rightYearLabel: vue.computed(() => computedYearLabel(rightCurrentView, rightYear)),
      showLeftPicker: (view) => showPicker("left", view),
      showRightPicker: (view) => showPicker("right", view),
      handleLeftYearPick: (year) => handlePick("year", "left", year),
      handleRightYearPick: (year) => handlePick("year", "right", year),
      handleLeftMonthPick: (month) => handlePick("month", "left", month),
      handleRightMonthPick: (month) => handlePick("month", "right", month),
      handlePanelChange,
      adjustDateByView
    };
  };

  const unit$2 = "month";
  const _sfc_main$1r = /* @__PURE__ */ vue.defineComponent({
    __name: "panel-date-range",
    props: panelDateRangeProps,
    emits: [
      "pick",
      "set-picker-option",
      "calendar-change",
      "panel-change"
    ],
    setup(__props, { emit }) {
      const props = __props;
      const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
      const isDefaultFormat = vue.inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
      const { disabledDate, cellClassName, defaultTime, clearable } = pickerBase.props;
      const format = vue.toRef(pickerBase.props, "format");
      const shortcuts = vue.toRef(pickerBase.props, "shortcuts");
      const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
      const { lang } = useLocale();
      const leftDate = vue.ref(dayjs().locale(lang.value));
      const rightDate = vue.ref(dayjs().locale(lang.value).add(1, unit$2));
      const {
        minDate,
        maxDate,
        rangeState,
        ppNs,
        drpNs,
        handleChangeRange,
        handleRangeConfirm,
        handleShortcutClick,
        onSelect,
        parseValue,
        t
      } = useRangePicker(props, {
        defaultValue,
        defaultTime,
        leftDate,
        rightDate,
        unit: unit$2,
        sortDates
      });
      vue.watch(() => props.visible, (visible) => {
        if (!visible && rangeState.value.selecting) {
          parseValue(props.parsedValue);
          onSelect(false);
        }
      });
      const dateUserInput = vue.ref({
        min: null,
        max: null
      });
      const timeUserInput = vue.ref({
        min: null,
        max: null
      });
      const {
        leftCurrentView,
        rightCurrentView,
        leftCurrentViewRef,
        rightCurrentViewRef,
        leftYear,
        rightYear,
        leftMonth,
        rightMonth,
        leftYearLabel,
        rightYearLabel,
        showLeftPicker,
        showRightPicker,
        handleLeftYearPick,
        handleRightYearPick,
        handleLeftMonthPick,
        handleRightMonthPick,
        handlePanelChange,
        adjustDateByView
      } = usePanelDateRange(props, emit, leftDate, rightDate);
      const hasShortcuts = vue.computed(() => !!shortcuts.value.length);
      const minVisibleDate = vue.computed(() => {
        if (dateUserInput.value.min !== null)
          return dateUserInput.value.min;
        if (minDate.value)
          return minDate.value.format(dateFormat.value);
        return "";
      });
      const maxVisibleDate = vue.computed(() => {
        if (dateUserInput.value.max !== null)
          return dateUserInput.value.max;
        if (maxDate.value || minDate.value)
          return (maxDate.value || minDate.value).format(dateFormat.value);
        return "";
      });
      const minVisibleTime = vue.computed(() => {
        if (timeUserInput.value.min !== null)
          return timeUserInput.value.min;
        if (minDate.value)
          return minDate.value.format(timeFormat.value);
        return "";
      });
      const maxVisibleTime = vue.computed(() => {
        if (timeUserInput.value.max !== null)
          return timeUserInput.value.max;
        if (maxDate.value || minDate.value)
          return (maxDate.value || minDate.value).format(timeFormat.value);
        return "";
      });
      const timeFormat = vue.computed(() => {
        return props.timeFormat || extractTimeFormat(format.value || "") || DEFAULT_FORMATS_TIME;
      });
      const dateFormat = vue.computed(() => {
        return props.dateFormat || extractDateFormat(format.value || "") || DEFAULT_FORMATS_DATE;
      });
      const isValidValue = (date) => {
        return isValidRange(date) && (disabledDate ? !disabledDate(date[0].toDate()) && !disabledDate(date[1].toDate()) : true);
      };
      const leftPrevYear = () => {
        leftDate.value = adjustDateByView(leftCurrentView.value, leftDate.value, false);
        if (!props.unlinkPanels) {
          rightDate.value = leftDate.value.add(1, "month");
        }
        handlePanelChange("year");
      };
      const leftPrevMonth = () => {
        leftDate.value = leftDate.value.subtract(1, "month");
        if (!props.unlinkPanels) {
          rightDate.value = leftDate.value.add(1, "month");
        }
        handlePanelChange("month");
      };
      const rightNextYear = () => {
        if (!props.unlinkPanels) {
          leftDate.value = adjustDateByView(rightCurrentView.value, leftDate.value, true);
          rightDate.value = leftDate.value.add(1, "month");
        } else {
          rightDate.value = adjustDateByView(rightCurrentView.value, rightDate.value, true);
        }
        handlePanelChange("year");
      };
      const rightNextMonth = () => {
        if (!props.unlinkPanels) {
          leftDate.value = leftDate.value.add(1, "month");
          rightDate.value = leftDate.value.add(1, "month");
        } else {
          rightDate.value = rightDate.value.add(1, "month");
        }
        handlePanelChange("month");
      };
      const leftNextYear = () => {
        leftDate.value = adjustDateByView(leftCurrentView.value, leftDate.value, true);
        handlePanelChange("year");
      };
      const leftNextMonth = () => {
        leftDate.value = leftDate.value.add(1, "month");
        handlePanelChange("month");
      };
      const rightPrevYear = () => {
        rightDate.value = adjustDateByView(rightCurrentView.value, rightDate.value, false);
        handlePanelChange("year");
      };
      const rightPrevMonth = () => {
        rightDate.value = rightDate.value.subtract(1, "month");
        handlePanelChange("month");
      };
      const enableMonthArrow = vue.computed(() => {
        const nextMonth = (leftMonth.value + 1) % 12;
        const yearOffset = leftMonth.value + 1 >= 12 ? 1 : 0;
        return props.unlinkPanels && new Date(leftYear.value + yearOffset, nextMonth) < new Date(rightYear.value, rightMonth.value);
      });
      const enableYearArrow = vue.computed(() => {
        return props.unlinkPanels && rightYear.value * 12 + rightMonth.value - (leftYear.value * 12 + leftMonth.value + 1) >= 12;
      });
      const btnDisabled = vue.computed(() => {
        return !(minDate.value && maxDate.value && !rangeState.value.selecting && isValidRange([minDate.value, maxDate.value]));
      });
      const showTime = vue.computed(() => props.type === "datetime" || props.type === "datetimerange");
      const formatEmit = (emitDayjs, index) => {
        if (!emitDayjs)
          return;
        if (defaultTime) {
          const defaultTimeD = dayjs(defaultTime[index] || defaultTime).locale(lang.value);
          return defaultTimeD.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
        }
        return emitDayjs;
      };
      const handleRangePick = (val, close = true) => {
        const min_ = val.minDate;
        const max_ = val.maxDate;
        const minDate_ = formatEmit(min_, 0);
        const maxDate_ = formatEmit(max_, 1);
        if (maxDate.value === maxDate_ && minDate.value === minDate_) {
          return;
        }
        emit("calendar-change", [min_.toDate(), max_ && max_.toDate()]);
        maxDate.value = maxDate_;
        minDate.value = minDate_;
        if (!showTime.value && close) {
          close = !minDate_ || !maxDate_;
        }
        handleRangeConfirm(close);
      };
      const minTimePickerVisible = vue.ref(false);
      const maxTimePickerVisible = vue.ref(false);
      const handleMinTimeClose = () => {
        minTimePickerVisible.value = false;
      };
      const handleMaxTimeClose = () => {
        maxTimePickerVisible.value = false;
      };
      const handleDateInput = (value, type) => {
        dateUserInput.value[type] = value;
        const parsedValueD = dayjs(value, dateFormat.value).locale(lang.value);
        if (parsedValueD.isValid()) {
          if (disabledDate && disabledDate(parsedValueD.toDate())) {
            return;
          }
          if (type === "min") {
            leftDate.value = parsedValueD;
            minDate.value = (minDate.value || leftDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
            if (!props.unlinkPanels && (!maxDate.value || maxDate.value.isBefore(minDate.value))) {
              rightDate.value = parsedValueD.add(1, "month");
              maxDate.value = minDate.value.add(1, "month");
            }
          } else {
            rightDate.value = parsedValueD;
            maxDate.value = (maxDate.value || rightDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
            if (!props.unlinkPanels && (!minDate.value || minDate.value.isAfter(maxDate.value))) {
              leftDate.value = parsedValueD.subtract(1, "month");
              minDate.value = maxDate.value.subtract(1, "month");
            }
          }
          sortDates(minDate.value, maxDate.value);
          handleRangeConfirm(true);
        }
      };
      const handleDateChange = (_, type) => {
        dateUserInput.value[type] = null;
      };
      const handleTimeInput = (value, type) => {
        timeUserInput.value[type] = value;
        const parsedValueD = dayjs(value, timeFormat.value).locale(lang.value);
        if (parsedValueD.isValid()) {
          if (type === "min") {
            minTimePickerVisible.value = true;
            minDate.value = (minDate.value || leftDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
            leftDate.value = minDate.value;
          } else {
            maxTimePickerVisible.value = true;
            maxDate.value = (maxDate.value || rightDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
            rightDate.value = maxDate.value;
          }
        }
      };
      const handleTimeChange = (_value, type) => {
        timeUserInput.value[type] = null;
        if (type === "min") {
          leftDate.value = minDate.value;
          minTimePickerVisible.value = false;
          if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
            maxDate.value = minDate.value;
          }
        } else {
          rightDate.value = maxDate.value;
          maxTimePickerVisible.value = false;
          if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
            minDate.value = maxDate.value;
          }
        }
        handleRangeConfirm(true);
      };
      const handleMinTimePick = (value, visible, first) => {
        if (timeUserInput.value.min)
          return;
        if (value) {
          leftDate.value = value;
          minDate.value = (minDate.value || leftDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
        }
        if (!first) {
          minTimePickerVisible.value = visible;
        }
        if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
          maxDate.value = minDate.value;
          rightDate.value = value;
          vue.nextTick(() => {
            parseValue(props.parsedValue);
          });
        }
        handleRangeConfirm(true);
      };
      const handleMaxTimePick = (value, visible, first) => {
        if (timeUserInput.value.max)
          return;
        if (value) {
          rightDate.value = value;
          maxDate.value = (maxDate.value || rightDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
        }
        if (!first) {
          maxTimePickerVisible.value = visible;
        }
        if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
          minDate.value = maxDate.value;
        }
        handleRangeConfirm(true);
      };
      const handleClear = () => {
        let valueOnClear = null;
        if (pickerBase == null ? void 0 : pickerBase.emptyValues) {
          valueOnClear = pickerBase.emptyValues.valueOnClear.value;
        }
        leftDate.value = getDefaultValue(vue.unref(defaultValue), {
          lang: vue.unref(lang),
          unit: "month",
          unlinkPanels: props.unlinkPanels
        })[0];
        rightDate.value = leftDate.value.add(1, "month");
        maxDate.value = void 0;
        minDate.value = void 0;
        handleRangeConfirm(true);
        emit("pick", valueOnClear);
      };
      const parseUserInput = (value) => {
        return correctlyParseUserInput(value, format.value || "", lang.value, isDefaultFormat);
      };
      function sortDates(minDate2, maxDate2) {
        if (props.unlinkPanels && maxDate2) {
          const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
          const minDateMonth = (minDate2 == null ? void 0 : minDate2.month()) || 0;
          const maxDateYear = maxDate2.year();
          const maxDateMonth = maxDate2.month();
          rightDate.value = minDateYear === maxDateYear && minDateMonth === maxDateMonth ? maxDate2.add(1, unit$2) : maxDate2;
        } else {
          rightDate.value = leftDate.value.add(1, unit$2);
          if (maxDate2) {
            rightDate.value = rightDate.value.hour(maxDate2.hour()).minute(maxDate2.minute()).second(maxDate2.second());
          }
        }
      }
      emit("set-picker-option", ["isValidValue", isValidValue]);
      emit("set-picker-option", ["parseUserInput", parseUserInput]);
      emit("set-picker-option", ["handleClear", handleClear]);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ppNs).b(),
            vue.unref(drpNs).b(),
            vue.unref(ppNs).is("border", _ctx.border),
            vue.unref(ppNs).is("disabled", _ctx.disabled),
            {
              "has-sidebar": _ctx.$slots.sidebar || vue.unref(hasShortcuts),
              "has-time": vue.unref(showTime)
            }
          ])
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
          }, [
            vue.renderSlot(_ctx.$slots, "sidebar", {
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }),
            vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
                return vue.openBlock(), vue.createElementBlock("button", {
                  key,
                  type: "button",
                  disabled: _ctx.disabled,
                  class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
                  onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
                }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
              }), 128))
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("body"))
            }, [
              vue.unref(showTime) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(drpNs).e("time-header"))
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(drpNs).e("editors-wrap"))
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                  }, [
                    vue.createVNode(vue.unref(ElInput), {
                      size: "small",
                      disabled: vue.unref(rangeState).selecting || _ctx.disabled,
                      placeholder: vue.unref(t)("el.datepicker.startDate"),
                      class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                      "model-value": vue.unref(minVisibleDate),
                      "validate-event": false,
                      onInput: (val) => handleDateInput(val, "min"),
                      onChange: (val) => handleDateChange(val, "min")
                    }, null, 8, ["disabled", "placeholder", "class", "model-value", "onInput", "onChange"])
                  ], 2),
                  vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                  }, [
                    vue.createVNode(vue.unref(ElInput), {
                      size: "small",
                      class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                      disabled: vue.unref(rangeState).selecting || _ctx.disabled,
                      placeholder: vue.unref(t)("el.datepicker.startTime"),
                      "model-value": vue.unref(minVisibleTime),
                      "validate-event": false,
                      onFocus: ($event) => minTimePickerVisible.value = true,
                      onInput: (val) => handleTimeInput(val, "min"),
                      onChange: (val) => handleTimeChange(val, "min")
                    }, null, 8, ["class", "disabled", "placeholder", "model-value", "onFocus", "onInput", "onChange"]),
                    vue.createVNode(vue.unref(TimePickPanel), {
                      visible: minTimePickerVisible.value,
                      format: vue.unref(timeFormat),
                      "datetime-role": "start",
                      "parsed-value": leftDate.value,
                      onPick: handleMinTimePick
                    }, null, 8, ["visible", "format", "parsed-value"])
                  ], 2)), [
                    [vue.unref(ClickOutside), handleMinTimeClose]
                  ])
                ], 2),
                vue.createElementVNode("span", null, [
                  vue.createVNode(vue.unref(ElIcon), null, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(arrow_right_default))
                    ]),
                    _: 1
                  })
                ]),
                vue.createElementVNode("span", {
                  class: vue.normalizeClass([vue.unref(drpNs).e("editors-wrap"), "is-right"])
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                  }, [
                    vue.createVNode(vue.unref(ElInput), {
                      size: "small",
                      class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                      disabled: vue.unref(rangeState).selecting || _ctx.disabled,
                      placeholder: vue.unref(t)("el.datepicker.endDate"),
                      "model-value": vue.unref(maxVisibleDate),
                      readonly: !vue.unref(minDate),
                      "validate-event": false,
                      onInput: (val) => handleDateInput(val, "max"),
                      onChange: (val) => handleDateChange(val, "max")
                    }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly", "onInput", "onChange"])
                  ], 2),
                  vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                  }, [
                    vue.createVNode(vue.unref(ElInput), {
                      size: "small",
                      class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                      disabled: vue.unref(rangeState).selecting || _ctx.disabled,
                      placeholder: vue.unref(t)("el.datepicker.endTime"),
                      "model-value": vue.unref(maxVisibleTime),
                      readonly: !vue.unref(minDate),
                      "validate-event": false,
                      onFocus: ($event) => vue.unref(minDate) && (maxTimePickerVisible.value = true),
                      onInput: (val) => handleTimeInput(val, "max"),
                      onChange: (val) => handleTimeChange(val, "max")
                    }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly", "onFocus", "onInput", "onChange"]),
                    vue.createVNode(vue.unref(TimePickPanel), {
                      "datetime-role": "end",
                      visible: maxTimePickerVisible.value,
                      format: vue.unref(timeFormat),
                      "parsed-value": rightDate.value,
                      onPick: handleMaxTimePick
                    }, null, 8, ["visible", "format", "parsed-value"])
                  ], 2)), [
                    [vue.unref(ClickOutside), handleMaxTimeClose]
                  ])
                ], 2)
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-left"])
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                }, [
                  vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
                    "aria-label": vue.unref(t)(`el.datepicker.prevYear`),
                    disabled: _ctx.disabled,
                    onClick: leftPrevYear
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["aria-label", "disabled"]),
                  vue.withDirectives(vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
                    "aria-label": vue.unref(t)(`el.datepicker.prevMonth`),
                    disabled: _ctx.disabled,
                    onClick: leftPrevMonth
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-month", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["aria-label", "disabled"]), [
                    [vue.vShow, vue.unref(leftCurrentView) === "date"]
                  ]),
                  _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 0,
                    type: "button",
                    disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
                    class: vue.normalizeClass([[
                      vue.unref(ppNs).e("icon-btn"),
                      vue.unref(ppNs).is("disabled", !vue.unref(enableYearArrow) || _ctx.disabled)
                    ], "d-arrow-right"]),
                    "aria-label": vue.unref(t)(`el.datepicker.nextYear`),
                    onClick: leftNextYear
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
                  _ctx.unlinkPanels && vue.unref(leftCurrentView) === "date" ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 1,
                    type: "button",
                    disabled: !vue.unref(enableMonthArrow) || _ctx.disabled,
                    class: vue.normalizeClass([[
                      vue.unref(ppNs).e("icon-btn"),
                      vue.unref(ppNs).is("disabled", !vue.unref(enableMonthArrow) || _ctx.disabled)
                    ], "arrow-right"]),
                    "aria-label": vue.unref(t)(`el.datepicker.nextMonth`),
                    onClick: leftNextMonth
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-month", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("div", null, [
                    vue.createElementVNode("span", {
                      role: "button",
                      class: vue.normalizeClass(vue.unref(drpNs).e("header-label")),
                      "aria-live": "polite",
                      tabindex: "0",
                      onKeydown: vue.withKeys(($event) => vue.unref(showLeftPicker)("year"), ["enter"]),
                      onClick: ($event) => vue.unref(showLeftPicker)("year")
                    }, vue.toDisplayString(vue.unref(leftYearLabel)), 43, ["onKeydown", "onClick"]),
                    vue.withDirectives(vue.createElementVNode("span", {
                      role: "button",
                      "aria-live": "polite",
                      tabindex: "0",
                      class: vue.normalizeClass([
                        vue.unref(drpNs).e("header-label"),
                        { active: vue.unref(leftCurrentView) === "month" }
                      ]),
                      onKeydown: vue.withKeys(($event) => vue.unref(showLeftPicker)("month"), ["enter"]),
                      onClick: ($event) => vue.unref(showLeftPicker)("month")
                    }, vue.toDisplayString(vue.unref(t)(`el.datepicker.month${leftDate.value.month() + 1}`)), 43, ["onKeydown", "onClick"]), [
                      [vue.vShow, vue.unref(leftCurrentView) === "date"]
                    ])
                  ])
                ], 2),
                vue.unref(leftCurrentView) === "date" ? (vue.openBlock(), vue.createBlock(DateTable, {
                  key: 0,
                  ref_key: "leftCurrentViewRef",
                  ref: leftCurrentViewRef,
                  "selection-mode": "range",
                  date: leftDate.value,
                  "min-date": vue.unref(minDate),
                  "max-date": vue.unref(maxDate),
                  "range-state": vue.unref(rangeState),
                  "disabled-date": vue.unref(disabledDate),
                  "cell-class-name": vue.unref(cellClassName),
                  "show-week-number": _ctx.showWeekNumber,
                  disabled: _ctx.disabled,
                  onChangerange: vue.unref(handleChangeRange),
                  onPick: handleRangePick,
                  onSelect: vue.unref(onSelect)
                }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "show-week-number", "disabled", "onChangerange", "onSelect"])) : vue.createCommentVNode("v-if", true),
                vue.unref(leftCurrentView) === "year" ? (vue.openBlock(), vue.createBlock(YearTable, {
                  key: 1,
                  ref_key: "leftCurrentViewRef",
                  ref: leftCurrentViewRef,
                  "selection-mode": "year",
                  date: leftDate.value,
                  "disabled-date": vue.unref(disabledDate),
                  "parsed-value": _ctx.parsedValue,
                  disabled: _ctx.disabled,
                  onPick: vue.unref(handleLeftYearPick)
                }, null, 8, ["date", "disabled-date", "parsed-value", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true),
                vue.unref(leftCurrentView) === "month" ? (vue.openBlock(), vue.createBlock(MonthTable, {
                  key: 2,
                  ref_key: "leftCurrentViewRef",
                  ref: leftCurrentViewRef,
                  "selection-mode": "month",
                  date: leftDate.value,
                  "parsed-value": _ctx.parsedValue,
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  onPick: vue.unref(handleLeftMonthPick)
                }, null, 8, ["date", "parsed-value", "disabled-date", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true)
              ], 2),
              vue.createElementVNode("div", {
                class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-right"])
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([
                    vue.unref(drpNs).e("header"),
                    vue.unref(ppNs).is("disabled", !vue.unref(enableYearArrow) || _ctx.disabled)
                  ])
                }, [
                  _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 0,
                    type: "button",
                    disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
                    "aria-label": vue.unref(t)(`el.datepicker.prevYear`),
                    onClick: rightPrevYear
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
                  _ctx.unlinkPanels && vue.unref(rightCurrentView) === "date" ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 1,
                    type: "button",
                    disabled: !vue.unref(enableMonthArrow) || _ctx.disabled,
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
                    "aria-label": vue.unref(t)(`el.datepicker.prevMonth`),
                    onClick: rightPrevMonth
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-month", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("button", {
                    type: "button",
                    "aria-label": vue.unref(t)(`el.datepicker.nextYear`),
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                    disabled: _ctx.disabled,
                    onClick: rightNextYear
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["aria-label", "disabled"]),
                  vue.withDirectives(vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-right"]),
                    disabled: _ctx.disabled,
                    "aria-label": vue.unref(t)(`el.datepicker.nextMonth`),
                    onClick: rightNextMonth
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-month", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "aria-label"]), [
                    [vue.vShow, vue.unref(rightCurrentView) === "date"]
                  ]),
                  vue.createElementVNode("div", null, [
                    vue.createElementVNode("span", {
                      role: "button",
                      class: vue.normalizeClass(vue.unref(drpNs).e("header-label")),
                      "aria-live": "polite",
                      tabindex: "0",
                      onKeydown: vue.withKeys(($event) => vue.unref(showRightPicker)("year"), ["enter"]),
                      onClick: ($event) => vue.unref(showRightPicker)("year")
                    }, vue.toDisplayString(vue.unref(rightYearLabel)), 43, ["onKeydown", "onClick"]),
                    vue.withDirectives(vue.createElementVNode("span", {
                      role: "button",
                      "aria-live": "polite",
                      tabindex: "0",
                      class: vue.normalizeClass([
                        vue.unref(drpNs).e("header-label"),
                        { active: vue.unref(rightCurrentView) === "month" }
                      ]),
                      onKeydown: vue.withKeys(($event) => vue.unref(showRightPicker)("month"), ["enter"]),
                      onClick: ($event) => vue.unref(showRightPicker)("month")
                    }, vue.toDisplayString(vue.unref(t)(`el.datepicker.month${rightDate.value.month() + 1}`)), 43, ["onKeydown", "onClick"]), [
                      [vue.vShow, vue.unref(rightCurrentView) === "date"]
                    ])
                  ])
                ], 2),
                vue.unref(rightCurrentView) === "date" ? (vue.openBlock(), vue.createBlock(DateTable, {
                  key: 0,
                  ref_key: "rightCurrentViewRef",
                  ref: rightCurrentViewRef,
                  "selection-mode": "range",
                  date: rightDate.value,
                  "min-date": vue.unref(minDate),
                  "max-date": vue.unref(maxDate),
                  "range-state": vue.unref(rangeState),
                  "disabled-date": vue.unref(disabledDate),
                  "cell-class-name": vue.unref(cellClassName),
                  "show-week-number": _ctx.showWeekNumber,
                  disabled: _ctx.disabled,
                  onChangerange: vue.unref(handleChangeRange),
                  onPick: handleRangePick,
                  onSelect: vue.unref(onSelect)
                }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "show-week-number", "disabled", "onChangerange", "onSelect"])) : vue.createCommentVNode("v-if", true),
                vue.unref(rightCurrentView) === "year" ? (vue.openBlock(), vue.createBlock(YearTable, {
                  key: 1,
                  ref_key: "rightCurrentViewRef",
                  ref: rightCurrentViewRef,
                  "selection-mode": "year",
                  date: rightDate.value,
                  "disabled-date": vue.unref(disabledDate),
                  "parsed-value": _ctx.parsedValue,
                  disabled: _ctx.disabled,
                  onPick: vue.unref(handleRightYearPick)
                }, null, 8, ["date", "disabled-date", "parsed-value", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true),
                vue.unref(rightCurrentView) === "month" ? (vue.openBlock(), vue.createBlock(MonthTable, {
                  key: 2,
                  ref_key: "rightCurrentViewRef",
                  ref: rightCurrentViewRef,
                  "selection-mode": "month",
                  date: rightDate.value,
                  "parsed-value": _ctx.parsedValue,
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  onPick: vue.unref(handleRightMonthPick)
                }, null, 8, ["date", "parsed-value", "disabled-date", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true)
              ], 2)
            ], 2)
          ], 2),
          _ctx.showFooter && vue.unref(showTime) && (_ctx.showConfirm || vue.unref(clearable)) ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ppNs).e("footer"))
          }, [
            vue.unref(clearable) ? (vue.openBlock(), vue.createBlock(vue.unref(ElButton), {
              key: 0,
              text: "",
              size: "small",
              class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
              onClick: handleClear
            }, {
              default: vue.withCtx(() => [
                vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.clear")), 1)
              ]),
              _: 1
            }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
            _ctx.showConfirm ? (vue.openBlock(), vue.createBlock(vue.unref(ElButton), {
              key: 1,
              plain: "",
              size: "small",
              class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
              disabled: vue.unref(btnDisabled),
              onClick: ($event) => vue.unref(handleRangeConfirm)(false)
            }, {
              default: vue.withCtx(() => [
                vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 1)
              ]),
              _: 1
            }, 8, ["class", "disabled", "onClick"])) : vue.createCommentVNode("v-if", true)
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var DateRangePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1r, [["__file", "panel-date-range.vue"]]);

  const panelMonthRangeProps = buildProps({
    ...panelRangeSharedProps
  });
  const panelMonthRangeEmits = [
    "pick",
    "set-picker-option",
    "calendar-change"
  ];

  const useMonthRangeHeader = ({
    unlinkPanels,
    leftDate,
    rightDate
  }) => {
    const { t } = useLocale();
    const leftPrevYear = () => {
      leftDate.value = leftDate.value.subtract(1, "year");
      if (!unlinkPanels.value) {
        rightDate.value = rightDate.value.subtract(1, "year");
      }
    };
    const rightNextYear = () => {
      if (!unlinkPanels.value) {
        leftDate.value = leftDate.value.add(1, "year");
      }
      rightDate.value = rightDate.value.add(1, "year");
    };
    const leftNextYear = () => {
      leftDate.value = leftDate.value.add(1, "year");
    };
    const rightPrevYear = () => {
      rightDate.value = rightDate.value.subtract(1, "year");
    };
    const leftLabel = vue.computed(() => {
      return `${leftDate.value.year()} ${t("el.datepicker.year")}`;
    });
    const rightLabel = vue.computed(() => {
      return `${rightDate.value.year()} ${t("el.datepicker.year")}`;
    });
    const leftYear = vue.computed(() => {
      return leftDate.value.year();
    });
    const rightYear = vue.computed(() => {
      return rightDate.value.year() === leftDate.value.year() ? leftDate.value.year() + 1 : rightDate.value.year();
    });
    return {
      leftPrevYear,
      rightNextYear,
      leftNextYear,
      rightPrevYear,
      leftLabel,
      rightLabel,
      leftYear,
      rightYear
    };
  };

  const unit$1 = "year";
  const __default__$13 = vue.defineComponent({
    name: "DatePickerMonthRange"
  });
  const _sfc_main$1q = /* @__PURE__ */ vue.defineComponent({
    ...__default__$13,
    props: panelMonthRangeProps,
    emits: panelMonthRangeEmits,
    setup(__props, { emit }) {
      const props = __props;
      const { lang } = useLocale();
      const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
      const isDefaultFormat = vue.inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
      const { shortcuts, disabledDate, cellClassName } = pickerBase.props;
      const format = vue.toRef(pickerBase.props, "format");
      const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
      const leftDate = vue.ref(dayjs().locale(lang.value));
      const rightDate = vue.ref(dayjs().locale(lang.value).add(1, unit$1));
      const {
        minDate,
        maxDate,
        rangeState,
        ppNs,
        drpNs,
        handleChangeRange,
        handleRangeConfirm,
        handleShortcutClick,
        onSelect,
        parseValue
      } = useRangePicker(props, {
        defaultValue,
        leftDate,
        rightDate,
        unit: unit$1,
        sortDates
      });
      const hasShortcuts = vue.computed(() => !!shortcuts.length);
      const {
        leftPrevYear,
        rightNextYear,
        leftNextYear,
        rightPrevYear,
        leftLabel,
        rightLabel,
        leftYear,
        rightYear
      } = useMonthRangeHeader({
        unlinkPanels: vue.toRef(props, "unlinkPanels"),
        leftDate,
        rightDate
      });
      const enableYearArrow = vue.computed(() => {
        return props.unlinkPanels && rightYear.value > leftYear.value + 1;
      });
      const handleRangePick = (val, close = true) => {
        const minDate_ = val.minDate;
        const maxDate_ = val.maxDate;
        if (maxDate.value === maxDate_ && minDate.value === minDate_) {
          return;
        }
        emit("calendar-change", [minDate_.toDate(), maxDate_ && maxDate_.toDate()]);
        maxDate.value = maxDate_;
        minDate.value = minDate_;
        if (!close)
          return;
        handleRangeConfirm();
      };
      const handleClear = () => {
        let valueOnClear = null;
        if (pickerBase == null ? void 0 : pickerBase.emptyValues) {
          valueOnClear = pickerBase.emptyValues.valueOnClear.value;
        }
        leftDate.value = getDefaultValue(vue.unref(defaultValue), {
          lang: vue.unref(lang),
          unit: "year",
          unlinkPanels: props.unlinkPanels
        })[0];
        rightDate.value = leftDate.value.add(1, "year");
        emit("pick", valueOnClear);
      };
      const parseUserInput = (value) => {
        return correctlyParseUserInput(value, format.value, lang.value, isDefaultFormat);
      };
      function sortDates(minDate2, maxDate2) {
        if (props.unlinkPanels && maxDate2) {
          const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
          const maxDateYear = maxDate2.year();
          rightDate.value = minDateYear === maxDateYear ? maxDate2.add(1, unit$1) : maxDate2;
        } else {
          rightDate.value = leftDate.value.add(1, unit$1);
        }
      }
      vue.watch(() => props.visible, (visible) => {
        if (!visible && rangeState.value.selecting) {
          parseValue(props.parsedValue);
          onSelect(false);
        }
      });
      emit("set-picker-option", ["isValidValue", isValidRange]);
      emit("set-picker-option", ["parseUserInput", parseUserInput]);
      emit("set-picker-option", ["handleClear", handleClear]);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ppNs).b(),
            vue.unref(drpNs).b(),
            vue.unref(ppNs).is("border", _ctx.border),
            vue.unref(ppNs).is("disabled", _ctx.disabled),
            {
              "has-sidebar": Boolean(_ctx.$slots.sidebar) || vue.unref(hasShortcuts)
            }
          ])
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
          }, [
            vue.renderSlot(_ctx.$slots, "sidebar", {
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }),
            vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
                return vue.openBlock(), vue.createElementBlock("button", {
                  key,
                  type: "button",
                  class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
                  disabled: _ctx.disabled,
                  onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
                }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
              }), 128))
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("body"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-left"])
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                }, [
                  vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
                    disabled: _ctx.disabled,
                    onClick: vue.unref(leftPrevYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"]),
                  _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 0,
                    type: "button",
                    disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
                    class: vue.normalizeClass([[
                      vue.unref(ppNs).e("icon-btn"),
                      vue.unref(ppNs).is("disabled", !vue.unref(enableYearArrow))
                    ], "d-arrow-right"]),
                    onClick: vue.unref(leftNextYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(leftLabel)), 1)
                ], 2),
                vue.createVNode(MonthTable, {
                  "selection-mode": "range",
                  date: leftDate.value,
                  "min-date": vue.unref(minDate),
                  "max-date": vue.unref(maxDate),
                  "range-state": vue.unref(rangeState),
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  "cell-class-name": vue.unref(cellClassName),
                  onChangerange: vue.unref(handleChangeRange),
                  onPick: handleRangePick,
                  onSelect: vue.unref(onSelect)
                }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
              ], 2),
              vue.createElementVNode("div", {
                class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-right"])
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                }, [
                  _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 0,
                    type: "button",
                    disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
                    class: vue.normalizeClass([[
                      vue.unref(ppNs).e("icon-btn"),
                      vue.unref(ppNs).is("disabled", !vue.unref(enableYearArrow))
                    ], "d-arrow-left"]),
                    onClick: vue.unref(rightPrevYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                    disabled: _ctx.disabled,
                    onClick: vue.unref(rightNextYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"]),
                  vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(rightLabel)), 1)
                ], 2),
                vue.createVNode(MonthTable, {
                  "selection-mode": "range",
                  date: rightDate.value,
                  "min-date": vue.unref(minDate),
                  "max-date": vue.unref(maxDate),
                  "range-state": vue.unref(rangeState),
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  "cell-class-name": vue.unref(cellClassName),
                  onChangerange: vue.unref(handleChangeRange),
                  onPick: handleRangePick,
                  onSelect: vue.unref(onSelect)
                }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
              ], 2)
            ], 2)
          ], 2)
        ], 2);
      };
    }
  });
  var MonthRangePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1q, [["__file", "panel-month-range.vue"]]);

  const panelYearRangeProps = buildProps({
    ...panelRangeSharedProps
  });
  const panelYearRangeEmits = [
    "pick",
    "set-picker-option",
    "calendar-change"
  ];

  const useYearRangeHeader = ({
    unlinkPanels,
    leftDate,
    rightDate
  }) => {
    const leftPrevYear = () => {
      leftDate.value = leftDate.value.subtract(10, "year");
      if (!unlinkPanels.value) {
        rightDate.value = rightDate.value.subtract(10, "year");
      }
    };
    const rightNextYear = () => {
      if (!unlinkPanels.value) {
        leftDate.value = leftDate.value.add(10, "year");
      }
      rightDate.value = rightDate.value.add(10, "year");
    };
    const leftNextYear = () => {
      leftDate.value = leftDate.value.add(10, "year");
    };
    const rightPrevYear = () => {
      rightDate.value = rightDate.value.subtract(10, "year");
    };
    const leftLabel = vue.computed(() => {
      const leftStartDate = Math.floor(leftDate.value.year() / 10) * 10;
      return `${leftStartDate}-${leftStartDate + 9}`;
    });
    const rightLabel = vue.computed(() => {
      const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
      return `${rightStartDate}-${rightStartDate + 9}`;
    });
    const leftYear = vue.computed(() => {
      const leftEndDate = Math.floor(leftDate.value.year() / 10) * 10 + 9;
      return leftEndDate;
    });
    const rightYear = vue.computed(() => {
      const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
      return rightStartDate;
    });
    return {
      leftPrevYear,
      rightNextYear,
      leftNextYear,
      rightPrevYear,
      leftLabel,
      rightLabel,
      leftYear,
      rightYear
    };
  };

  const step = 10;
  const unit = "year";
  const __default__$12 = vue.defineComponent({
    name: "DatePickerYearRange"
  });
  const _sfc_main$1p = /* @__PURE__ */ vue.defineComponent({
    ...__default__$12,
    props: panelYearRangeProps,
    emits: panelYearRangeEmits,
    setup(__props, { emit }) {
      const props = __props;
      const { lang } = useLocale();
      const leftDate = vue.ref(dayjs().locale(lang.value));
      const rightDate = vue.ref(dayjs().locale(lang.value).add(step, unit));
      const isDefaultFormat = vue.inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
      const pickerBase = vue.inject(PICKER_BASE_INJECTION_KEY);
      const { shortcuts, disabledDate, cellClassName } = pickerBase.props;
      const format = vue.toRef(pickerBase.props, "format");
      const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
      const {
        minDate,
        maxDate,
        rangeState,
        ppNs,
        drpNs,
        handleChangeRange,
        handleRangeConfirm,
        handleShortcutClick,
        onSelect,
        parseValue
      } = useRangePicker(props, {
        defaultValue,
        leftDate,
        rightDate,
        step,
        unit,
        sortDates
      });
      const {
        leftPrevYear,
        rightNextYear,
        leftNextYear,
        rightPrevYear,
        leftLabel,
        rightLabel,
        leftYear,
        rightYear
      } = useYearRangeHeader({
        unlinkPanels: vue.toRef(props, "unlinkPanels"),
        leftDate,
        rightDate
      });
      const hasShortcuts = vue.computed(() => !!shortcuts.length);
      const panelKls = vue.computed(() => [
        ppNs.b(),
        drpNs.b(),
        ppNs.is("border", props.border),
        ppNs.is("disabled", props.disabled),
        {
          "has-sidebar": Boolean(vue.useSlots().sidebar) || hasShortcuts.value
        }
      ]);
      const leftPanelKls = vue.computed(() => {
        return {
          content: [ppNs.e("content"), drpNs.e("content"), "is-left"],
          arrowLeftBtn: [ppNs.e("icon-btn"), "d-arrow-left"],
          arrowRightBtn: [
            ppNs.e("icon-btn"),
            ppNs.is("disabled", !enableYearArrow.value),
            "d-arrow-right"
          ]
        };
      });
      const rightPanelKls = vue.computed(() => {
        return {
          content: [ppNs.e("content"), drpNs.e("content"), "is-right"],
          arrowLeftBtn: [
            ppNs.e("icon-btn"),
            ppNs.is("disabled", !enableYearArrow.value),
            "d-arrow-left"
          ],
          arrowRightBtn: [ppNs.e("icon-btn"), "d-arrow-right"]
        };
      });
      const enableYearArrow = vue.computed(() => {
        return props.unlinkPanels && rightYear.value > leftYear.value + 1;
      });
      const handleRangePick = (val, close = true) => {
        const minDate_ = val.minDate;
        const maxDate_ = val.maxDate;
        if (maxDate.value === maxDate_ && minDate.value === minDate_) {
          return;
        }
        emit("calendar-change", [minDate_.toDate(), maxDate_ && maxDate_.toDate()]);
        maxDate.value = maxDate_;
        minDate.value = minDate_;
        if (!close)
          return;
        handleRangeConfirm();
      };
      const parseUserInput = (value) => {
        return correctlyParseUserInput(value, format.value, lang.value, isDefaultFormat);
      };
      const isValidValue = (date) => {
        return isValidRange(date) && (disabledDate ? !disabledDate(date[0].toDate()) && !disabledDate(date[1].toDate()) : true);
      };
      const handleClear = () => {
        let valueOnClear = null;
        if (pickerBase == null ? void 0 : pickerBase.emptyValues) {
          valueOnClear = pickerBase.emptyValues.valueOnClear.value;
        }
        const defaultArr = getDefaultValue(vue.unref(defaultValue), {
          lang: vue.unref(lang),
          step,
          unit,
          unlinkPanels: props.unlinkPanels
        });
        leftDate.value = defaultArr[0];
        rightDate.value = defaultArr[1];
        emit("pick", valueOnClear);
      };
      function sortDates(minDate2, maxDate2) {
        if (props.unlinkPanels && maxDate2) {
          const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
          const maxDateYear = maxDate2.year();
          rightDate.value = minDateYear + step > maxDateYear ? maxDate2.add(step, unit) : maxDate2;
        } else {
          rightDate.value = leftDate.value.add(step, unit);
        }
      }
      vue.watch(() => props.visible, (visible) => {
        if (!visible && rangeState.value.selecting) {
          parseValue(props.parsedValue);
          onSelect(false);
        }
      });
      emit("set-picker-option", ["isValidValue", isValidValue]);
      emit("set-picker-option", ["parseUserInput", parseUserInput]);
      emit("set-picker-option", ["handleClear", handleClear]);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(panelKls))
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
          }, [
            vue.renderSlot(_ctx.$slots, "sidebar", {
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }),
            vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
                return vue.openBlock(), vue.createElementBlock("button", {
                  key,
                  type: "button",
                  class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
                  disabled: _ctx.disabled,
                  onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
                }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
              }), 128))
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("body"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(leftPanelKls).content)
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                }, [
                  vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass(vue.unref(leftPanelKls).arrowLeftBtn),
                    disabled: _ctx.disabled,
                    onClick: vue.unref(leftPrevYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"]),
                  _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 0,
                    type: "button",
                    disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
                    class: vue.normalizeClass(vue.unref(leftPanelKls).arrowRightBtn),
                    onClick: vue.unref(leftNextYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(leftLabel)), 1)
                ], 2),
                vue.createVNode(YearTable, {
                  "selection-mode": "range",
                  date: leftDate.value,
                  "min-date": vue.unref(minDate),
                  "max-date": vue.unref(maxDate),
                  "range-state": vue.unref(rangeState),
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  "cell-class-name": vue.unref(cellClassName),
                  onChangerange: vue.unref(handleChangeRange),
                  onPick: handleRangePick,
                  onSelect: vue.unref(onSelect)
                }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
              ], 2),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(rightPanelKls).content)
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                }, [
                  _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                    key: 0,
                    type: "button",
                    disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
                    class: vue.normalizeClass(vue.unref(rightPanelKls).arrowLeftBtn),
                    onClick: vue.unref(rightPrevYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass(vue.unref(rightPanelKls).arrowRightBtn),
                    disabled: _ctx.disabled,
                    onClick: vue.unref(rightNextYear)
                  }, [
                    vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ])
                  ], 10, ["disabled", "onClick"]),
                  vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(rightLabel)), 1)
                ], 2),
                vue.createVNode(YearTable, {
                  "selection-mode": "range",
                  date: rightDate.value,
                  "min-date": vue.unref(minDate),
                  "max-date": vue.unref(maxDate),
                  "range-state": vue.unref(rangeState),
                  "disabled-date": vue.unref(disabledDate),
                  disabled: _ctx.disabled,
                  "cell-class-name": vue.unref(cellClassName),
                  onChangerange: vue.unref(handleChangeRange),
                  onPick: handleRangePick,
                  onSelect: vue.unref(onSelect)
                }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
              ], 2)
            ], 2)
          ], 2)
        ], 2);
      };
    }
  });
  var YearRangePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1p, [["__file", "panel-year-range.vue"]]);

  const getPanel = function(type) {
    switch (type) {
      case "daterange":
      case "datetimerange": {
        return DateRangePickPanel;
      }
      case "monthrange": {
        return MonthRangePickPanel;
      }
      case "yearrange": {
        return YearRangePickPanel;
      }
      default: {
        return DatePickPanel;
      }
    }
  };

  function _isSlot$7(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  dayjs.extend(localeData);
  dayjs.extend(advancedFormat);
  dayjs.extend(customParseFormat);
  dayjs.extend(weekOfYear);
  dayjs.extend(weekYear);
  dayjs.extend(dayOfYear);
  dayjs.extend(isSameOrAfter);
  dayjs.extend(isSameOrBefore);
  var DatePickerPanel = vue.defineComponent({
    name: "ElDatePickerPanel",
    install: null,
    props: datePickerPanelProps,
    emits: [UPDATE_MODEL_EVENT, "calendar-change", "panel-change", "visible-change", "pick"],
    setup(props, {
      slots,
      emit
    }) {
      const ns = useNamespace("picker-panel");
      const pickerInjection = vue.inject(PICKER_BASE_INJECTION_KEY, void 0);
      if (isUndefined(pickerInjection)) {
        const _props = vue.reactive({
          ...vue.toRefs(props)
        });
        vue.provide(PICKER_BASE_INJECTION_KEY, {
          props: _props
        });
      }
      vue.provide(ROOT_PICKER_INJECTION_KEY, {
        slots,
        pickerNs: ns
      });
      const {
        parsedValue,
        onCalendarChange,
        onPanelChange,
        onSetPickerOption,
        onPick
      } = vue.inject(ROOT_COMMON_PICKER_INJECTION_KEY, () => useCommonPicker(props, emit), true);
      return () => {
        const Component = getPanel(props.type);
        return vue.createVNode(Component, vue.mergeProps(props, {
          "parsedValue": parsedValue.value,
          "onSet-picker-option": onSetPickerOption,
          "onCalendar-change": onCalendarChange,
          "onPanel-change": onPanelChange,
          "onPick": onPick
        }), _isSlot$7(slots) ? slots : {
          default: () => [slots]
        });
      };
    }
  });

  const ElDatePickerPanel = withInstall(DatePickerPanel);

  const datePickerProps = buildProps({
    ...timePickerDefaultProps,
    type: {
      type: definePropType(String),
      default: "date"
    }
  });

  function _isSlot$6(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  var DatePicker = vue.defineComponent({
    name: "ElDatePicker",
    install: null,
    props: datePickerProps,
    emits: [UPDATE_MODEL_EVENT],
    setup(props, {
      expose,
      emit,
      slots
    }) {
      const isDefaultFormat = vue.computed(() => {
        return !props.format;
      });
      vue.provide(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, isDefaultFormat);
      vue.provide(PICKER_POPPER_OPTIONS_INJECTION_KEY, vue.reactive(vue.toRef(props, "popperOptions")));
      const commonPicker = vue.ref();
      const refProps = {
        focus: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.focus();
        },
        blur: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.blur();
        },
        handleOpen: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.handleOpen();
        },
        handleClose: () => {
          var _a;
          (_a = commonPicker.value) == null ? void 0 : _a.handleClose();
        }
      };
      expose(refProps);
      const onModelValueUpdated = (val) => {
        emit(UPDATE_MODEL_EVENT, val);
      };
      return () => {
        var _a;
        const format = (_a = props.format) != null ? _a : DEFAULT_FORMATS_DATEPICKER[props.type] || DEFAULT_FORMATS_DATE;
        return vue.createVNode(CommonPicker, vue.mergeProps(props, {
          "format": format,
          "type": props.type,
          "ref": commonPicker,
          "onUpdate:modelValue": onModelValueUpdated
        }), {
          default: (scopedProps) => vue.createVNode(ElDatePickerPanel, vue.mergeProps({
            "border": false
          }, scopedProps), _isSlot$6(slots) ? slots : {
            default: () => [slots]
          }),
          "range-separator": slots["range-separator"]
        });
      };
    }
  });

  const ElDatePicker = withInstall(DatePicker);

  const descriptionsKey = Symbol("elDescriptions");

  var ElDescriptionsCell = vue.defineComponent({
    name: "ElDescriptionsCell",
    props: {
      cell: {
        type: Object
      },
      tag: {
        type: String,
        default: "td"
      },
      type: {
        type: String
      }
    },
    setup() {
      const descriptions = vue.inject(descriptionsKey, {});
      return {
        descriptions
      };
    },
    render() {
      var _a;
      const item = getNormalizedProps(this.cell);
      const directives = (((_a = this.cell) == null ? void 0 : _a.dirs) || []).map((dire) => {
        const { dir, arg, modifiers, value } = dire;
        return [dir, value, arg, modifiers];
      });
      const { border, direction } = this.descriptions;
      const isVertical = direction === "vertical";
      const renderLabel = () => {
        var _a2, _b, _c;
        return ((_c = (_b = (_a2 = this.cell) == null ? void 0 : _a2.children) == null ? void 0 : _b.label) == null ? void 0 : _c.call(_b)) || item.label;
      };
      const renderContent = () => {
        var _a2, _b, _c;
        return (_c = (_b = (_a2 = this.cell) == null ? void 0 : _a2.children) == null ? void 0 : _b.default) == null ? void 0 : _c.call(_b);
      };
      const span = item.span;
      const rowspan = item.rowspan;
      const align = item.align ? `is-${item.align}` : "";
      const labelAlign = item.labelAlign ? `is-${item.labelAlign}` : align;
      const className = item.className;
      const labelClassName = item.labelClassName;
      const width = this.type === "label" ? item.labelWidth || this.descriptions.labelWidth || item.width : item.width;
      const style = {
        width: addUnit(width),
        minWidth: addUnit(item.minWidth)
      };
      const ns = useNamespace("descriptions");
      switch (this.type) {
        case "label":
          return vue.withDirectives(vue.h(this.tag, {
            style,
            class: [
              ns.e("cell"),
              ns.e("label"),
              ns.is("bordered-label", border),
              ns.is("vertical-label", isVertical),
              labelAlign,
              labelClassName
            ],
            colSpan: isVertical ? span : 1,
            rowspan: isVertical ? 1 : rowspan
          }, renderLabel()), directives);
        case "content":
          return vue.withDirectives(vue.h(this.tag, {
            style,
            class: [
              ns.e("cell"),
              ns.e("content"),
              ns.is("bordered-content", border),
              ns.is("vertical-content", isVertical),
              align,
              className
            ],
            colSpan: isVertical ? span : span * 2 - 1,
            rowspan: isVertical ? rowspan * 2 - 1 : rowspan
          }, renderContent()), directives);
        default: {
          const label = renderLabel();
          const labelStyle = {};
          const width2 = addUnit(item.labelWidth || this.descriptions.labelWidth);
          if (width2) {
            labelStyle.width = width2;
            labelStyle.display = "inline-block";
          }
          return vue.withDirectives(vue.h("td", {
            style,
            class: [ns.e("cell"), align],
            colSpan: span,
            rowspan
          }, [
            !isNil(label) ? vue.h("span", {
              style: labelStyle,
              class: [ns.e("label"), labelClassName]
            }, label) : void 0,
            vue.h("span", {
              class: [ns.e("content"), className]
            }, renderContent())
          ]), directives);
        }
      }
    }
  });

  const descriptionsRowProps = buildProps({
    row: {
      type: definePropType(Array),
      default: () => []
    }
  });

  const __default__$11 = vue.defineComponent({
    name: "ElDescriptionsRow"
  });
  const _sfc_main$1o = /* @__PURE__ */ vue.defineComponent({
    ...__default__$11,
    props: descriptionsRowProps,
    setup(__props) {
      const descriptions = vue.inject(descriptionsKey, {});
      return (_ctx, _cache) => {
        return vue.unref(descriptions).direction === "vertical" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
          vue.createElementVNode("tr", null, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.row, (cell, _index) => {
              return vue.openBlock(), vue.createBlock(vue.unref(ElDescriptionsCell), {
                key: `tr1-${_index}`,
                cell,
                tag: "th",
                type: "label"
              }, null, 8, ["cell"]);
            }), 128))
          ]),
          vue.createElementVNode("tr", null, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.row, (cell, _index) => {
              return vue.openBlock(), vue.createBlock(vue.unref(ElDescriptionsCell), {
                key: `tr2-${_index}`,
                cell,
                tag: "td",
                type: "content"
              }, null, 8, ["cell"]);
            }), 128))
          ])
        ], 64)) : (vue.openBlock(), vue.createElementBlock("tr", { key: 1 }, [
          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.row, (cell, _index) => {
            return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
              key: `tr3-${_index}`
            }, [
              vue.unref(descriptions).border ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                vue.createVNode(vue.unref(ElDescriptionsCell), {
                  cell,
                  tag: "td",
                  type: "label"
                }, null, 8, ["cell"]),
                vue.createVNode(vue.unref(ElDescriptionsCell), {
                  cell,
                  tag: "td",
                  type: "content"
                }, null, 8, ["cell"])
              ], 64)) : (vue.openBlock(), vue.createBlock(vue.unref(ElDescriptionsCell), {
                key: 1,
                cell,
                tag: "td",
                type: "both"
              }, null, 8, ["cell"]))
            ], 64);
          }), 128))
        ]));
      };
    }
  });
  var ElDescriptionsRow = /* @__PURE__ */ _export_sfc(_sfc_main$1o, [["__file", "descriptions-row.vue"]]);

  const descriptionProps = buildProps({
    border: Boolean,
    column: {
      type: Number,
      default: 3
    },
    direction: {
      type: String,
      values: ["horizontal", "vertical"],
      default: "horizontal"
    },
    size: useSizeProp,
    title: {
      type: String,
      default: ""
    },
    extra: {
      type: String,
      default: ""
    },
    labelWidth: {
      type: [String, Number],
      default: ""
    }
  });

  const COMPONENT_NAME$f = "ElDescriptionsItem";

  const __default__$10 = vue.defineComponent({
    name: "ElDescriptions"
  });
  const _sfc_main$1n = /* @__PURE__ */ vue.defineComponent({
    ...__default__$10,
    props: descriptionProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("descriptions");
      const descriptionsSize = useFormSize();
      const slots = vue.useSlots();
      vue.provide(descriptionsKey, props);
      const descriptionKls = vue.computed(() => [ns.b(), ns.m(descriptionsSize.value)]);
      const filledNode = (node, span, count, isLast = false) => {
        if (!node.props) {
          node.props = {};
        }
        if (span > count) {
          node.props.span = count;
        }
        if (isLast) {
          node.props.span = span;
        }
        return node;
      };
      const getRows = () => {
        if (!slots.default)
          return [];
        const children = flattedChildren(slots.default()).filter((node) => {
          var _a;
          return ((_a = node == null ? void 0 : node.type) == null ? void 0 : _a.name) === COMPONENT_NAME$f;
        });
        const rows = [];
        let temp = [];
        let count = props.column;
        let totalSpan = 0;
        const rowspanTemp = [];
        children.forEach((node, index) => {
          var _a, _b, _c;
          const span = ((_a = node.props) == null ? void 0 : _a.span) || 1;
          const rowspan = ((_b = node.props) == null ? void 0 : _b.rowspan) || 1;
          const rowNo = rows.length;
          rowspanTemp[rowNo] || (rowspanTemp[rowNo] = 0);
          if (rowspan > 1) {
            for (let i = 1; i < rowspan; i++) {
              rowspanTemp[_c = rowNo + i] || (rowspanTemp[_c] = 0);
              rowspanTemp[rowNo + i]++;
              totalSpan++;
            }
          }
          if (rowspanTemp[rowNo] > 0) {
            count -= rowspanTemp[rowNo];
            rowspanTemp[rowNo] = 0;
          }
          if (index < children.length - 1) {
            totalSpan += span > count ? count : span;
          }
          if (index === children.length - 1) {
            const lastSpan = props.column - totalSpan % props.column;
            temp.push(filledNode(node, lastSpan, count, true));
            rows.push(temp);
            return;
          }
          if (span < count) {
            count -= span;
            temp.push(node);
          } else {
            temp.push(filledNode(node, span, count));
            rows.push(temp);
            count = props.column;
            temp = [];
          }
        });
        return rows;
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(descriptionKls))
        }, [
          _ctx.title || _ctx.extra || _ctx.$slots.title || _ctx.$slots.extra ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("header"))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("title"))
            }, [
              vue.renderSlot(_ctx.$slots, "title", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
              ])
            ], 2),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("extra"))
            }, [
              vue.renderSlot(_ctx.$slots, "extra", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.extra), 1)
              ])
            ], 2)
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("body"))
          }, [
            vue.createElementVNode("table", {
              class: vue.normalizeClass([vue.unref(ns).e("table"), vue.unref(ns).is("bordered", _ctx.border)])
            }, [
              vue.createElementVNode("tbody", null, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(getRows(), (row, _index) => {
                  return vue.openBlock(), vue.createBlock(ElDescriptionsRow, {
                    key: _index,
                    row
                  }, null, 8, ["row"]);
                }), 128))
              ])
            ], 2)
          ], 2)
        ], 2);
      };
    }
  });
  var Descriptions = /* @__PURE__ */ _export_sfc(_sfc_main$1n, [["__file", "description.vue"]]);

  const descriptionItemProps = buildProps({
    label: {
      type: String,
      default: ""
    },
    span: {
      type: Number,
      default: 1
    },
    rowspan: {
      type: Number,
      default: 1
    },
    width: {
      type: [String, Number],
      default: ""
    },
    minWidth: {
      type: [String, Number],
      default: ""
    },
    labelWidth: {
      type: [String, Number],
      default: ""
    },
    align: {
      type: String,
      values: columnAlignment,
      default: "left"
    },
    labelAlign: {
      type: String,
      values: columnAlignment
    },
    className: {
      type: String,
      default: ""
    },
    labelClassName: {
      type: String,
      default: ""
    }
  });
  const DescriptionItem = vue.defineComponent({
    name: COMPONENT_NAME$f,
    props: descriptionItemProps
  });

  const ElDescriptions = withInstall(Descriptions, {
    DescriptionsItem: DescriptionItem
  });
  const ElDescriptionsItem = withNoopInstall(DescriptionItem);

  const overlayProps = buildProps({
    mask: {
      type: Boolean,
      default: true
    },
    customMaskEvent: Boolean,
    overlayClass: {
      type: definePropType([
        String,
        Array,
        Object
      ])
    },
    zIndex: {
      type: definePropType([String, Number])
    }
  });
  const overlayEmits = {
    click: (evt) => evt instanceof MouseEvent
  };
  const BLOCK = "overlay";
  var Overlay$1 = vue.defineComponent({
    name: "ElOverlay",
    props: overlayProps,
    emits: overlayEmits,
    setup(props, { slots, emit }) {
      const ns = useNamespace(BLOCK);
      const onMaskClick = (e) => {
        emit("click", e);
      };
      const { onClick, onMousedown, onMouseup } = useSameTarget(props.customMaskEvent ? void 0 : onMaskClick);
      return () => {
        return props.mask ? vue.createVNode("div", {
          class: [ns.b(), props.overlayClass],
          style: {
            zIndex: props.zIndex
          },
          onClick,
          onMousedown,
          onMouseup
        }, [vue.renderSlot(slots, "default")], PatchFlags.STYLE | PatchFlags.CLASS | PatchFlags.PROPS, ["onClick", "onMouseup", "onMousedown"]) : vue.h("div", {
          class: props.overlayClass,
          style: {
            zIndex: props.zIndex,
            position: "fixed",
            top: "0px",
            right: "0px",
            bottom: "0px",
            left: "0px"
          }
        }, [vue.renderSlot(slots, "default")]);
      };
    }
  });

  const ElOverlay = Overlay$1;

  const dialogInjectionKey = Symbol("dialogInjectionKey");
  const DEFAULT_DIALOG_TRANSITION = "dialog-fade";

  const dialogContentProps = buildProps({
    center: Boolean,
    alignCenter: {
      type: Boolean,
      default: void 0
    },
    closeIcon: {
      type: iconPropType
    },
    draggable: {
      type: Boolean,
      default: void 0
    },
    overflow: {
      type: Boolean,
      default: void 0
    },
    fullscreen: Boolean,
    headerClass: String,
    bodyClass: String,
    footerClass: String,
    showClose: {
      type: Boolean,
      default: true
    },
    title: {
      type: String,
      default: ""
    },
    ariaLevel: {
      type: String,
      default: "2"
    }
  });
  const dialogContentEmits = {
    close: () => true
  };

  const __default__$$ = vue.defineComponent({ name: "ElDialogContent" });
  const _sfc_main$1m = /* @__PURE__ */ vue.defineComponent({
    ...__default__$$,
    props: dialogContentProps,
    emits: dialogContentEmits,
    setup(__props, { expose }) {
      const props = __props;
      const { t } = useLocale();
      const { Close } = CloseComponents;
      const { dialogRef, headerRef, bodyId, ns, style } = vue.inject(dialogInjectionKey);
      const { focusTrapRef } = vue.inject(FOCUS_TRAP_INJECTION_KEY);
      const composedDialogRef = composeRefs(focusTrapRef, dialogRef);
      const draggable = vue.computed(() => !!props.draggable);
      const overflow = vue.computed(() => !!props.overflow);
      const { resetPosition, updatePosition, isDragging } = useDraggable(dialogRef, headerRef, draggable, overflow);
      const dialogKls = vue.computed(() => [
        ns.b(),
        ns.is("fullscreen", props.fullscreen),
        ns.is("draggable", draggable.value),
        ns.is("dragging", isDragging.value),
        ns.is("align-center", !!props.alignCenter),
        { [ns.m("center")]: props.center }
      ]);
      expose({
        resetPosition,
        updatePosition
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref: vue.unref(composedDialogRef),
          class: vue.normalizeClass(vue.unref(dialogKls)),
          style: vue.normalizeStyle(vue.unref(style)),
          tabindex: "-1"
        }, [
          vue.createElementVNode("header", {
            ref_key: "headerRef",
            ref: headerRef,
            class: vue.normalizeClass([vue.unref(ns).e("header"), _ctx.headerClass, { "show-close": _ctx.showClose }])
          }, [
            vue.renderSlot(_ctx.$slots, "header", {}, () => [
              vue.createElementVNode("span", {
                role: "heading",
                "aria-level": _ctx.ariaLevel,
                class: vue.normalizeClass(vue.unref(ns).e("title"))
              }, vue.toDisplayString(_ctx.title), 11, ["aria-level"])
            ]),
            _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("button", {
              key: 0,
              "aria-label": vue.unref(t)("el.dialog.close"),
              class: vue.normalizeClass(vue.unref(ns).e("headerbtn")),
              type: "button",
              onClick: ($event) => _ctx.$emit("close")
            }, [
              vue.createVNode(vue.unref(ElIcon), {
                class: vue.normalizeClass(vue.unref(ns).e("close"))
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.closeIcon || vue.unref(Close))))
                ]),
                _: 1
              }, 8, ["class"])
            ], 10, ["aria-label", "onClick"])) : vue.createCommentVNode("v-if", true)
          ], 2),
          vue.createElementVNode("div", {
            id: vue.unref(bodyId),
            class: vue.normalizeClass([vue.unref(ns).e("body"), _ctx.bodyClass])
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 10, ["id"]),
          _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("footer", {
            key: 0,
            class: vue.normalizeClass([vue.unref(ns).e("footer"), _ctx.footerClass])
          }, [
            vue.renderSlot(_ctx.$slots, "footer")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 6);
      };
    }
  });
  var ElDialogContent = /* @__PURE__ */ _export_sfc(_sfc_main$1m, [["__file", "dialog-content.vue"]]);

  const dialogProps = buildProps({
    ...dialogContentProps,
    appendToBody: Boolean,
    appendTo: {
      type: teleportProps.to.type,
      default: "body"
    },
    beforeClose: {
      type: definePropType(Function)
    },
    destroyOnClose: Boolean,
    closeOnClickModal: {
      type: Boolean,
      default: true
    },
    closeOnPressEscape: {
      type: Boolean,
      default: true
    },
    lockScroll: {
      type: Boolean,
      default: true
    },
    modal: {
      type: Boolean,
      default: true
    },
    modalPenetrable: Boolean,
    openDelay: {
      type: Number,
      default: 0
    },
    closeDelay: {
      type: Number,
      default: 0
    },
    top: {
      type: String
    },
    modelValue: Boolean,
    modalClass: String,
    headerClass: String,
    bodyClass: String,
    footerClass: String,
    width: {
      type: [String, Number]
    },
    zIndex: {
      type: Number
    },
    trapFocus: Boolean,
    headerAriaLevel: {
      type: String,
      default: "2"
    },
    transition: {
      type: definePropType([String, Object]),
      default: void 0
    }
  });
  const dialogEmits = {
    open: () => true,
    opened: () => true,
    close: () => true,
    closed: () => true,
    [UPDATE_MODEL_EVENT]: (value) => isBoolean(value),
    openAutoFocus: () => true,
    closeAutoFocus: () => true
  };
  const dialogContextKey = Symbol("dialogContextKey");

  const COMPONENT_NAME$e = "ElDialog";
  const useDialog = (props, targetRef) => {
    var _a;
    const instance = vue.getCurrentInstance();
    const emit = instance.emit;
    const { nextZIndex } = useZIndex();
    let lastPosition = "";
    const titleId = useId();
    const bodyId = useId();
    const visible = vue.ref(false);
    const closed = vue.ref(false);
    const rendered = vue.ref(false);
    const zIndex = vue.ref((_a = props.zIndex) != null ? _a : nextZIndex());
    let openTimer = void 0;
    let closeTimer = void 0;
    const config = useGlobalConfig();
    const namespace = vue.computed(() => {
      var _a2, _b;
      return (_b = (_a2 = config.value) == null ? void 0 : _a2.namespace) != null ? _b : defaultNamespace;
    });
    const globalConfig = vue.computed(() => {
      var _a2;
      return (_a2 = config.value) == null ? void 0 : _a2.dialog;
    });
    const style = vue.computed(() => {
      const style2 = {};
      const varPrefix = `--${namespace.value}-dialog`;
      if (!props.fullscreen) {
        if (props.top) {
          style2[`${varPrefix}-margin-top`] = props.top;
        }
        if (props.width) {
          style2[`${varPrefix}-width`] = addUnit(props.width);
        }
      }
      return style2;
    });
    const _draggable = vue.computed(() => {
      var _a2, _b, _c;
      return ((_c = (_b = props.draggable) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.draggable) != null ? _c : false) && !props.fullscreen;
    });
    const _alignCenter = vue.computed(() => {
      var _a2, _b, _c;
      return (_c = (_b = props.alignCenter) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.alignCenter) != null ? _c : false;
    });
    const _overflow = vue.computed(() => {
      var _a2, _b, _c;
      return (_c = (_b = props.overflow) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.overflow) != null ? _c : false;
    });
    const overlayDialogStyle = vue.computed(() => {
      if (_alignCenter.value) {
        return { display: "flex" };
      }
      return {};
    });
    const transitionConfig = vue.computed(() => {
      var _a2, _b, _c;
      const transition = (_c = (_b = props.transition) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.transition) != null ? _c : DEFAULT_DIALOG_TRANSITION;
      const baseConfig = {
        name: transition,
        onAfterEnter: afterEnter,
        onBeforeLeave: beforeLeave,
        onAfterLeave: afterLeave
      };
      if (isObject$1(transition)) {
        const config2 = { ...transition };
        const _mergeHook = (userHook, defaultHook) => {
          return (el) => {
            if (isArray$1(userHook)) {
              userHook.forEach((fn) => {
                if (isFunction$1(fn))
                  fn(el);
              });
            } else if (isFunction$1(userHook)) {
              userHook(el);
            }
            defaultHook();
          };
        };
        config2.onAfterEnter = _mergeHook(config2.onAfterEnter, afterEnter);
        config2.onBeforeLeave = _mergeHook(config2.onBeforeLeave, beforeLeave);
        config2.onAfterLeave = _mergeHook(config2.onAfterLeave, afterLeave);
        if (!config2.name) {
          config2.name = DEFAULT_DIALOG_TRANSITION;
          debugWarn(COMPONENT_NAME$e, `transition.name is missing when using object syntax, fallback to '${DEFAULT_DIALOG_TRANSITION}'`);
        }
        return config2;
      }
      return baseConfig;
    });
    function afterEnter() {
      emit("opened");
    }
    function afterLeave() {
      emit("closed");
      emit(UPDATE_MODEL_EVENT, false);
      if (props.destroyOnClose) {
        rendered.value = false;
      }
    }
    function beforeLeave() {
      emit("close");
    }
    function open() {
      closeTimer == null ? void 0 : closeTimer();
      openTimer == null ? void 0 : openTimer();
      if (props.openDelay && props.openDelay > 0) {
        ({ stop: openTimer } = useTimeoutFn(() => doOpen(), props.openDelay));
      } else {
        doOpen();
      }
    }
    function close() {
      openTimer == null ? void 0 : openTimer();
      closeTimer == null ? void 0 : closeTimer();
      if (props.closeDelay && props.closeDelay > 0) {
        ({ stop: closeTimer } = useTimeoutFn(() => doClose(), props.closeDelay));
      } else {
        doClose();
      }
    }
    function handleClose() {
      function hide(shouldCancel) {
        if (shouldCancel)
          return;
        closed.value = true;
        visible.value = false;
      }
      if (props.beforeClose) {
        props.beforeClose(hide);
      } else {
        close();
      }
    }
    function onModalClick() {
      if (props.closeOnClickModal) {
        handleClose();
      }
    }
    function doOpen() {
      if (!isClient)
        return;
      visible.value = true;
    }
    function doClose() {
      visible.value = false;
    }
    function onOpenAutoFocus() {
      emit("openAutoFocus");
    }
    function onCloseAutoFocus() {
      emit("closeAutoFocus");
    }
    function onFocusoutPrevented(event) {
      var _a2;
      if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) === "pointer") {
        event.preventDefault();
      }
    }
    if (props.lockScroll) {
      useLockscreen(visible);
    }
    function onCloseRequested() {
      if (props.closeOnPressEscape) {
        handleClose();
      }
    }
    vue.watch(() => props.zIndex, () => {
      var _a2;
      zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
    });
    vue.watch(() => props.modelValue, (val) => {
      var _a2;
      if (val) {
        closed.value = false;
        open();
        rendered.value = true;
        zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
        vue.nextTick(() => {
          emit("open");
          if (targetRef.value) {
            targetRef.value.parentElement.scrollTop = 0;
            targetRef.value.parentElement.scrollLeft = 0;
            targetRef.value.scrollTop = 0;
          }
        });
      } else {
        if (visible.value) {
          close();
        }
      }
    });
    vue.watch(() => props.fullscreen, (val) => {
      if (!targetRef.value)
        return;
      if (val) {
        lastPosition = targetRef.value.style.transform;
        targetRef.value.style.transform = "";
      } else {
        targetRef.value.style.transform = lastPosition;
      }
    });
    vue.onMounted(() => {
      if (props.modelValue) {
        visible.value = true;
        rendered.value = true;
        open();
      }
    });
    return {
      afterEnter,
      afterLeave,
      beforeLeave,
      handleClose,
      onModalClick,
      close,
      doClose,
      onOpenAutoFocus,
      onCloseAutoFocus,
      onCloseRequested,
      onFocusoutPrevented,
      titleId,
      bodyId,
      closed,
      style,
      overlayDialogStyle,
      rendered,
      visible,
      zIndex,
      transitionConfig,
      _draggable,
      _alignCenter,
      _overflow
    };
  };

  const __default__$_ = vue.defineComponent({
    name: "ElDialog",
    inheritAttrs: false
  });
  const _sfc_main$1l = /* @__PURE__ */ vue.defineComponent({
    ...__default__$_,
    props: dialogProps,
    emits: dialogEmits,
    setup(__props, { expose }) {
      const props = __props;
      const slots = vue.useSlots();
      useDeprecated({
        scope: "el-dialog",
        from: "the title slot",
        replacement: "the header slot",
        version: "3.0.0",
        ref: "https://element-plus.org/en-US/component/dialog.html#slots"
      }, vue.computed(() => !!slots.title));
      const ns = useNamespace("dialog");
      const dialogRef = vue.ref();
      const headerRef = vue.ref();
      const dialogContentRef = vue.ref();
      const {
        visible,
        titleId,
        bodyId,
        style,
        overlayDialogStyle,
        rendered,
        transitionConfig,
        zIndex,
        _draggable,
        _alignCenter,
        _overflow,
        handleClose,
        onModalClick,
        onOpenAutoFocus,
        onCloseAutoFocus,
        onCloseRequested,
        onFocusoutPrevented
      } = useDialog(props, dialogRef);
      vue.provide(dialogInjectionKey, {
        dialogRef,
        headerRef,
        bodyId,
        ns,
        rendered,
        style
      });
      const overlayEvent = useSameTarget(onModalClick);
      const penetrable = vue.computed(() => props.modalPenetrable && !props.modal && !props.fullscreen);
      const resetPosition = () => {
        var _a;
        (_a = dialogContentRef.value) == null ? void 0 : _a.resetPosition();
      };
      expose({
        visible,
        dialogContentRef,
        resetPosition,
        handleClose
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTeleport$1), {
          to: _ctx.appendTo,
          disabled: _ctx.appendTo !== "body" ? false : !_ctx.appendToBody
        }, {
          default: vue.withCtx(() => [
            vue.createVNode(vue.Transition, vue.mergeProps(vue.unref(transitionConfig), { persisted: "" }), {
              default: vue.withCtx(() => {
                var _a;
                return [
                  vue.withDirectives(vue.createVNode(vue.unref(ElOverlay), {
                    "custom-mask-event": "",
                    mask: _ctx.modal,
                    "overlay-class": [
                      (_a = _ctx.modalClass) != null ? _a : "",
                      `${vue.unref(ns).namespace.value}-modal-dialog`,
                      vue.unref(ns).is("penetrable", vue.unref(penetrable))
                    ],
                    "z-index": vue.unref(zIndex)
                  }, {
                    default: vue.withCtx(() => [
                      vue.createElementVNode("div", {
                        role: "dialog",
                        "aria-modal": "true",
                        "aria-label": _ctx.title || void 0,
                        "aria-labelledby": !_ctx.title ? vue.unref(titleId) : void 0,
                        "aria-describedby": vue.unref(bodyId),
                        class: vue.normalizeClass(`${vue.unref(ns).namespace.value}-overlay-dialog`),
                        style: vue.normalizeStyle(vue.unref(overlayDialogStyle)),
                        onClick: vue.unref(overlayEvent).onClick,
                        onMousedown: vue.unref(overlayEvent).onMousedown,
                        onMouseup: vue.unref(overlayEvent).onMouseup
                      }, [
                        vue.createVNode(vue.unref(ElFocusTrap), {
                          loop: "",
                          trapped: vue.unref(visible),
                          "focus-start-el": "container",
                          onFocusAfterTrapped: vue.unref(onOpenAutoFocus),
                          onFocusAfterReleased: vue.unref(onCloseAutoFocus),
                          onFocusoutPrevented: vue.unref(onFocusoutPrevented),
                          onReleaseRequested: vue.unref(onCloseRequested)
                        }, {
                          default: vue.withCtx(() => [
                            vue.unref(rendered) ? (vue.openBlock(), vue.createBlock(ElDialogContent, vue.mergeProps({
                              key: 0,
                              ref_key: "dialogContentRef",
                              ref: dialogContentRef
                            }, _ctx.$attrs, {
                              center: _ctx.center,
                              "align-center": vue.unref(_alignCenter),
                              "close-icon": _ctx.closeIcon,
                              draggable: vue.unref(_draggable),
                              overflow: vue.unref(_overflow),
                              fullscreen: _ctx.fullscreen,
                              "header-class": _ctx.headerClass,
                              "body-class": _ctx.bodyClass,
                              "footer-class": _ctx.footerClass,
                              "show-close": _ctx.showClose,
                              title: _ctx.title,
                              "aria-level": _ctx.headerAriaLevel,
                              onClose: vue.unref(handleClose)
                            }), vue.createSlots({
                              header: vue.withCtx(() => [
                                !_ctx.$slots.title ? vue.renderSlot(_ctx.$slots, "header", {
                                  key: 0,
                                  close: vue.unref(handleClose),
                                  titleId: vue.unref(titleId),
                                  titleClass: vue.unref(ns).e("title")
                                }) : vue.renderSlot(_ctx.$slots, "title", { key: 1 })
                              ]),
                              default: vue.withCtx(() => [
                                vue.renderSlot(_ctx.$slots, "default")
                              ]),
                              _: 2
                            }, [
                              _ctx.$slots.footer ? {
                                name: "footer",
                                fn: vue.withCtx(() => [
                                  vue.renderSlot(_ctx.$slots, "footer")
                                ])
                              } : void 0
                            ]), 1040, ["center", "align-center", "close-icon", "draggable", "overflow", "fullscreen", "header-class", "body-class", "footer-class", "show-close", "title", "aria-level", "onClose"])) : vue.createCommentVNode("v-if", true)
                          ]),
                          _: 3
                        }, 8, ["trapped", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
                      ], 46, ["aria-label", "aria-labelledby", "aria-describedby", "onClick", "onMousedown", "onMouseup"])
                    ]),
                    _: 3
                  }, 8, ["mask", "overlay-class", "z-index"]), [
                    [vue.vShow, vue.unref(visible)]
                  ])
                ];
              }),
              _: 3
            }, 16)
          ]),
          _: 3
        }, 8, ["to", "disabled"]);
      };
    }
  });
  var Dialog = /* @__PURE__ */ _export_sfc(_sfc_main$1l, [["__file", "dialog.vue"]]);

  const ElDialog = withInstall(Dialog);

  const dividerProps = buildProps({
    direction: {
      type: String,
      values: ["horizontal", "vertical"],
      default: "horizontal"
    },
    contentPosition: {
      type: String,
      values: ["left", "center", "right"],
      default: "center"
    },
    borderStyle: {
      type: definePropType(String),
      default: "solid"
    }
  });

  const __default__$Z = vue.defineComponent({
    name: "ElDivider"
  });
  const _sfc_main$1k = /* @__PURE__ */ vue.defineComponent({
    ...__default__$Z,
    props: dividerProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("divider");
      const dividerStyle = vue.computed(() => {
        return ns.cssVar({
          "border-style": props.borderStyle
        });
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.direction)]),
          style: vue.normalizeStyle(vue.unref(dividerStyle)),
          role: "separator"
        }, [
          _ctx.$slots.default && _ctx.direction !== "vertical" ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass([vue.unref(ns).e("text"), vue.unref(ns).is(_ctx.contentPosition)])
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 6);
      };
    }
  });
  var Divider = /* @__PURE__ */ _export_sfc(_sfc_main$1k, [["__file", "divider.vue"]]);

  const ElDivider = withInstall(Divider);

  const drawerProps = buildProps({
    ...dialogProps,
    direction: {
      type: String,
      default: "rtl",
      values: ["ltr", "rtl", "ttb", "btt"]
    },
    resizable: Boolean,
    size: {
      type: [String, Number],
      default: "30%"
    },
    withHeader: {
      type: Boolean,
      default: true
    },
    modalFade: {
      type: Boolean,
      default: true
    },
    headerAriaLevel: {
      type: String,
      default: "2"
    }
  });
  const drawerEmits = dialogEmits;

  function useResizable(props, target) {
    const { width, height } = useWindowSize();
    const isHorizontal = vue.computed(() => ["ltr", "rtl"].includes(props.direction));
    const sign = vue.computed(() => ["ltr", "ttb"].includes(props.direction) ? 1 : -1);
    const windowSize = vue.computed(() => isHorizontal.value ? width.value : height.value);
    const getSize = vue.computed(() => {
      return clamp$2(startSize.value + sign.value * offset.value, 4, windowSize.value);
    });
    const startSize = vue.ref(0);
    const offset = vue.ref(0);
    const isResizing = vue.ref(false);
    const hasStartedDragging = vue.ref(false);
    let startPos = [];
    let cleanups = [];
    const getActualSize = () => {
      var _a;
      const drawerEl = (_a = target.value) == null ? void 0 : _a.closest('[aria-modal="true"]');
      if (drawerEl) {
        return isHorizontal.value ? drawerEl.offsetWidth : drawerEl.offsetHeight;
      }
      return 100;
    };
    vue.watch(() => [props.size, props.resizable], () => {
      hasStartedDragging.value = false;
      startSize.value = 0;
      offset.value = 0;
      onMouseUp();
    });
    const onMousedown = (e) => {
      if (!props.resizable)
        return;
      if (!hasStartedDragging.value) {
        startSize.value = getActualSize();
        hasStartedDragging.value = true;
      }
      startPos = [e.pageX, e.pageY];
      isResizing.value = true;
      cleanups.push(useEventListener(window, "mouseup", onMouseUp), useEventListener(window, "mousemove", onMouseMove));
    };
    const onMouseMove = (e) => {
      const { pageX, pageY } = e;
      const offsetX = pageX - startPos[0];
      const offsetY = pageY - startPos[1];
      offset.value = isHorizontal.value ? offsetX : offsetY;
    };
    const onMouseUp = () => {
      startPos = [];
      startSize.value = getSize.value;
      offset.value = 0;
      isResizing.value = false;
      cleanups.forEach((cleanup2) => cleanup2 == null ? void 0 : cleanup2());
      cleanups = [];
    };
    const cleanup = useEventListener(target, "mousedown", onMousedown);
    vue.onBeforeUnmount(() => {
      cleanup();
      onMouseUp();
    });
    return {
      size: vue.computed(() => {
        return hasStartedDragging.value ? `${getSize.value}px` : addUnit(props.size);
      }),
      isResizing,
      isHorizontal
    };
  }

  const __default__$Y = vue.defineComponent({
    name: "ElDrawer",
    inheritAttrs: false
  });
  const _sfc_main$1j = /* @__PURE__ */ vue.defineComponent({
    ...__default__$Y,
    props: drawerProps,
    emits: drawerEmits,
    setup(__props, { expose }) {
      const props = __props;
      const slots = vue.useSlots();
      useDeprecated({
        scope: "el-drawer",
        from: "the title slot",
        replacement: "the header slot",
        version: "3.0.0",
        ref: "https://element-plus.org/en-US/component/drawer.html#slots"
      }, vue.computed(() => !!slots.title));
      const drawerRef = vue.ref();
      const focusStartRef = vue.ref();
      const draggerRef = vue.ref();
      const ns = useNamespace("drawer");
      const { t } = useLocale();
      const {
        afterEnter,
        afterLeave,
        beforeLeave,
        visible,
        rendered,
        titleId,
        bodyId,
        zIndex,
        onModalClick,
        onOpenAutoFocus,
        onCloseAutoFocus,
        onFocusoutPrevented,
        onCloseRequested,
        handleClose
      } = useDialog(props, drawerRef);
      const { isHorizontal, size, isResizing } = useResizable(props, draggerRef);
      const penetrable = vue.computed(() => props.modalPenetrable && !props.modal);
      expose({
        handleClose,
        afterEnter,
        afterLeave
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTeleport$1), {
          to: _ctx.appendTo,
          disabled: _ctx.appendTo !== "body" ? false : !_ctx.appendToBody
        }, {
          default: vue.withCtx(() => [
            vue.createVNode(vue.Transition, {
              name: vue.unref(ns).b("fade"),
              onAfterEnter: vue.unref(afterEnter),
              onAfterLeave: vue.unref(afterLeave),
              onBeforeLeave: vue.unref(beforeLeave),
              persisted: ""
            }, {
              default: vue.withCtx(() => {
                var _a;
                return [
                  vue.withDirectives(vue.createVNode(vue.unref(ElOverlay), {
                    mask: _ctx.modal,
                    "overlay-class": [
                      vue.unref(ns).is("drawer"),
                      (_a = _ctx.modalClass) != null ? _a : "",
                      `${vue.unref(ns).namespace.value}-modal-drawer`,
                      vue.unref(ns).is("penetrable", vue.unref(penetrable))
                    ],
                    "z-index": vue.unref(zIndex),
                    onClick: vue.unref(onModalClick)
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(ElFocusTrap), {
                        loop: "",
                        trapped: vue.unref(visible),
                        "focus-trap-el": drawerRef.value,
                        "focus-start-el": focusStartRef.value,
                        onFocusAfterTrapped: vue.unref(onOpenAutoFocus),
                        onFocusAfterReleased: vue.unref(onCloseAutoFocus),
                        onFocusoutPrevented: vue.unref(onFocusoutPrevented),
                        onReleaseRequested: vue.unref(onCloseRequested)
                      }, {
                        default: vue.withCtx(() => [
                          vue.createElementVNode("div", vue.mergeProps({
                            ref_key: "drawerRef",
                            ref: drawerRef,
                            "aria-modal": "true",
                            "aria-label": _ctx.title || void 0,
                            "aria-labelledby": !_ctx.title ? vue.unref(titleId) : void 0,
                            "aria-describedby": vue.unref(bodyId)
                          }, _ctx.$attrs, {
                            class: [
                              vue.unref(ns).b(),
                              _ctx.direction,
                              vue.unref(visible) && "open",
                              vue.unref(ns).is("dragging", vue.unref(isResizing))
                            ],
                            style: { [vue.unref(isHorizontal) ? "width" : "height"]: vue.unref(size) },
                            role: "dialog",
                            onClick: vue.withModifiers(() => {
                            }, ["stop"])
                          }), [
                            vue.createElementVNode("span", {
                              ref_key: "focusStartRef",
                              ref: focusStartRef,
                              class: vue.normalizeClass(vue.unref(ns).e("sr-focus")),
                              tabindex: "-1"
                            }, null, 2),
                            _ctx.withHeader ? (vue.openBlock(), vue.createElementBlock("header", {
                              key: 0,
                              class: vue.normalizeClass([vue.unref(ns).e("header"), _ctx.headerClass])
                            }, [
                              !_ctx.$slots.title ? vue.renderSlot(_ctx.$slots, "header", {
                                key: 0,
                                close: vue.unref(handleClose),
                                titleId: vue.unref(titleId),
                                titleClass: vue.unref(ns).e("title")
                              }, () => [
                                vue.createElementVNode("span", {
                                  id: vue.unref(titleId),
                                  role: "heading",
                                  "aria-level": _ctx.headerAriaLevel,
                                  class: vue.normalizeClass(vue.unref(ns).e("title"))
                                }, vue.toDisplayString(_ctx.title), 11, ["id", "aria-level"])
                              ]) : vue.renderSlot(_ctx.$slots, "title", { key: 1 }, () => [
                                vue.createCommentVNode(" DEPRECATED SLOT ")
                              ]),
                              _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("button", {
                                key: 2,
                                "aria-label": vue.unref(t)("el.drawer.close"),
                                class: vue.normalizeClass(vue.unref(ns).e("close-btn")),
                                type: "button",
                                onClick: vue.unref(handleClose)
                              }, [
                                vue.createVNode(vue.unref(ElIcon), {
                                  class: vue.normalizeClass(vue.unref(ns).e("close"))
                                }, {
                                  default: vue.withCtx(() => [
                                    vue.createVNode(vue.unref(close_default))
                                  ]),
                                  _: 1
                                }, 8, ["class"])
                              ], 10, ["aria-label", "onClick"])) : vue.createCommentVNode("v-if", true)
                            ], 2)) : vue.createCommentVNode("v-if", true),
                            vue.unref(rendered) ? (vue.openBlock(), vue.createElementBlock("div", {
                              key: 1,
                              id: vue.unref(bodyId),
                              class: vue.normalizeClass([vue.unref(ns).e("body"), _ctx.bodyClass])
                            }, [
                              vue.renderSlot(_ctx.$slots, "default")
                            ], 10, ["id"])) : vue.createCommentVNode("v-if", true),
                            _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", {
                              key: 2,
                              class: vue.normalizeClass([vue.unref(ns).e("footer"), _ctx.footerClass])
                            }, [
                              vue.renderSlot(_ctx.$slots, "footer")
                            ], 2)) : vue.createCommentVNode("v-if", true),
                            _ctx.resizable ? (vue.openBlock(), vue.createElementBlock("div", {
                              key: 3,
                              ref_key: "draggerRef",
                              ref: draggerRef,
                              style: vue.normalizeStyle({ zIndex: vue.unref(zIndex) }),
                              class: vue.normalizeClass(vue.unref(ns).e("dragger"))
                            }, null, 6)) : vue.createCommentVNode("v-if", true)
                          ], 16, ["aria-label", "aria-labelledby", "aria-describedby", "onClick"])
                        ]),
                        _: 3
                      }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
                    ]),
                    _: 3
                  }, 8, ["mask", "overlay-class", "z-index", "onClick"]), [
                    [vue.vShow, vue.unref(visible)]
                  ])
                ];
              }),
              _: 3
            }, 8, ["name", "onAfterEnter", "onAfterLeave", "onBeforeLeave"])
          ]),
          _: 3
        }, 8, ["to", "disabled"]);
      };
    }
  });
  var Drawer = /* @__PURE__ */ _export_sfc(_sfc_main$1j, [["__file", "drawer.vue"]]);

  const ElDrawer = withInstall(Drawer);

  const _sfc_main$1i = vue.defineComponent({
    inheritAttrs: false
  });
  function _sfc_render$k(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.renderSlot(_ctx.$slots, "default");
  }
  var Collection = /* @__PURE__ */ _export_sfc(_sfc_main$1i, [["render", _sfc_render$k], ["__file", "collection.vue"]]);

  const _sfc_main$1h = vue.defineComponent({
    name: "ElCollectionItem",
    inheritAttrs: false
  });
  function _sfc_render$j(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.renderSlot(_ctx.$slots, "default");
  }
  var CollectionItem = /* @__PURE__ */ _export_sfc(_sfc_main$1h, [["render", _sfc_render$j], ["__file", "collection-item.vue"]]);

  const COLLECTION_ITEM_SIGN = `data-el-collection-item`;
  const createCollectionWithScope = (name) => {
    const COLLECTION_NAME = `El${name}Collection`;
    const COLLECTION_ITEM_NAME = `${COLLECTION_NAME}Item`;
    const COLLECTION_INJECTION_KEY = Symbol(COLLECTION_NAME);
    const COLLECTION_ITEM_INJECTION_KEY = Symbol(COLLECTION_ITEM_NAME);
    const ElCollection = {
      ...Collection,
      name: COLLECTION_NAME,
      setup() {
        const collectionRef = vue.ref();
        const itemMap = /* @__PURE__ */ new Map();
        const getItems = () => {
          const collectionEl = vue.unref(collectionRef);
          if (!collectionEl)
            return [];
          const orderedNodes = Array.from(collectionEl.querySelectorAll(`[${COLLECTION_ITEM_SIGN}]`));
          const items = [...itemMap.values()];
          return items.sort((a, b) => orderedNodes.indexOf(a.ref) - orderedNodes.indexOf(b.ref));
        };
        vue.provide(COLLECTION_INJECTION_KEY, {
          itemMap,
          getItems,
          collectionRef
        });
      }
    };
    const ElCollectionItem = {
      ...CollectionItem,
      name: COLLECTION_ITEM_NAME,
      setup(_, { attrs }) {
        const collectionItemRef = vue.ref();
        const collectionInjection = vue.inject(COLLECTION_INJECTION_KEY, void 0);
        vue.provide(COLLECTION_ITEM_INJECTION_KEY, {
          collectionItemRef
        });
        vue.onMounted(() => {
          const collectionItemEl = vue.unref(collectionItemRef);
          if (collectionItemEl) {
            collectionInjection.itemMap.set(collectionItemEl, {
              ref: collectionItemEl,
              ...attrs
            });
          }
        });
        vue.onBeforeUnmount(() => {
          const collectionItemEl = vue.unref(collectionItemRef);
          collectionInjection.itemMap.delete(collectionItemEl);
        });
      }
    };
    return {
      COLLECTION_INJECTION_KEY,
      COLLECTION_ITEM_INJECTION_KEY,
      ElCollection,
      ElCollectionItem
    };
  };

  const rovingFocusGroupProps = buildProps({
    style: { type: definePropType([String, Array, Object]) },
    currentTabId: {
      type: definePropType(String)
    },
    defaultCurrentTabId: String,
    loop: Boolean,
    dir: {
      type: String,
      values: ["ltr", "rtl"],
      default: "ltr"
    },
    orientation: {
      type: definePropType(String)
    },
    onBlur: Function,
    onFocus: Function,
    onMousedown: Function
  });
  const {
    ElCollection,
    ElCollectionItem,
    COLLECTION_INJECTION_KEY,
    COLLECTION_ITEM_INJECTION_KEY
  } = createCollectionWithScope("RovingFocusGroup");

  const ROVING_FOCUS_GROUP_INJECTION_KEY = Symbol("elRovingFocusGroup");
  const ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY = Symbol("elRovingFocusGroupItem");

  const MAP_KEY_TO_FOCUS_INTENT = {
    ArrowLeft: "prev",
    ArrowUp: "prev",
    ArrowRight: "next",
    ArrowDown: "next",
    PageUp: "first",
    Home: "first",
    PageDown: "last",
    End: "last"
  };
  const getDirectionAwareKey = (key, dir) => {
    if (dir !== "rtl")
      return key;
    switch (key) {
      case EVENT_CODE.right:
        return EVENT_CODE.left;
      case EVENT_CODE.left:
        return EVENT_CODE.right;
      default:
        return key;
    }
  };
  const getFocusIntent = (event, orientation, dir) => {
    const code = getEventCode(event);
    const key = getDirectionAwareKey(code, dir);
    if (orientation === "vertical" && [EVENT_CODE.left, EVENT_CODE.right].includes(key))
      return void 0;
    if (orientation === "horizontal" && [EVENT_CODE.up, EVENT_CODE.down].includes(key))
      return void 0;
    return MAP_KEY_TO_FOCUS_INTENT[key];
  };
  const reorderArray = (array, atIdx) => {
    return array.map((_, idx) => array[(idx + atIdx) % array.length]);
  };
  const focusFirst = (elements) => {
    const { activeElement: prevActive } = document;
    for (const element of elements) {
      if (element === prevActive)
        return;
      element.focus();
      if (prevActive !== document.activeElement)
        return;
    }
  };

  const CURRENT_TAB_ID_CHANGE_EVT = "currentTabIdChange";
  const ENTRY_FOCUS_EVT = "rovingFocusGroup.entryFocus";
  const EVT_OPTS = { bubbles: false, cancelable: true };
  const _sfc_main$1g = vue.defineComponent({
    name: "ElRovingFocusGroupImpl",
    inheritAttrs: false,
    props: rovingFocusGroupProps,
    emits: [CURRENT_TAB_ID_CHANGE_EVT, "entryFocus"],
    setup(props, { emit }) {
      var _a;
      const currentTabbedId = vue.ref((_a = props.currentTabId || props.defaultCurrentTabId) != null ? _a : null);
      const isBackingOut = vue.ref(false);
      const isClickFocus = vue.ref(false);
      const rovingFocusGroupRef = vue.ref();
      const { getItems } = vue.inject(COLLECTION_INJECTION_KEY, void 0);
      const rovingFocusGroupRootStyle = vue.computed(() => {
        return [
          {
            outline: "none"
          },
          props.style
        ];
      });
      const onItemFocus = (tabbedId) => {
        emit(CURRENT_TAB_ID_CHANGE_EVT, tabbedId);
      };
      const onItemShiftTab = () => {
        isBackingOut.value = true;
      };
      const onMousedown = composeEventHandlers((e) => {
        var _a2;
        (_a2 = props.onMousedown) == null ? void 0 : _a2.call(props, e);
      }, () => {
        isClickFocus.value = true;
      });
      const onFocus = composeEventHandlers((e) => {
        var _a2;
        (_a2 = props.onFocus) == null ? void 0 : _a2.call(props, e);
      }, (e) => {
        const isKeyboardFocus = !vue.unref(isClickFocus);
        const { target, currentTarget } = e;
        if (target === currentTarget && isKeyboardFocus && !vue.unref(isBackingOut)) {
          const entryFocusEvt = new Event(ENTRY_FOCUS_EVT, EVT_OPTS);
          currentTarget == null ? void 0 : currentTarget.dispatchEvent(entryFocusEvt);
          if (!entryFocusEvt.defaultPrevented) {
            const items = getItems().filter((item) => item.focusable);
            const activeItem = items.find((item) => item.active);
            const currentItem = items.find((item) => item.id === vue.unref(currentTabbedId));
            const candidates = [activeItem, currentItem, ...items].filter(Boolean);
            const candidateNodes = candidates.map((item) => item.ref);
            focusFirst(candidateNodes);
          }
        }
        isClickFocus.value = false;
      });
      const onBlur = composeEventHandlers((e) => {
        var _a2;
        (_a2 = props.onBlur) == null ? void 0 : _a2.call(props, e);
      }, () => {
        isBackingOut.value = false;
      });
      const handleEntryFocus = (...args) => {
        emit("entryFocus", ...args);
      };
      const onKeydown = (e) => {
        const focusIntent = getFocusIntent(e);
        if (focusIntent) {
          e.preventDefault();
          const items = getItems().filter((item) => item.focusable);
          let elements = items.map((item) => item.ref);
          switch (focusIntent) {
            case "last": {
              elements.reverse();
              break;
            }
            case "prev":
            case "next": {
              if (focusIntent === "prev") {
                elements.reverse();
              }
              const currentIdx = elements.indexOf(e.currentTarget);
              elements = props.loop ? reorderArray(elements, currentIdx + 1) : elements.slice(currentIdx + 1);
              break;
            }
          }
          vue.nextTick(() => {
            focusFirst(elements);
          });
        }
      };
      vue.provide(ROVING_FOCUS_GROUP_INJECTION_KEY, {
        currentTabbedId: vue.readonly(currentTabbedId),
        loop: vue.toRef(props, "loop"),
        tabIndex: vue.computed(() => {
          return vue.unref(isBackingOut) ? -1 : 0;
        }),
        rovingFocusGroupRef,
        rovingFocusGroupRootStyle,
        orientation: vue.toRef(props, "orientation"),
        dir: vue.toRef(props, "dir"),
        onItemFocus,
        onItemShiftTab,
        onBlur,
        onFocus,
        onMousedown,
        onKeydown
      });
      vue.watch(() => props.currentTabId, (val) => {
        currentTabbedId.value = val != null ? val : null;
      });
      useEventListener(rovingFocusGroupRef, ENTRY_FOCUS_EVT, handleEntryFocus);
    }
  });
  function _sfc_render$i(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.renderSlot(_ctx.$slots, "default");
  }
  var ElRovingFocusGroupImpl = /* @__PURE__ */ _export_sfc(_sfc_main$1g, [["render", _sfc_render$i], ["__file", "roving-focus-group-impl.vue"]]);

  const _sfc_main$1f = vue.defineComponent({
    name: "ElRovingFocusGroup",
    components: {
      ElFocusGroupCollection: ElCollection,
      ElRovingFocusGroupImpl
    }
  });
  function _sfc_render$h(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_roving_focus_group_impl = vue.resolveComponent("el-roving-focus-group-impl");
    const _component_el_focus_group_collection = vue.resolveComponent("el-focus-group-collection");
    return vue.openBlock(), vue.createBlock(_component_el_focus_group_collection, null, {
      default: vue.withCtx(() => [
        vue.createVNode(_component_el_roving_focus_group_impl, vue.normalizeProps(vue.guardReactiveProps(_ctx.$attrs)), {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 16)
      ]),
      _: 3
    });
  }
  var ElRovingFocusGroup = /* @__PURE__ */ _export_sfc(_sfc_main$1f, [["render", _sfc_render$h], ["__file", "roving-focus-group.vue"]]);

  const _sfc_main$1e = vue.defineComponent({
    components: {
      ElRovingFocusCollectionItem: ElCollectionItem
    },
    props: {
      focusable: {
        type: Boolean,
        default: true
      },
      active: Boolean
    },
    emits: ["mousedown", "focus", "keydown"],
    setup(props, { emit }) {
      const { currentTabbedId, onItemFocus, onItemShiftTab, onKeydown } = vue.inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
      const id = useId();
      const rovingFocusGroupItemRef = vue.ref();
      const handleMousedown = composeEventHandlers((e) => {
        emit("mousedown", e);
      }, (e) => {
        if (!props.focusable) {
          e.preventDefault();
        } else {
          onItemFocus(vue.unref(id));
        }
      });
      const handleFocus = composeEventHandlers((e) => {
        emit("focus", e);
      }, () => {
        onItemFocus(vue.unref(id));
      });
      const handleKeydown = composeEventHandlers((e) => {
        emit("keydown", e);
      }, (e) => {
        const { shiftKey, target, currentTarget } = e;
        const code = getEventCode(e);
        if (code === EVENT_CODE.tab && shiftKey) {
          onItemShiftTab();
          return;
        }
        if (target !== currentTarget)
          return;
        onKeydown(e);
      });
      const isCurrentTab = vue.computed(() => currentTabbedId.value === vue.unref(id));
      vue.provide(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, {
        rovingFocusGroupItemRef,
        tabIndex: vue.computed(() => vue.unref(isCurrentTab) ? 0 : -1),
        handleMousedown,
        handleFocus,
        handleKeydown
      });
      return {
        id,
        handleKeydown,
        handleFocus,
        handleMousedown
      };
    }
  });
  function _sfc_render$g(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_roving_focus_collection_item = vue.resolveComponent("el-roving-focus-collection-item");
    return vue.openBlock(), vue.createBlock(_component_el_roving_focus_collection_item, {
      id: _ctx.id,
      focusable: _ctx.focusable,
      active: _ctx.active
    }, {
      default: vue.withCtx(() => [
        vue.renderSlot(_ctx.$slots, "default")
      ]),
      _: 3
    }, 8, ["id", "focusable", "active"]);
  }
  var ElRovingFocusItem = /* @__PURE__ */ _export_sfc(_sfc_main$1e, [["render", _sfc_render$g], ["__file", "roving-focus-item.vue"]]);

  const dropdownProps = buildProps({
    trigger: {
      ...useTooltipTriggerProps.trigger,
      type: definePropType([
        String,
        Array
      ])
    },
    triggerKeys: {
      type: definePropType(Array),
      default: () => [
        EVENT_CODE.enter,
        EVENT_CODE.numpadEnter,
        EVENT_CODE.space,
        EVENT_CODE.down
      ]
    },
    virtualTriggering: useTooltipTriggerProps.virtualTriggering,
    virtualRef: useTooltipTriggerProps.virtualRef,
    effect: {
      ...useTooltipContentProps.effect,
      default: "light"
    },
    type: {
      type: definePropType(String)
    },
    placement: {
      type: definePropType(String),
      default: "bottom"
    },
    popperOptions: {
      type: definePropType(Object),
      default: () => ({})
    },
    id: String,
    size: {
      type: String,
      default: ""
    },
    splitButton: Boolean,
    hideOnClick: {
      type: Boolean,
      default: true
    },
    loop: {
      type: Boolean,
      default: true
    },
    showArrow: {
      type: Boolean,
      default: true
    },
    showTimeout: {
      type: Number,
      default: 150
    },
    hideTimeout: {
      type: Number,
      default: 150
    },
    tabindex: {
      type: definePropType([Number, String]),
      default: 0
    },
    maxHeight: {
      type: definePropType([Number, String]),
      default: ""
    },
    popperClass: useTooltipContentProps.popperClass,
    popperStyle: useTooltipContentProps.popperStyle,
    disabled: Boolean,
    role: {
      type: String,
      values: roleTypes,
      default: "menu"
    },
    buttonProps: {
      type: definePropType(Object)
    },
    teleported: useTooltipContentProps.teleported,
    persistent: {
      type: Boolean,
      default: true
    }
  });
  const dropdownItemProps = buildProps({
    command: {
      type: [Object, String, Number],
      default: () => ({})
    },
    disabled: Boolean,
    divided: Boolean,
    textValue: String,
    icon: {
      type: iconPropType
    }
  });
  const dropdownMenuProps = buildProps({
    onKeydown: { type: definePropType(Function) }
  });
  const FIRST_KEYS = [
    EVENT_CODE.down,
    EVENT_CODE.pageDown,
    EVENT_CODE.home
  ];
  const LAST_KEYS = [EVENT_CODE.up, EVENT_CODE.pageUp, EVENT_CODE.end];
  const FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];

  const DROPDOWN_INJECTION_KEY = Symbol("elDropdown");
  const DROPDOWN_INSTANCE_INJECTION_KEY = "elDropdown";

  const { ButtonGroup: ElButtonGroup } = ElButton;
  const _sfc_main$1d = vue.defineComponent({
    name: "ElDropdown",
    components: {
      ElButton,
      ElButtonGroup,
      ElScrollbar,
      ElTooltip,
      ElRovingFocusGroup,
      ElOnlyChild: OnlyChild,
      ElIcon,
      ArrowDown: arrow_down_default
    },
    props: dropdownProps,
    emits: ["visible-change", "click", "command"],
    setup(props, { emit }) {
      const _instance = vue.getCurrentInstance();
      const ns = useNamespace("dropdown");
      const { t } = useLocale();
      const triggeringElementRef = vue.ref();
      const referenceElementRef = vue.ref();
      const popperRef = vue.ref();
      const contentRef = vue.ref();
      const scrollbar = vue.ref(null);
      const currentTabId = vue.ref(null);
      const isUsingKeyboard = vue.ref(false);
      const wrapStyle = vue.computed(() => ({
        maxHeight: addUnit(props.maxHeight)
      }));
      const dropdownTriggerKls = vue.computed(() => [ns.m(dropdownSize.value)]);
      const trigger = vue.computed(() => castArray$1(props.trigger));
      const defaultTriggerId = useId().value;
      const triggerId = vue.computed(() => props.id || defaultTriggerId);
      function handleClick() {
        var _a;
        (_a = popperRef.value) == null ? void 0 : _a.onClose(void 0, 0);
      }
      function handleClose() {
        var _a;
        (_a = popperRef.value) == null ? void 0 : _a.onClose();
      }
      function handleOpen() {
        var _a;
        (_a = popperRef.value) == null ? void 0 : _a.onOpen();
      }
      const dropdownSize = useFormSize();
      function commandHandler(...args) {
        emit("command", ...args);
      }
      function onItemEnter() {
      }
      function onItemLeave() {
        const contentEl = vue.unref(contentRef);
        trigger.value.includes("hover") && (contentEl == null ? void 0 : contentEl.focus({
          preventScroll: true
        }));
        currentTabId.value = null;
      }
      function handleCurrentTabIdChange(id) {
        currentTabId.value = id;
      }
      function handleBeforeShowTooltip() {
        emit("visible-change", true);
      }
      function handleShowTooltip(event) {
        var _a;
        isUsingKeyboard.value = (event == null ? void 0 : event.type) === "keydown";
        (_a = contentRef.value) == null ? void 0 : _a.focus();
      }
      function handleBeforeHideTooltip() {
        emit("visible-change", false);
      }
      vue.provide(DROPDOWN_INJECTION_KEY, {
        contentRef,
        role: vue.computed(() => props.role),
        triggerId,
        isUsingKeyboard,
        onItemEnter,
        onItemLeave,
        handleClose
      });
      vue.provide(DROPDOWN_INSTANCE_INJECTION_KEY, {
        instance: _instance,
        dropdownSize,
        handleClick,
        commandHandler,
        trigger: vue.toRef(props, "trigger"),
        hideOnClick: vue.toRef(props, "hideOnClick")
      });
      const handlerMainButtonClick = (event) => {
        emit("click", event);
      };
      return {
        t,
        ns,
        scrollbar,
        wrapStyle,
        dropdownTriggerKls,
        dropdownSize,
        triggerId,
        currentTabId,
        handleCurrentTabIdChange,
        handlerMainButtonClick,
        handleClose,
        handleOpen,
        handleBeforeShowTooltip,
        handleShowTooltip,
        handleBeforeHideTooltip,
        popperRef,
        contentRef,
        triggeringElementRef,
        referenceElementRef
      };
    }
  });
  function _sfc_render$f(_ctx, _cache, $props, $setup, $data, $options) {
    var _a;
    const _component_el_roving_focus_group = vue.resolveComponent("el-roving-focus-group");
    const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
    const _component_el_only_child = vue.resolveComponent("el-only-child");
    const _component_el_tooltip = vue.resolveComponent("el-tooltip");
    const _component_el_button = vue.resolveComponent("el-button");
    const _component_arrow_down = vue.resolveComponent("arrow-down");
    const _component_el_icon = vue.resolveComponent("el-icon");
    const _component_el_button_group = vue.resolveComponent("el-button-group");
    return vue.openBlock(), vue.createElementBlock("div", {
      class: vue.normalizeClass([_ctx.ns.b(), _ctx.ns.is("disabled", _ctx.disabled)])
    }, [
      vue.createVNode(_component_el_tooltip, {
        ref: "popperRef",
        role: _ctx.role,
        effect: _ctx.effect,
        "fallback-placements": ["bottom", "top"],
        "popper-options": _ctx.popperOptions,
        "gpu-acceleration": false,
        placement: _ctx.placement,
        "popper-class": [_ctx.ns.e("popper"), _ctx.popperClass],
        "popper-style": _ctx.popperStyle,
        trigger: _ctx.trigger,
        "trigger-keys": _ctx.triggerKeys,
        "trigger-target-el": _ctx.contentRef,
        "show-arrow": _ctx.showArrow,
        "show-after": _ctx.trigger === "hover" ? _ctx.showTimeout : 0,
        "hide-after": _ctx.trigger === "hover" ? _ctx.hideTimeout : 0,
        "virtual-ref": (_a = _ctx.virtualRef) != null ? _a : _ctx.triggeringElementRef,
        "virtual-triggering": _ctx.virtualTriggering || _ctx.splitButton,
        disabled: _ctx.disabled,
        transition: `${_ctx.ns.namespace.value}-zoom-in-top`,
        teleported: _ctx.teleported,
        pure: "",
        "focus-on-target": "",
        persistent: _ctx.persistent,
        onBeforeShow: _ctx.handleBeforeShowTooltip,
        onShow: _ctx.handleShowTooltip,
        onBeforeHide: _ctx.handleBeforeHideTooltip
      }, vue.createSlots({
        content: vue.withCtx(() => [
          vue.createVNode(_component_el_scrollbar, {
            ref: "scrollbar",
            "wrap-style": _ctx.wrapStyle,
            tag: "div",
            "view-class": _ctx.ns.e("list")
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(_component_el_roving_focus_group, {
                loop: _ctx.loop,
                "current-tab-id": _ctx.currentTabId,
                orientation: "horizontal",
                onCurrentTabIdChange: _ctx.handleCurrentTabIdChange
              }, {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "dropdown")
                ]),
                _: 3
              }, 8, ["loop", "current-tab-id", "onCurrentTabIdChange"])
            ]),
            _: 3
          }, 8, ["wrap-style", "view-class"])
        ]),
        _: 2
      }, [
        !_ctx.splitButton ? {
          name: "default",
          fn: vue.withCtx(() => [
            vue.createVNode(_component_el_only_child, {
              id: _ctx.triggerId,
              ref: "triggeringElementRef",
              role: "button",
              tabindex: _ctx.tabindex
            }, {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 8, ["id", "tabindex"])
          ])
        } : void 0
      ]), 1032, ["role", "effect", "popper-options", "placement", "popper-class", "popper-style", "trigger", "trigger-keys", "trigger-target-el", "show-arrow", "show-after", "hide-after", "virtual-ref", "virtual-triggering", "disabled", "transition", "teleported", "persistent", "onBeforeShow", "onShow", "onBeforeHide"]),
      _ctx.splitButton ? (vue.openBlock(), vue.createBlock(_component_el_button_group, { key: 0 }, {
        default: vue.withCtx(() => [
          vue.createVNode(_component_el_button, vue.mergeProps({ ref: "referenceElementRef" }, _ctx.buttonProps, {
            size: _ctx.dropdownSize,
            type: _ctx.type,
            disabled: _ctx.disabled,
            tabindex: _ctx.tabindex,
            onClick: _ctx.handlerMainButtonClick
          }), {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 16, ["size", "type", "disabled", "tabindex", "onClick"]),
          vue.createVNode(_component_el_button, vue.mergeProps({
            id: _ctx.triggerId,
            ref: "triggeringElementRef"
          }, _ctx.buttonProps, {
            role: "button",
            size: _ctx.dropdownSize,
            type: _ctx.type,
            class: _ctx.ns.e("caret-button"),
            disabled: _ctx.disabled,
            tabindex: _ctx.tabindex,
            "aria-label": _ctx.t("el.dropdown.toggleDropdown")
          }), {
            default: vue.withCtx(() => [
              vue.createVNode(_component_el_icon, {
                class: vue.normalizeClass(_ctx.ns.e("icon"))
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(_component_arrow_down)
                ]),
                _: 1
              }, 8, ["class"])
            ]),
            _: 1
          }, 16, ["id", "size", "type", "class", "disabled", "tabindex", "aria-label"])
        ]),
        _: 3
      })) : vue.createCommentVNode("v-if", true)
    ], 2);
  }
  var Dropdown = /* @__PURE__ */ _export_sfc(_sfc_main$1d, [["render", _sfc_render$f], ["__file", "dropdown.vue"]]);

  const _sfc_main$1c = vue.defineComponent({
    name: "DropdownItemImpl",
    components: {
      ElIcon
    },
    props: dropdownItemProps,
    emits: ["pointermove", "pointerleave", "click", "clickimpl"],
    setup(_, { emit }) {
      const ns = useNamespace("dropdown");
      const { role: menuRole } = vue.inject(DROPDOWN_INJECTION_KEY, void 0);
      const { collectionItemRef: rovingFocusCollectionItemRef } = vue.inject(COLLECTION_ITEM_INJECTION_KEY, void 0);
      const {
        rovingFocusGroupItemRef,
        tabIndex,
        handleFocus,
        handleKeydown: handleItemKeydown,
        handleMousedown
      } = vue.inject(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, void 0);
      const itemRef = composeRefs(rovingFocusCollectionItemRef, rovingFocusGroupItemRef);
      const role = vue.computed(() => {
        if (menuRole.value === "menu") {
          return "menuitem";
        } else if (menuRole.value === "navigation") {
          return "link";
        }
        return "button";
      });
      const handleKeydown = composeEventHandlers((e) => {
        const code = getEventCode(e);
        if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space].includes(code)) {
          e.preventDefault();
          e.stopImmediatePropagation();
          emit("clickimpl", e);
          return true;
        }
      }, handleItemKeydown);
      return {
        ns,
        itemRef,
        dataset: {
          [COLLECTION_ITEM_SIGN]: ""
        },
        role,
        tabIndex,
        handleFocus,
        handleKeydown,
        handleMousedown
      };
    }
  });
  function _sfc_render$e(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_icon = vue.resolveComponent("el-icon");
    return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
      _ctx.divided ? (vue.openBlock(), vue.createElementBlock("li", {
        key: 0,
        role: "separator",
        class: vue.normalizeClass(_ctx.ns.bem("menu", "item", "divided"))
      }, null, 2)) : vue.createCommentVNode("v-if", true),
      vue.createElementVNode("li", vue.mergeProps({ ref: _ctx.itemRef }, { ..._ctx.dataset, ..._ctx.$attrs }, {
        "aria-disabled": _ctx.disabled,
        class: [_ctx.ns.be("menu", "item"), _ctx.ns.is("disabled", _ctx.disabled)],
        tabindex: _ctx.tabIndex,
        role: _ctx.role,
        onClick: (e) => _ctx.$emit("clickimpl", e),
        onFocus: _ctx.handleFocus,
        onKeydown: vue.withModifiers(_ctx.handleKeydown, ["self"]),
        onMousedown: _ctx.handleMousedown,
        onPointermove: (e) => _ctx.$emit("pointermove", e),
        onPointerleave: (e) => _ctx.$emit("pointerleave", e)
      }), [
        _ctx.icon ? (vue.openBlock(), vue.createBlock(_component_el_icon, { key: 0 }, {
          default: vue.withCtx(() => [
            (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
          ]),
          _: 1
        })) : vue.createCommentVNode("v-if", true),
        vue.renderSlot(_ctx.$slots, "default")
      ], 16, ["aria-disabled", "tabindex", "role", "onClick", "onFocus", "onKeydown", "onMousedown", "onPointermove", "onPointerleave"])
    ], 64);
  }
  var ElDropdownItemImpl = /* @__PURE__ */ _export_sfc(_sfc_main$1c, [["render", _sfc_render$e], ["__file", "dropdown-item-impl.vue"]]);

  const useDropdown = () => {
    const elDropdown = vue.inject(DROPDOWN_INSTANCE_INJECTION_KEY, {});
    const _elDropdownSize = vue.computed(() => elDropdown == null ? void 0 : elDropdown.dropdownSize);
    return {
      elDropdown,
      _elDropdownSize
    };
  };

  const _sfc_main$1b = vue.defineComponent({
    name: "ElDropdownItem",
    components: {
      ElRovingFocusItem,
      ElDropdownItemImpl
    },
    inheritAttrs: false,
    props: dropdownItemProps,
    emits: ["pointermove", "pointerleave", "click"],
    setup(props, { emit, attrs }) {
      const { elDropdown } = useDropdown();
      const _instance = vue.getCurrentInstance();
      const { onItemEnter, onItemLeave } = vue.inject(DROPDOWN_INJECTION_KEY, void 0);
      const handlePointerMove = composeEventHandlers((e) => {
        emit("pointermove", e);
        return e.defaultPrevented;
      }, whenMouse((e) => {
        if (props.disabled) {
          onItemLeave(e);
          return;
        }
        const target = e.currentTarget;
        if (target === document.activeElement || target.contains(document.activeElement)) {
          return;
        }
        onItemEnter(e);
        if (!e.defaultPrevented) {
          target == null ? void 0 : target.focus({
            preventScroll: true
          });
        }
      }));
      const handlePointerLeave = composeEventHandlers((e) => {
        emit("pointerleave", e);
        return e.defaultPrevented;
      }, whenMouse(onItemLeave));
      const handleClick = composeEventHandlers((e) => {
        if (props.disabled) {
          return;
        }
        emit("click", e);
        return e.type !== "keydown" && e.defaultPrevented;
      }, (e) => {
        var _a, _b, _c;
        if (props.disabled) {
          e.stopImmediatePropagation();
          return;
        }
        if ((_a = elDropdown == null ? void 0 : elDropdown.hideOnClick) == null ? void 0 : _a.value) {
          (_b = elDropdown.handleClick) == null ? void 0 : _b.call(elDropdown);
        }
        (_c = elDropdown.commandHandler) == null ? void 0 : _c.call(elDropdown, props.command, _instance, e);
      });
      const propsAndAttrs = vue.computed(() => ({ ...props, ...attrs }));
      return {
        handleClick,
        handlePointerMove,
        handlePointerLeave,
        propsAndAttrs
      };
    }
  });
  function _sfc_render$d(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_dropdown_item_impl = vue.resolveComponent("el-dropdown-item-impl");
    const _component_el_roving_focus_item = vue.resolveComponent("el-roving-focus-item");
    return vue.openBlock(), vue.createBlock(_component_el_roving_focus_item, {
      focusable: !_ctx.disabled
    }, {
      default: vue.withCtx(() => [
        vue.createVNode(_component_el_dropdown_item_impl, vue.mergeProps(_ctx.propsAndAttrs, {
          onPointerleave: _ctx.handlePointerLeave,
          onPointermove: _ctx.handlePointerMove,
          onClickimpl: _ctx.handleClick
        }), {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 16, ["onPointerleave", "onPointermove", "onClickimpl"])
      ]),
      _: 3
    }, 8, ["focusable"]);
  }
  var DropdownItem = /* @__PURE__ */ _export_sfc(_sfc_main$1b, [["render", _sfc_render$d], ["__file", "dropdown-item.vue"]]);

  const _sfc_main$1a = vue.defineComponent({
    name: "ElDropdownMenu",
    props: dropdownMenuProps,
    setup(props) {
      const ns = useNamespace("dropdown");
      const { _elDropdownSize } = useDropdown();
      const size = _elDropdownSize.value;
      const { contentRef, role, triggerId, isUsingKeyboard, handleClose } = vue.inject(DROPDOWN_INJECTION_KEY, void 0);
      const {
        rovingFocusGroupRef,
        rovingFocusGroupRootStyle,
        onBlur,
        onFocus,
        onKeydown,
        onMousedown
      } = vue.inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
      const { collectionRef: rovingFocusGroupCollectionRef } = vue.inject(COLLECTION_INJECTION_KEY, void 0);
      const dropdownKls = vue.computed(() => {
        return [ns.b("menu"), ns.bm("menu", size == null ? void 0 : size.value)];
      });
      const dropdownListWrapperRef = composeRefs(contentRef, rovingFocusGroupRef, rovingFocusGroupCollectionRef);
      const handleKeydown = composeEventHandlers((e) => {
        var _a;
        (_a = props.onKeydown) == null ? void 0 : _a.call(props, e);
      }, (e) => {
        const { currentTarget, target } = e;
        const code = getEventCode(e);
        currentTarget.contains(target);
        if (EVENT_CODE.tab === code) {
          return handleClose();
        }
        onKeydown(e);
      });
      function handleFocus(e) {
        isUsingKeyboard.value && onFocus(e);
      }
      return {
        size,
        rovingFocusGroupRootStyle,
        dropdownKls,
        role,
        triggerId,
        dropdownListWrapperRef,
        handleKeydown,
        onBlur,
        handleFocus,
        onMousedown
      };
    }
  });
  function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("ul", {
      ref: _ctx.dropdownListWrapperRef,
      class: vue.normalizeClass(_ctx.dropdownKls),
      style: vue.normalizeStyle(_ctx.rovingFocusGroupRootStyle),
      tabindex: -1,
      role: _ctx.role,
      "aria-labelledby": _ctx.triggerId,
      onFocusin: _ctx.handleFocus,
      onFocusout: _ctx.onBlur,
      onKeydown: vue.withModifiers(_ctx.handleKeydown, ["self"]),
      onMousedown: vue.withModifiers(_ctx.onMousedown, ["self"])
    }, [
      vue.renderSlot(_ctx.$slots, "default")
    ], 46, ["role", "aria-labelledby", "onFocusin", "onFocusout", "onKeydown", "onMousedown"]);
  }
  var DropdownMenu = /* @__PURE__ */ _export_sfc(_sfc_main$1a, [["render", _sfc_render$c], ["__file", "dropdown-menu.vue"]]);

  const ElDropdown = withInstall(Dropdown, {
    DropdownItem,
    DropdownMenu
  });
  const ElDropdownItem = withNoopInstall(DropdownItem);
  const ElDropdownMenu = withNoopInstall(DropdownMenu);

  const __default__$X = vue.defineComponent({
    name: "ImgEmpty"
  });
  const _sfc_main$19 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$X,
    setup(__props) {
      const ns = useNamespace("empty");
      const id = useId();
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("svg", {
          viewBox: "0 0 79 86",
          version: "1.1",
          xmlns: "http://www.w3.org/2000/svg",
          "xmlns:xlink": "http://www.w3.org/1999/xlink"
        }, [
          vue.createElementVNode("defs", null, [
            vue.createElementVNode("linearGradient", {
              id: `linearGradient-1-${vue.unref(id)}`,
              x1: "38.8503086%",
              y1: "0%",
              x2: "61.1496914%",
              y2: "100%"
            }, [
              vue.createElementVNode("stop", {
                "stop-color": `var(${vue.unref(ns).cssVarBlockName("fill-color-1")})`,
                offset: "0%"
              }, null, 8, ["stop-color"]),
              vue.createElementVNode("stop", {
                "stop-color": `var(${vue.unref(ns).cssVarBlockName("fill-color-4")})`,
                offset: "100%"
              }, null, 8, ["stop-color"])
            ], 8, ["id"]),
            vue.createElementVNode("linearGradient", {
              id: `linearGradient-2-${vue.unref(id)}`,
              x1: "0%",
              y1: "9.5%",
              x2: "100%",
              y2: "90.5%"
            }, [
              vue.createElementVNode("stop", {
                "stop-color": `var(${vue.unref(ns).cssVarBlockName("fill-color-1")})`,
                offset: "0%"
              }, null, 8, ["stop-color"]),
              vue.createElementVNode("stop", {
                "stop-color": `var(${vue.unref(ns).cssVarBlockName("fill-color-6")})`,
                offset: "100%"
              }, null, 8, ["stop-color"])
            ], 8, ["id"]),
            vue.createElementVNode("rect", {
              id: `path-3-${vue.unref(id)}`,
              x: "0",
              y: "0",
              width: "17",
              height: "36"
            }, null, 8, ["id"])
          ]),
          vue.createElementVNode("g", {
            stroke: "none",
            "stroke-width": "1",
            fill: "none",
            "fill-rule": "evenodd"
          }, [
            vue.createElementVNode("g", { transform: "translate(-1268.000000, -535.000000)" }, [
              vue.createElementVNode("g", { transform: "translate(1268.000000, 535.000000)" }, [
                vue.createElementVNode("path", {
                  d: "M39.5,86 C61.3152476,86 79,83.9106622 79,81.3333333 C79,78.7560045 57.3152476,78 35.5,78 C13.6847524,78 0,78.7560045 0,81.3333333 C0,83.9106622 17.6847524,86 39.5,86 Z",
                  fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-3")})`
                }, null, 8, ["fill"]),
                vue.createElementVNode("polygon", {
                  fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-7")})`,
                  transform: "translate(27.500000, 51.500000) scale(1, -1) translate(-27.500000, -51.500000) ",
                  points: "13 58 53 58 42 45 2 45"
                }, null, 8, ["fill"]),
                vue.createElementVNode("g", { transform: "translate(34.500000, 31.500000) scale(-1, 1) rotate(-25.000000) translate(-34.500000, -31.500000) translate(7.000000, 10.000000)" }, [
                  vue.createElementVNode("polygon", {
                    fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-7")})`,
                    transform: "translate(11.500000, 5.000000) scale(1, -1) translate(-11.500000, -5.000000) ",
                    points: "2.84078316e-14 3 18 3 23 7 5 7"
                  }, null, 8, ["fill"]),
                  vue.createElementVNode("polygon", {
                    fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-5")})`,
                    points: "-3.69149156e-15 7 38 7 38 43 -3.69149156e-15 43"
                  }, null, 8, ["fill"]),
                  vue.createElementVNode("rect", {
                    fill: `url(#linearGradient-1-${vue.unref(id)})`,
                    transform: "translate(46.500000, 25.000000) scale(-1, 1) translate(-46.500000, -25.000000) ",
                    x: "38",
                    y: "7",
                    width: "17",
                    height: "36"
                  }, null, 8, ["fill"]),
                  vue.createElementVNode("polygon", {
                    fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-2")})`,
                    transform: "translate(39.500000, 3.500000) scale(-1, 1) translate(-39.500000, -3.500000) ",
                    points: "24 7 41 7 55 -3.63806207e-12 38 -3.63806207e-12"
                  }, null, 8, ["fill"])
                ]),
                vue.createElementVNode("rect", {
                  fill: `url(#linearGradient-2-${vue.unref(id)})`,
                  x: "13",
                  y: "45",
                  width: "40",
                  height: "36"
                }, null, 8, ["fill"]),
                vue.createElementVNode("g", { transform: "translate(53.000000, 45.000000)" }, [
                  vue.createElementVNode("use", {
                    fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-8")})`,
                    transform: "translate(8.500000, 18.000000) scale(-1, 1) translate(-8.500000, -18.000000) ",
                    "xlink:href": `#path-3-${vue.unref(id)}`
                  }, null, 8, ["fill", "xlink:href"]),
                  vue.createElementVNode("polygon", {
                    fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-9")})`,
                    mask: `url(#mask-4-${vue.unref(id)})`,
                    transform: "translate(12.000000, 9.000000) scale(-1, 1) translate(-12.000000, -9.000000) ",
                    points: "7 0 24 0 20 18 7 16.5"
                  }, null, 8, ["fill", "mask"])
                ]),
                vue.createElementVNode("polygon", {
                  fill: `var(${vue.unref(ns).cssVarBlockName("fill-color-2")})`,
                  transform: "translate(66.000000, 51.500000) scale(-1, 1) translate(-66.000000, -51.500000) ",
                  points: "62 45 79 45 70 58 53 58"
                }, null, 8, ["fill"])
              ])
            ])
          ])
        ]);
      };
    }
  });
  var ImgEmpty = /* @__PURE__ */ _export_sfc(_sfc_main$19, [["__file", "img-empty.vue"]]);

  const emptyProps = buildProps({
    image: {
      type: String,
      default: ""
    },
    imageSize: Number,
    description: {
      type: String,
      default: ""
    }
  });

  const __default__$W = vue.defineComponent({
    name: "ElEmpty"
  });
  const _sfc_main$18 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$W,
    props: emptyProps,
    setup(__props) {
      const props = __props;
      const { t } = useLocale();
      const ns = useNamespace("empty");
      const emptyDescription = vue.computed(() => props.description || t("el.table.emptyText"));
      const imageStyle = vue.computed(() => ({
        width: addUnit(props.imageSize)
      }));
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("image")),
            style: vue.normalizeStyle(vue.unref(imageStyle))
          }, [
            _ctx.image ? (vue.openBlock(), vue.createElementBlock("img", {
              key: 0,
              src: _ctx.image,
              ondragstart: "return false"
            }, null, 8, ["src"])) : vue.renderSlot(_ctx.$slots, "image", { key: 1 }, () => [
              vue.createVNode(ImgEmpty)
            ])
          ], 6),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("description"))
          }, [
            _ctx.$slots.description ? vue.renderSlot(_ctx.$slots, "description", { key: 0 }) : (vue.openBlock(), vue.createElementBlock("p", { key: 1 }, vue.toDisplayString(vue.unref(emptyDescription)), 1))
          ], 2),
          _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("bottom"))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var Empty = /* @__PURE__ */ _export_sfc(_sfc_main$18, [["__file", "empty.vue"]]);

  const ElEmpty = withInstall(Empty);

  const imageViewerProps = buildProps({
    urlList: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    zIndex: {
      type: Number
    },
    initialIndex: {
      type: Number,
      default: 0
    },
    infinite: {
      type: Boolean,
      default: true
    },
    hideOnClickModal: Boolean,
    teleported: Boolean,
    closeOnPressEscape: {
      type: Boolean,
      default: true
    },
    zoomRate: {
      type: Number,
      default: 1.2
    },
    scale: {
      type: Number,
      default: 1
    },
    minScale: {
      type: Number,
      default: 0.2
    },
    maxScale: {
      type: Number,
      default: 7
    },
    showProgress: Boolean,
    crossorigin: {
      type: definePropType(String)
    }
  });
  const imageViewerEmits = {
    close: () => true,
    error: (evt) => evt instanceof Event,
    switch: (index) => isNumber(index),
    rotate: (deg) => isNumber(deg)
  };

  const __default__$V = vue.defineComponent({
    name: "ElImageViewer"
  });
  const _sfc_main$17 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$V,
    props: imageViewerProps,
    emits: imageViewerEmits,
    setup(__props, { expose, emit }) {
      var _a;
      const props = __props;
      const modes = {
        CONTAIN: {
          name: "contain",
          icon: vue.markRaw(full_screen_default)
        },
        ORIGINAL: {
          name: "original",
          icon: vue.markRaw(scale_to_original_default)
        }
      };
      let stopWheelListener;
      let prevOverflow = "";
      const { t } = useLocale();
      const ns = useNamespace("image-viewer");
      const { nextZIndex } = useZIndex();
      const wrapper = vue.ref();
      const imgRef = vue.ref();
      const scopeEventListener = vue.effectScope();
      const scaleClamped = vue.computed(() => {
        const { scale, minScale, maxScale } = props;
        return clamp$2(scale, minScale, maxScale);
      });
      const loading = vue.ref(true);
      const loadError = vue.ref(false);
      const activeIndex = vue.ref(props.initialIndex);
      const mode = vue.shallowRef(modes.CONTAIN);
      const transform = vue.ref({
        scale: scaleClamped.value,
        deg: 0,
        offsetX: 0,
        offsetY: 0,
        enableTransition: false
      });
      const zIndex = vue.ref((_a = props.zIndex) != null ? _a : nextZIndex());
      const isSingle = vue.computed(() => {
        const { urlList } = props;
        return urlList.length <= 1;
      });
      const isFirst = vue.computed(() => activeIndex.value === 0);
      const isLast = vue.computed(() => activeIndex.value === props.urlList.length - 1);
      const currentImg = vue.computed(() => props.urlList[activeIndex.value]);
      const arrowPrevKls = vue.computed(() => [
        ns.e("btn"),
        ns.e("prev"),
        ns.is("disabled", !props.infinite && isFirst.value)
      ]);
      const arrowNextKls = vue.computed(() => [
        ns.e("btn"),
        ns.e("next"),
        ns.is("disabled", !props.infinite && isLast.value)
      ]);
      const imgStyle = vue.computed(() => {
        const { scale, deg, offsetX, offsetY, enableTransition } = transform.value;
        let translateX = offsetX / scale;
        let translateY = offsetY / scale;
        const radian = deg * Math.PI / 180;
        const cosRadian = Math.cos(radian);
        const sinRadian = Math.sin(radian);
        translateX = translateX * cosRadian + translateY * sinRadian;
        translateY = translateY * cosRadian - offsetX / scale * sinRadian;
        const style = {
          transform: `scale(${scale}) rotate(${deg}deg) translate(${translateX}px, ${translateY}px)`,
          transition: enableTransition ? "transform .3s" : ""
        };
        if (mode.value.name === modes.CONTAIN.name) {
          style.maxWidth = style.maxHeight = "100%";
        }
        return style;
      });
      const progress = vue.computed(() => `${activeIndex.value + 1} / ${props.urlList.length}`);
      function hide() {
        unregisterEventListener();
        stopWheelListener == null ? void 0 : stopWheelListener();
        document.body.style.overflow = prevOverflow;
        emit("close");
      }
      function registerEventListener() {
        const keydownHandler = throttle((e) => {
          const code = getEventCode(e);
          switch (code) {
            case EVENT_CODE.esc:
              props.closeOnPressEscape && hide();
              break;
            case EVENT_CODE.space:
              toggleMode();
              break;
            case EVENT_CODE.left:
              prev();
              break;
            case EVENT_CODE.up:
              handleActions("zoomIn");
              break;
            case EVENT_CODE.right:
              next();
              break;
            case EVENT_CODE.down:
              handleActions("zoomOut");
              break;
          }
        });
        const mousewheelHandler = throttle((e) => {
          const delta = e.deltaY || e.deltaX;
          handleActions(delta < 0 ? "zoomIn" : "zoomOut", {
            zoomRate: props.zoomRate,
            enableTransition: false
          });
        });
        scopeEventListener.run(() => {
          useEventListener(document, "keydown", keydownHandler);
          useEventListener(document, "wheel", mousewheelHandler);
        });
      }
      function unregisterEventListener() {
        scopeEventListener.stop();
      }
      function handleImgLoad() {
        loading.value = false;
      }
      function handleImgError(e) {
        loadError.value = true;
        loading.value = false;
        emit("error", e);
        e.target.alt = t("el.image.error");
      }
      function handleMouseDown(e) {
        if (loading.value || e.button !== 0 || !wrapper.value)
          return;
        transform.value.enableTransition = false;
        const { offsetX, offsetY } = transform.value;
        const startX = e.pageX;
        const startY = e.pageY;
        const dragHandler = throttle((ev) => {
          transform.value = {
            ...transform.value,
            offsetX: offsetX + ev.pageX - startX,
            offsetY: offsetY + ev.pageY - startY
          };
        });
        const removeMousemove = useEventListener(document, "mousemove", dragHandler);
        useEventListener(document, "mouseup", () => {
          removeMousemove();
        });
        e.preventDefault();
      }
      function reset() {
        transform.value = {
          scale: scaleClamped.value,
          deg: 0,
          offsetX: 0,
          offsetY: 0,
          enableTransition: false
        };
      }
      function toggleMode() {
        if (loading.value || loadError.value)
          return;
        const modeNames = keysOf(modes);
        const modeValues = Object.values(modes);
        const currentMode = mode.value.name;
        const index = modeValues.findIndex((i) => i.name === currentMode);
        const nextIndex = (index + 1) % modeNames.length;
        mode.value = modes[modeNames[nextIndex]];
        reset();
      }
      function setActiveItem(index) {
        loadError.value = false;
        const len = props.urlList.length;
        activeIndex.value = (index + len) % len;
      }
      function prev() {
        if (isFirst.value && !props.infinite)
          return;
        setActiveItem(activeIndex.value - 1);
      }
      function next() {
        if (isLast.value && !props.infinite)
          return;
        setActiveItem(activeIndex.value + 1);
      }
      function handleActions(action, options = {}) {
        if (loading.value || loadError.value)
          return;
        const { minScale, maxScale } = props;
        const { zoomRate, rotateDeg, enableTransition } = {
          zoomRate: props.zoomRate,
          rotateDeg: 90,
          enableTransition: true,
          ...options
        };
        switch (action) {
          case "zoomOut":
            if (transform.value.scale > minScale) {
              transform.value.scale = Number.parseFloat((transform.value.scale / zoomRate).toFixed(3));
            }
            break;
          case "zoomIn":
            if (transform.value.scale < maxScale) {
              transform.value.scale = Number.parseFloat((transform.value.scale * zoomRate).toFixed(3));
            }
            break;
          case "clockwise":
            transform.value.deg += rotateDeg;
            emit("rotate", transform.value.deg);
            break;
          case "anticlockwise":
            transform.value.deg -= rotateDeg;
            emit("rotate", transform.value.deg);
            break;
        }
        transform.value.enableTransition = enableTransition;
      }
      function onFocusoutPrevented(event) {
        var _a2;
        if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) === "pointer") {
          event.preventDefault();
        }
      }
      function onCloseRequested() {
        if (props.closeOnPressEscape) {
          hide();
        }
      }
      function wheelHandler(e) {
        if (!e.ctrlKey)
          return;
        if (e.deltaY < 0) {
          e.preventDefault();
          return false;
        } else if (e.deltaY > 0) {
          e.preventDefault();
          return false;
        }
      }
      vue.watch(() => scaleClamped.value, (val) => {
        transform.value.scale = val;
      });
      vue.watch(currentImg, () => {
        vue.nextTick(() => {
          const $img = imgRef.value;
          if (!($img == null ? void 0 : $img.complete)) {
            loading.value = true;
          }
        });
      });
      vue.watch(activeIndex, (val) => {
        reset();
        emit("switch", val);
      });
      vue.onMounted(() => {
        registerEventListener();
        stopWheelListener = useEventListener("wheel", wheelHandler, {
          passive: false
        });
        prevOverflow = document.body.style.overflow;
        document.body.style.overflow = "hidden";
      });
      expose({
        setActiveItem
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTeleport$1), {
          to: "body",
          disabled: !_ctx.teleported
        }, {
          default: vue.withCtx(() => [
            vue.createVNode(vue.Transition, {
              name: "viewer-fade",
              appear: ""
            }, {
              default: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  ref_key: "wrapper",
                  ref: wrapper,
                  tabindex: -1,
                  class: vue.normalizeClass(vue.unref(ns).e("wrapper")),
                  style: vue.normalizeStyle({ zIndex: zIndex.value })
                }, [
                  vue.createVNode(vue.unref(ElFocusTrap), {
                    loop: "",
                    trapped: "",
                    "focus-trap-el": wrapper.value,
                    "focus-start-el": "container",
                    onFocusoutPrevented,
                    onReleaseRequested: onCloseRequested
                  }, {
                    default: vue.withCtx(() => [
                      vue.createElementVNode("div", {
                        class: vue.normalizeClass(vue.unref(ns).e("mask")),
                        onClick: vue.withModifiers(($event) => _ctx.hideOnClickModal && hide(), ["self"])
                      }, null, 10, ["onClick"]),
                      vue.createCommentVNode(" CLOSE "),
                      vue.createElementVNode("span", {
                        class: vue.normalizeClass([vue.unref(ns).e("btn"), vue.unref(ns).e("close")]),
                        onClick: hide
                      }, [
                        vue.createVNode(vue.unref(ElIcon), null, {
                          default: vue.withCtx(() => [
                            vue.createVNode(vue.unref(close_default))
                          ]),
                          _: 1
                        })
                      ], 2),
                      vue.createCommentVNode(" ARROW "),
                      !vue.unref(isSingle) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                        vue.createElementVNode("span", {
                          class: vue.normalizeClass(vue.unref(arrowPrevKls)),
                          onClick: prev
                        }, [
                          vue.createVNode(vue.unref(ElIcon), null, {
                            default: vue.withCtx(() => [
                              vue.createVNode(vue.unref(arrow_left_default))
                            ]),
                            _: 1
                          })
                        ], 2),
                        vue.createElementVNode("span", {
                          class: vue.normalizeClass(vue.unref(arrowNextKls)),
                          onClick: next
                        }, [
                          vue.createVNode(vue.unref(ElIcon), null, {
                            default: vue.withCtx(() => [
                              vue.createVNode(vue.unref(arrow_right_default))
                            ]),
                            _: 1
                          })
                        ], 2)
                      ], 64)) : vue.createCommentVNode("v-if", true),
                      _ctx.$slots.progress || _ctx.showProgress ? (vue.openBlock(), vue.createElementBlock("div", {
                        key: 1,
                        class: vue.normalizeClass([vue.unref(ns).e("btn"), vue.unref(ns).e("progress")])
                      }, [
                        vue.renderSlot(_ctx.$slots, "progress", {
                          activeIndex: activeIndex.value,
                          total: _ctx.urlList.length
                        }, () => [
                          vue.createTextVNode(vue.toDisplayString(vue.unref(progress)), 1)
                        ])
                      ], 2)) : vue.createCommentVNode("v-if", true),
                      vue.createCommentVNode(" ACTIONS "),
                      vue.createElementVNode("div", {
                        class: vue.normalizeClass([vue.unref(ns).e("btn"), vue.unref(ns).e("actions")])
                      }, [
                        vue.createElementVNode("div", {
                          class: vue.normalizeClass(vue.unref(ns).e("actions__inner"))
                        }, [
                          vue.renderSlot(_ctx.$slots, "toolbar", {
                            actions: handleActions,
                            prev,
                            next,
                            reset: toggleMode,
                            activeIndex: activeIndex.value,
                            setActiveItem
                          }, () => [
                            vue.createVNode(vue.unref(ElIcon), {
                              onClick: ($event) => handleActions("zoomOut")
                            }, {
                              default: vue.withCtx(() => [
                                vue.createVNode(vue.unref(zoom_out_default))
                              ]),
                              _: 1
                            }, 8, ["onClick"]),
                            vue.createVNode(vue.unref(ElIcon), {
                              onClick: ($event) => handleActions("zoomIn")
                            }, {
                              default: vue.withCtx(() => [
                                vue.createVNode(vue.unref(zoom_in_default))
                              ]),
                              _: 1
                            }, 8, ["onClick"]),
                            vue.createElementVNode("i", {
                              class: vue.normalizeClass(vue.unref(ns).e("actions__divider"))
                            }, null, 2),
                            vue.createVNode(vue.unref(ElIcon), { onClick: toggleMode }, {
                              default: vue.withCtx(() => [
                                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(mode).icon)))
                              ]),
                              _: 1
                            }),
                            vue.createElementVNode("i", {
                              class: vue.normalizeClass(vue.unref(ns).e("actions__divider"))
                            }, null, 2),
                            vue.createVNode(vue.unref(ElIcon), {
                              onClick: ($event) => handleActions("anticlockwise")
                            }, {
                              default: vue.withCtx(() => [
                                vue.createVNode(vue.unref(refresh_left_default))
                              ]),
                              _: 1
                            }, 8, ["onClick"]),
                            vue.createVNode(vue.unref(ElIcon), {
                              onClick: ($event) => handleActions("clockwise")
                            }, {
                              default: vue.withCtx(() => [
                                vue.createVNode(vue.unref(refresh_right_default))
                              ]),
                              _: 1
                            }, 8, ["onClick"])
                          ])
                        ], 2)
                      ], 2),
                      vue.createCommentVNode(" CANVAS "),
                      vue.createElementVNode("div", {
                        class: vue.normalizeClass(vue.unref(ns).e("canvas"))
                      }, [
                        loadError.value && _ctx.$slots["viewer-error"] ? vue.renderSlot(_ctx.$slots, "viewer-error", {
                          key: 0,
                          activeIndex: activeIndex.value,
                          src: vue.unref(currentImg)
                        }) : (vue.openBlock(), vue.createElementBlock("img", {
                          ref_key: "imgRef",
                          ref: imgRef,
                          key: vue.unref(currentImg),
                          src: vue.unref(currentImg),
                          style: vue.normalizeStyle(vue.unref(imgStyle)),
                          class: vue.normalizeClass(vue.unref(ns).e("img")),
                          crossorigin: _ctx.crossorigin,
                          onLoad: handleImgLoad,
                          onError: handleImgError,
                          onMousedown: handleMouseDown
                        }, null, 46, ["src", "crossorigin"]))
                      ], 2),
                      vue.renderSlot(_ctx.$slots, "default")
                    ]),
                    _: 3
                  }, 8, ["focus-trap-el"])
                ], 6)
              ]),
              _: 3
            })
          ]),
          _: 3
        }, 8, ["disabled"]);
      };
    }
  });
  var ImageViewer = /* @__PURE__ */ _export_sfc(_sfc_main$17, [["__file", "image-viewer.vue"]]);

  const ElImageViewer = withInstall(ImageViewer);

  const imageProps = buildProps({
    hideOnClickModal: Boolean,
    src: {
      type: String,
      default: ""
    },
    fit: {
      type: String,
      values: ["", "contain", "cover", "fill", "none", "scale-down"],
      default: ""
    },
    loading: {
      type: String,
      values: ["eager", "lazy"]
    },
    lazy: Boolean,
    scrollContainer: {
      type: definePropType([String, Object])
    },
    previewSrcList: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    previewTeleported: Boolean,
    zIndex: {
      type: Number
    },
    initialIndex: {
      type: Number,
      default: 0
    },
    infinite: {
      type: Boolean,
      default: true
    },
    closeOnPressEscape: {
      type: Boolean,
      default: true
    },
    zoomRate: {
      type: Number,
      default: 1.2
    },
    scale: {
      type: Number,
      default: 1
    },
    minScale: {
      type: Number,
      default: 0.2
    },
    maxScale: {
      type: Number,
      default: 7
    },
    showProgress: Boolean,
    crossorigin: {
      type: definePropType(String)
    }
  });
  const imageEmits = {
    load: (evt) => evt instanceof Event,
    error: (evt) => evt instanceof Event,
    switch: (val) => isNumber(val),
    close: () => true,
    show: () => true
  };

  const __default__$U = vue.defineComponent({
    name: "ElImage",
    inheritAttrs: false
  });
  const _sfc_main$16 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$U,
    props: imageProps,
    emits: imageEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const { t } = useLocale();
      const ns = useNamespace("image");
      const rawAttrs = vue.useAttrs();
      const containerAttrs = vue.computed(() => {
        return fromPairs(Object.entries(rawAttrs).filter(([key]) => /^(data-|on[A-Z])/i.test(key) || ["id", "style"].includes(key)));
      });
      const imgAttrs = useAttrs({
        excludeListeners: true,
        excludeKeys: vue.computed(() => {
          return Object.keys(containerAttrs.value);
        })
      });
      const imageSrc = vue.ref();
      const hasLoadError = vue.ref(false);
      const isLoading = vue.ref(true);
      const showViewer = vue.ref(false);
      const container = vue.ref();
      const _scrollContainer = vue.ref();
      const supportLoading = isClient && "loading" in HTMLImageElement.prototype;
      let stopScrollListener;
      const imageKls = vue.computed(() => [
        ns.e("inner"),
        preview.value && ns.e("preview"),
        isLoading.value && ns.is("loading")
      ]);
      const imageStyle = vue.computed(() => {
        const { fit } = props;
        if (isClient && fit) {
          return { objectFit: fit };
        }
        return {};
      });
      const preview = vue.computed(() => {
        const { previewSrcList } = props;
        return isArray$1(previewSrcList) && previewSrcList.length > 0;
      });
      const imageIndex = vue.computed(() => {
        const { previewSrcList, initialIndex } = props;
        let previewIndex = initialIndex;
        if (initialIndex > previewSrcList.length - 1) {
          previewIndex = 0;
        }
        return previewIndex;
      });
      const isManual = vue.computed(() => {
        if (props.loading === "eager")
          return false;
        return !supportLoading && props.loading === "lazy" || props.lazy;
      });
      const loadImage = () => {
        if (!isClient)
          return;
        isLoading.value = true;
        hasLoadError.value = false;
        imageSrc.value = props.src;
      };
      function handleLoad(event) {
        isLoading.value = false;
        hasLoadError.value = false;
        emit("load", event);
      }
      function handleError(event) {
        isLoading.value = false;
        hasLoadError.value = true;
        emit("error", event);
      }
      function handleLazyLoad(isIntersecting) {
        if (isIntersecting) {
          loadImage();
          removeLazyLoadListener();
        }
      }
      const lazyLoadHandler = useThrottleFn(handleLazyLoad, 200, true);
      async function addLazyLoadListener() {
        var _a;
        if (!isClient)
          return;
        await vue.nextTick();
        const { scrollContainer } = props;
        if (isElement$2(scrollContainer)) {
          _scrollContainer.value = scrollContainer;
        } else if (isString$1(scrollContainer) && scrollContainer !== "") {
          _scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
        } else if (container.value) {
          const scrollContainer2 = getScrollContainer(container.value);
          _scrollContainer.value = isWindow$1(scrollContainer2) ? void 0 : scrollContainer2;
        }
        const { stop } = useIntersectionObserver(container, ([entry]) => {
          lazyLoadHandler(entry.isIntersecting);
        }, { root: _scrollContainer });
        stopScrollListener = stop;
      }
      function removeLazyLoadListener() {
        if (!isClient || !lazyLoadHandler)
          return;
        stopScrollListener == null ? void 0 : stopScrollListener();
        _scrollContainer.value = void 0;
        stopScrollListener = void 0;
      }
      function clickHandler() {
        if (!preview.value)
          return;
        showViewer.value = true;
        emit("show");
      }
      function closeViewer() {
        showViewer.value = false;
        emit("close");
      }
      function switchViewer(val) {
        emit("switch", val);
      }
      vue.watch(() => props.src, () => {
        if (isManual.value) {
          isLoading.value = true;
          hasLoadError.value = false;
          removeLazyLoadListener();
          addLazyLoadListener();
        } else {
          loadImage();
        }
      });
      vue.onMounted(() => {
        if (isManual.value) {
          addLazyLoadListener();
        } else {
          loadImage();
        }
      });
      expose({
        showPreview: clickHandler
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
          ref_key: "container",
          ref: container
        }, vue.unref(containerAttrs), {
          class: [vue.unref(ns).b(), _ctx.$attrs.class]
        }), [
          hasLoadError.value ? vue.renderSlot(_ctx.$slots, "error", { key: 0 }, () => [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("error"))
            }, vue.toDisplayString(vue.unref(t)("el.image.error")), 3)
          ]) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
            imageSrc.value !== void 0 ? (vue.openBlock(), vue.createElementBlock("img", vue.mergeProps({ key: 0 }, vue.unref(imgAttrs), {
              src: imageSrc.value,
              loading: _ctx.loading,
              style: vue.unref(imageStyle),
              class: vue.unref(imageKls),
              crossorigin: _ctx.crossorigin,
              onClick: clickHandler,
              onLoad: handleLoad,
              onError: handleError
            }), null, 16, ["src", "loading", "crossorigin"])) : vue.createCommentVNode("v-if", true),
            isLoading.value ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("wrapper"))
            }, [
              vue.renderSlot(_ctx.$slots, "placeholder", {}, () => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("placeholder"))
                }, null, 2)
              ])
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 64)),
          vue.unref(preview) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
            showViewer.value ? (vue.openBlock(), vue.createBlock(vue.unref(ElImageViewer), {
              key: 0,
              "z-index": _ctx.zIndex,
              "initial-index": vue.unref(imageIndex),
              infinite: _ctx.infinite,
              "zoom-rate": _ctx.zoomRate,
              "min-scale": _ctx.minScale,
              "max-scale": _ctx.maxScale,
              "show-progress": _ctx.showProgress,
              "url-list": _ctx.previewSrcList,
              scale: _ctx.scale,
              crossorigin: _ctx.crossorigin,
              "hide-on-click-modal": _ctx.hideOnClickModal,
              teleported: _ctx.previewTeleported,
              "close-on-press-escape": _ctx.closeOnPressEscape,
              onClose: closeViewer,
              onSwitch: switchViewer
            }, vue.createSlots({
              toolbar: vue.withCtx((toolbar) => [
                vue.renderSlot(_ctx.$slots, "toolbar", vue.normalizeProps(vue.guardReactiveProps(toolbar)))
              ]),
              default: vue.withCtx(() => [
                _ctx.$slots.viewer ? (vue.openBlock(), vue.createElementBlock("div", { key: 0 }, [
                  vue.renderSlot(_ctx.$slots, "viewer")
                ])) : vue.createCommentVNode("v-if", true)
              ]),
              _: 2
            }, [
              _ctx.$slots.progress ? {
                name: "progress",
                fn: vue.withCtx((progress) => [
                  vue.renderSlot(_ctx.$slots, "progress", vue.normalizeProps(vue.guardReactiveProps(progress)))
                ])
              } : void 0,
              _ctx.$slots["viewer-error"] ? {
                name: "viewer-error",
                fn: vue.withCtx((viewerError) => [
                  vue.renderSlot(_ctx.$slots, "viewer-error", vue.normalizeProps(vue.guardReactiveProps(viewerError)))
                ])
              } : void 0
            ]), 1032, ["z-index", "initial-index", "infinite", "zoom-rate", "min-scale", "max-scale", "show-progress", "url-list", "scale", "crossorigin", "hide-on-click-modal", "teleported", "close-on-press-escape"])) : vue.createCommentVNode("v-if", true)
          ], 64)) : vue.createCommentVNode("v-if", true)
        ], 16);
      };
    }
  });
  var Image$1 = /* @__PURE__ */ _export_sfc(_sfc_main$16, [["__file", "image.vue"]]);

  const ElImage = withInstall(Image$1);

  const inputNumberProps = buildProps({
    id: {
      type: String,
      default: void 0
    },
    step: {
      type: Number,
      default: 1
    },
    stepStrictly: Boolean,
    max: {
      type: Number,
      default: Number.MAX_SAFE_INTEGER
    },
    min: {
      type: Number,
      default: Number.MIN_SAFE_INTEGER
    },
    modelValue: {
      type: [Number, null]
    },
    readonly: Boolean,
    disabled: Boolean,
    size: useSizeProp,
    controls: {
      type: Boolean,
      default: true
    },
    controlsPosition: {
      type: String,
      default: "",
      values: ["", "right"]
    },
    valueOnClear: {
      type: [String, Number, null],
      validator: (val) => val === null || isNumber(val) || ["min", "max"].includes(val),
      default: null
    },
    name: String,
    placeholder: String,
    precision: {
      type: Number,
      validator: (val) => val >= 0 && val === Number.parseInt(`${val}`, 10)
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    ...useAriaProps(["ariaLabel"]),
    inputmode: {
      type: definePropType(String),
      default: void 0
    },
    align: {
      type: definePropType(String),
      default: "center"
    },
    disabledScientific: Boolean
  });
  const inputNumberEmits = {
    [CHANGE_EVENT]: (cur, prev) => prev !== cur,
    blur: (e) => e instanceof FocusEvent,
    focus: (e) => e instanceof FocusEvent,
    [INPUT_EVENT]: (val) => isNumber(val) || isNil(val),
    [UPDATE_MODEL_EVENT]: (val) => isNumber(val) || isNil(val)
  };

  const __default__$T = vue.defineComponent({
    name: "ElInputNumber"
  });
  const _sfc_main$15 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$T,
    props: inputNumberProps,
    emits: inputNumberEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const { t } = useLocale();
      const ns = useNamespace("input-number");
      const input = vue.ref();
      const data = vue.reactive({
        currentValue: props.modelValue,
        userInput: null
      });
      const { formItem } = useFormItem();
      const minDisabled = vue.computed(() => isNumber(props.modelValue) && props.modelValue <= props.min);
      const maxDisabled = vue.computed(() => isNumber(props.modelValue) && props.modelValue >= props.max);
      const numPrecision = vue.computed(() => {
        const stepPrecision = getPrecision(props.step);
        if (!isUndefined(props.precision)) {
          if (stepPrecision > props.precision) {
            debugWarn("InputNumber", "precision should not be less than the decimal places of step");
          }
          return props.precision;
        } else {
          return Math.max(getPrecision(props.modelValue), stepPrecision);
        }
      });
      const controlsAtRight = vue.computed(() => {
        return props.controls && props.controlsPosition === "right";
      });
      const inputNumberSize = useFormSize();
      const inputNumberDisabled = useFormDisabled();
      const displayValue = vue.computed(() => {
        if (data.userInput !== null) {
          return data.userInput;
        }
        let currentValue = data.currentValue;
        if (isNil(currentValue))
          return "";
        if (isNumber(currentValue)) {
          if (Number.isNaN(currentValue))
            return "";
          if (!isUndefined(props.precision)) {
            currentValue = currentValue.toFixed(props.precision);
          }
        }
        return currentValue;
      });
      const toPrecision = (num, pre) => {
        if (isUndefined(pre))
          pre = numPrecision.value;
        if (pre === 0)
          return Math.round(num);
        let snum = String(num);
        const pointPos = snum.indexOf(".");
        if (pointPos === -1)
          return num;
        const nums = snum.replace(".", "").split("");
        const datum = nums[pointPos + pre];
        if (!datum)
          return num;
        const length = snum.length;
        if (snum.charAt(length - 1) === "5") {
          snum = `${snum.slice(0, Math.max(0, length - 1))}6`;
        }
        return Number.parseFloat(Number(snum).toFixed(pre));
      };
      const getPrecision = (value) => {
        if (isNil(value))
          return 0;
        const valueString = value.toString();
        const dotPosition = valueString.indexOf(".");
        let precision = 0;
        if (dotPosition !== -1) {
          precision = valueString.length - dotPosition - 1;
        }
        return precision;
      };
      const ensurePrecision = (val, coefficient = 1) => {
        if (!isNumber(val))
          return data.currentValue;
        if (val >= Number.MAX_SAFE_INTEGER && coefficient === 1) {
          debugWarn("InputNumber", "The value has reached the maximum safe integer limit.");
          return val;
        } else if (val <= Number.MIN_SAFE_INTEGER && coefficient === -1) {
          debugWarn("InputNumber", "The value has reached the minimum safe integer limit.");
          return val;
        }
        return toPrecision(val + props.step * coefficient);
      };
      const handleKeydown = (event) => {
        const code = getEventCode(event);
        const key = getEventKey(event);
        if (props.disabledScientific && ["e", "E"].includes(key)) {
          event.preventDefault();
          return;
        }
        switch (code) {
          case EVENT_CODE.up: {
            event.preventDefault();
            increase();
            break;
          }
          case EVENT_CODE.down: {
            event.preventDefault();
            decrease();
            break;
          }
        }
      };
      const increase = () => {
        if (props.readonly || inputNumberDisabled.value || maxDisabled.value)
          return;
        const value = Number(displayValue.value) || 0;
        const newVal = ensurePrecision(value);
        setCurrentValue(newVal);
        emit(INPUT_EVENT, data.currentValue);
        setCurrentValueToModelValue();
      };
      const decrease = () => {
        if (props.readonly || inputNumberDisabled.value || minDisabled.value)
          return;
        const value = Number(displayValue.value) || 0;
        const newVal = ensurePrecision(value, -1);
        setCurrentValue(newVal);
        emit(INPUT_EVENT, data.currentValue);
        setCurrentValueToModelValue();
      };
      const verifyValue = (value, update) => {
        const { max, min, step, precision, stepStrictly, valueOnClear } = props;
        if (max < min) {
          throwError("InputNumber", "min should not be greater than max.");
        }
        let newVal = Number(value);
        if (isNil(value) || Number.isNaN(newVal)) {
          return null;
        }
        if (value === "") {
          if (valueOnClear === null) {
            return null;
          }
          newVal = isString$1(valueOnClear) ? { min, max }[valueOnClear] : valueOnClear;
        }
        if (stepStrictly) {
          newVal = toPrecision(Math.round(toPrecision(newVal / step)) * step, precision);
          if (newVal !== value) {
            update && emit(UPDATE_MODEL_EVENT, newVal);
          }
        }
        if (!isUndefined(precision)) {
          newVal = toPrecision(newVal, precision);
        }
        if (newVal > max || newVal < min) {
          newVal = newVal > max ? max : min;
          update && emit(UPDATE_MODEL_EVENT, newVal);
        }
        return newVal;
      };
      const setCurrentValue = (value, emitChange = true) => {
        var _a;
        const oldVal = data.currentValue;
        const newVal = verifyValue(value);
        if (!emitChange) {
          emit(UPDATE_MODEL_EVENT, newVal);
          return;
        }
        if (oldVal === newVal && value)
          return;
        data.userInput = null;
        emit(UPDATE_MODEL_EVENT, newVal);
        if (oldVal !== newVal) {
          emit(CHANGE_EVENT, newVal, oldVal);
        }
        if (props.validateEvent) {
          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
        }
        data.currentValue = newVal;
      };
      const handleInput = (value) => {
        data.userInput = value;
        const newVal = value === "" ? null : Number(value);
        emit(INPUT_EVENT, newVal);
        setCurrentValue(newVal, false);
      };
      const handleInputChange = (value) => {
        const newVal = value !== "" ? Number(value) : "";
        if (isNumber(newVal) && !Number.isNaN(newVal) || value === "") {
          setCurrentValue(newVal);
        }
        setCurrentValueToModelValue();
        data.userInput = null;
      };
      const focus = () => {
        var _a, _b;
        (_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
      };
      const blur = () => {
        var _a, _b;
        (_b = (_a = input.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
      };
      const handleFocus = (event) => {
        emit("focus", event);
      };
      const handleBlur = (event) => {
        var _a, _b;
        data.userInput = null;
        if (data.currentValue === null && ((_a = input.value) == null ? void 0 : _a.input)) {
          input.value.input.value = "";
        }
        emit("blur", event);
        if (props.validateEvent) {
          (_b = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _b.call(formItem, "blur").catch((err) => debugWarn(err));
        }
      };
      const setCurrentValueToModelValue = () => {
        if (data.currentValue !== props.modelValue) {
          data.currentValue = props.modelValue;
        }
      };
      const handleWheel = (e) => {
        if (document.activeElement === e.target)
          e.preventDefault();
      };
      vue.watch(() => props.modelValue, (value, oldValue) => {
        const newValue = verifyValue(value, true);
        if (data.userInput === null && newValue !== oldValue) {
          data.currentValue = newValue;
        }
      }, { immediate: true });
      vue.watch(() => props.precision, () => {
        data.currentValue = verifyValue(props.modelValue);
      });
      vue.onMounted(() => {
        var _a;
        const { min, max, modelValue } = props;
        const innerInput = (_a = input.value) == null ? void 0 : _a.input;
        innerInput.setAttribute("role", "spinbutton");
        if (Number.isFinite(max)) {
          innerInput.setAttribute("aria-valuemax", String(max));
        } else {
          innerInput.removeAttribute("aria-valuemax");
        }
        if (Number.isFinite(min)) {
          innerInput.setAttribute("aria-valuemin", String(min));
        } else {
          innerInput.removeAttribute("aria-valuemin");
        }
        innerInput.setAttribute("aria-valuenow", data.currentValue || data.currentValue === 0 ? String(data.currentValue) : "");
        innerInput.setAttribute("aria-disabled", String(inputNumberDisabled.value));
        if (!isNumber(modelValue) && modelValue != null) {
          let val = Number(modelValue);
          if (Number.isNaN(val)) {
            val = null;
          }
          emit(UPDATE_MODEL_EVENT, val);
        }
        innerInput.addEventListener("wheel", handleWheel, { passive: false });
      });
      vue.onUpdated(() => {
        var _a, _b;
        const innerInput = (_a = input.value) == null ? void 0 : _a.input;
        innerInput == null ? void 0 : innerInput.setAttribute("aria-valuenow", `${(_b = data.currentValue) != null ? _b : ""}`);
      });
      expose({
        focus,
        blur
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ns).b(),
            vue.unref(ns).m(vue.unref(inputNumberSize)),
            vue.unref(ns).is("disabled", vue.unref(inputNumberDisabled)),
            vue.unref(ns).is("without-controls", !_ctx.controls),
            vue.unref(ns).is("controls-right", vue.unref(controlsAtRight)),
            vue.unref(ns).is(_ctx.align, !!_ctx.align)
          ]),
          onDragstart: vue.withModifiers(() => {
          }, ["prevent"])
        }, [
          _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
            key: 0,
            role: "button",
            "aria-label": vue.unref(t)("el.inputNumber.decrease"),
            class: vue.normalizeClass([vue.unref(ns).e("decrease"), vue.unref(ns).is("disabled", vue.unref(minDisabled))]),
            onKeydown: vue.withKeys(decrease, ["enter"])
          }, [
            vue.renderSlot(_ctx.$slots, "decrease-icon", {}, () => [
              vue.createVNode(vue.unref(ElIcon), null, {
                default: vue.withCtx(() => [
                  vue.unref(controlsAtRight) ? (vue.openBlock(), vue.createBlock(vue.unref(arrow_down_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(minus_default), { key: 1 }))
                ]),
                _: 1
              })
            ])
          ], 42, ["aria-label", "onKeydown"])), [
            [vue.unref(vRepeatClick), decrease]
          ]) : vue.createCommentVNode("v-if", true),
          _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
            key: 1,
            role: "button",
            "aria-label": vue.unref(t)("el.inputNumber.increase"),
            class: vue.normalizeClass([vue.unref(ns).e("increase"), vue.unref(ns).is("disabled", vue.unref(maxDisabled))]),
            onKeydown: vue.withKeys(increase, ["enter"])
          }, [
            vue.renderSlot(_ctx.$slots, "increase-icon", {}, () => [
              vue.createVNode(vue.unref(ElIcon), null, {
                default: vue.withCtx(() => [
                  vue.unref(controlsAtRight) ? (vue.openBlock(), vue.createBlock(vue.unref(arrow_up_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(plus_default), { key: 1 }))
                ]),
                _: 1
              })
            ])
          ], 42, ["aria-label", "onKeydown"])), [
            [vue.unref(vRepeatClick), increase]
          ]) : vue.createCommentVNode("v-if", true),
          vue.createVNode(vue.unref(ElInput), {
            id: _ctx.id,
            ref_key: "input",
            ref: input,
            type: "number",
            step: _ctx.step,
            "model-value": vue.unref(displayValue),
            placeholder: _ctx.placeholder,
            readonly: _ctx.readonly,
            disabled: vue.unref(inputNumberDisabled),
            size: vue.unref(inputNumberSize),
            max: _ctx.max,
            min: _ctx.min,
            name: _ctx.name,
            "aria-label": _ctx.ariaLabel,
            "validate-event": false,
            inputmode: _ctx.inputmode,
            onKeydown: handleKeydown,
            onBlur: handleBlur,
            onFocus: handleFocus,
            onInput: handleInput,
            onChange: handleInputChange
          }, vue.createSlots({
            _: 2
          }, [
            _ctx.$slots.prefix ? {
              name: "prefix",
              fn: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "prefix")
              ])
            } : void 0,
            _ctx.$slots.suffix ? {
              name: "suffix",
              fn: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "suffix")
              ])
            } : void 0
          ]), 1032, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "aria-label", "inputmode"])
        ], 42, ["onDragstart"]);
      };
    }
  });
  var InputNumber = /* @__PURE__ */ _export_sfc(_sfc_main$15, [["__file", "input-number.vue"]]);

  const ElInputNumber = withInstall(InputNumber);

  const inputTagProps = buildProps({
    modelValue: {
      type: definePropType(Array)
    },
    max: Number,
    tagType: { ...tagProps.type, default: "info" },
    tagEffect: tagProps.effect,
    trigger: {
      type: definePropType(String),
      default: EVENT_CODE.enter
    },
    draggable: Boolean,
    delimiter: {
      type: [String, RegExp],
      default: ""
    },
    size: useSizeProp,
    clearable: Boolean,
    clearIcon: {
      type: iconPropType,
      default: circle_close_default
    },
    disabled: {
      type: Boolean,
      default: void 0
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    readonly: Boolean,
    autofocus: Boolean,
    id: {
      type: String,
      default: void 0
    },
    tabindex: {
      type: [String, Number],
      default: 0
    },
    maxlength: {
      type: [String, Number]
    },
    minlength: {
      type: [String, Number]
    },
    placeholder: String,
    autocomplete: {
      type: definePropType(String),
      default: "off"
    },
    saveOnBlur: {
      type: Boolean,
      default: true
    },
    collapseTags: Boolean,
    collapseTagsTooltip: Boolean,
    maxCollapseTags: {
      type: Number,
      default: 1
    },
    ariaLabel: String
  });
  const inputTagEmits = {
    [UPDATE_MODEL_EVENT]: (value) => isArray$1(value) || isUndefined(value),
    [CHANGE_EVENT]: (value) => isArray$1(value) || isUndefined(value),
    [INPUT_EVENT]: (value) => isString$1(value),
    "add-tag": (value) => isString$1(value) || isArray$1(value),
    "remove-tag": (value, index) => isString$1(value) && isNumber(index),
    "drag-tag": (oldIndex, newIndex, value) => isNumber(oldIndex) && isNumber(newIndex) && isString$1(value),
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent,
    clear: () => true
  };

  function useDragTag({
    wrapperRef,
    handleDragged,
    afterDragged
  }) {
    const ns = useNamespace("input-tag");
    const dropIndicatorRef = vue.shallowRef();
    const showDropIndicator = vue.ref(false);
    let draggingIndex;
    let draggingTag;
    let dropIndex;
    let dropType;
    function getTagClassName(index) {
      return `.${ns.e("inner")} .${ns.namespace.value}-tag:nth-child(${index + 1})`;
    }
    function handleDragStart(event, index) {
      draggingIndex = index;
      draggingTag = wrapperRef.value.querySelector(getTagClassName(index));
      if (draggingTag) {
        draggingTag.style.opacity = "0.5";
      }
      event.dataTransfer.effectAllowed = "move";
    }
    function handleDragOver(event, index) {
      dropIndex = index;
      event.preventDefault();
      event.dataTransfer.dropEffect = "move";
      if (isUndefined(draggingIndex) || draggingIndex === index) {
        showDropIndicator.value = false;
        return;
      }
      const dropPosition = wrapperRef.value.querySelector(getTagClassName(index)).getBoundingClientRect();
      const dropPrev = !(draggingIndex + 1 === index);
      const dropNext = !(draggingIndex - 1 === index);
      const distance = event.clientX - dropPosition.left;
      const prevPercent = dropPrev ? dropNext ? 0.5 : 1 : -1;
      const nextPercent = dropNext ? dropPrev ? 0.5 : 0 : 1;
      if (distance <= dropPosition.width * prevPercent) {
        dropType = "before";
      } else if (distance > dropPosition.width * nextPercent) {
        dropType = "after";
      } else {
        dropType = void 0;
      }
      const innerEl = wrapperRef.value.querySelector(`.${ns.e("inner")}`);
      const innerPosition = innerEl.getBoundingClientRect();
      const gap = Number.parseFloat(getStyle(innerEl, "gap")) / 2;
      const indicatorTop = dropPosition.top - innerPosition.top;
      let indicatorLeft = -9999;
      if (dropType === "before") {
        indicatorLeft = Math.max(dropPosition.left - innerPosition.left - gap, Math.floor(-gap / 2));
      } else if (dropType === "after") {
        const left = dropPosition.right - innerPosition.left;
        indicatorLeft = left + (innerPosition.width === left ? Math.floor(gap / 2) : gap);
      }
      setStyle(dropIndicatorRef.value, {
        top: `${indicatorTop}px`,
        left: `${indicatorLeft}px`
      });
      showDropIndicator.value = !!dropType;
    }
    function handleDragEnd(event) {
      event.preventDefault();
      if (draggingTag) {
        draggingTag.style.opacity = "";
      }
      if (dropType && !isUndefined(draggingIndex) && !isUndefined(dropIndex) && draggingIndex !== dropIndex) {
        handleDragged(draggingIndex, dropIndex, dropType);
      }
      showDropIndicator.value = false;
      draggingIndex = void 0;
      draggingTag = null;
      dropIndex = void 0;
      dropType = void 0;
      afterDragged == null ? void 0 : afterDragged();
    }
    return {
      dropIndicatorRef,
      showDropIndicator,
      handleDragStart,
      handleDragOver,
      handleDragEnd
    };
  }

  function useHovering() {
    const hovering = vue.ref(false);
    const handleMouseEnter = () => {
      hovering.value = true;
    };
    const handleMouseLeave = () => {
      hovering.value = false;
    };
    return {
      hovering,
      handleMouseEnter,
      handleMouseLeave
    };
  }

  function useInputTag({ props, emit, formItem }) {
    const disabled = useFormDisabled();
    const size = useFormSize();
    const inputRef = vue.shallowRef();
    const inputValue = vue.ref();
    const tagTooltipRef = vue.ref();
    const tagSize = vue.computed(() => {
      return ["small"].includes(size.value) ? "small" : "default";
    });
    const placeholder = vue.computed(() => {
      var _a;
      return ((_a = props.modelValue) == null ? void 0 : _a.length) ? void 0 : props.placeholder;
    });
    const closable = vue.computed(() => !(props.readonly || disabled.value));
    const inputLimit = vue.computed(() => {
      var _a, _b;
      return isUndefined(props.max) ? false : ((_b = (_a = props.modelValue) == null ? void 0 : _a.length) != null ? _b : 0) >= props.max;
    });
    const showTagList = vue.computed(() => {
      var _a;
      return props.collapseTags ? (_a = props.modelValue) == null ? void 0 : _a.slice(0, props.maxCollapseTags) : props.modelValue;
    });
    const collapseTagList = vue.computed(() => {
      var _a;
      return props.collapseTags ? (_a = props.modelValue) == null ? void 0 : _a.slice(props.maxCollapseTags) : [];
    });
    const addTagsEmit = (value) => {
      var _a;
      const list = [...(_a = props.modelValue) != null ? _a : [], ...castArray$1(value)];
      emit(UPDATE_MODEL_EVENT, list);
      emit(CHANGE_EVENT, list);
      emit("add-tag", value);
      inputValue.value = void 0;
    };
    const getDelimitedTags = (input) => {
      var _a, _b;
      const tags = input.split(props.delimiter).filter((val) => val && val !== input);
      if (props.max) {
        const maxInsert = props.max - ((_b = (_a = props.modelValue) == null ? void 0 : _a.length) != null ? _b : 0);
        tags.splice(maxInsert);
      }
      return tags.length === 1 ? tags[0] : tags;
    };
    const handleInput = (event) => {
      if (inputLimit.value) {
        inputValue.value = void 0;
        return;
      }
      if (isComposing.value)
        return;
      if (props.delimiter && inputValue.value) {
        const tags = getDelimitedTags(inputValue.value);
        if (tags.length) {
          addTagsEmit(tags);
        }
      }
      emit(INPUT_EVENT, event.target.value);
    };
    const handleKeydown = (event) => {
      var _a;
      if (isComposing.value)
        return;
      const code = getEventCode(event);
      switch (code) {
        case props.trigger:
          event.preventDefault();
          event.stopPropagation();
          handleAddTag();
          break;
        case EVENT_CODE.numpadEnter:
          if (props.trigger === EVENT_CODE.enter) {
            event.preventDefault();
            event.stopPropagation();
            handleAddTag();
          }
          break;
        case EVENT_CODE.backspace:
          if (!inputValue.value && ((_a = props.modelValue) == null ? void 0 : _a.length)) {
            event.preventDefault();
            event.stopPropagation();
            handleRemoveTag(props.modelValue.length - 1);
          }
          break;
      }
    };
    const handleKeyup = (event) => {
      if (isComposing.value || !isAndroid())
        return;
      const code = getEventCode(event);
      switch (code) {
        case EVENT_CODE.space:
          if (props.trigger === EVENT_CODE.space) {
            event.preventDefault();
            event.stopPropagation();
            handleAddTag();
          }
          break;
      }
    };
    const handleAddTag = () => {
      var _a;
      const value = (_a = inputValue.value) == null ? void 0 : _a.trim();
      if (!value || inputLimit.value)
        return;
      addTagsEmit(value);
    };
    const handleRemoveTag = (index) => {
      var _a;
      const value = ((_a = props.modelValue) != null ? _a : []).slice();
      const [item] = value.splice(index, 1);
      emit(UPDATE_MODEL_EVENT, value);
      emit(CHANGE_EVENT, value);
      emit("remove-tag", item, index);
    };
    const handleClear = () => {
      inputValue.value = void 0;
      emit(UPDATE_MODEL_EVENT, void 0);
      emit(CHANGE_EVENT, void 0);
      emit("clear");
    };
    const handleDragged = (draggingIndex, dropIndex, type) => {
      var _a;
      const value = ((_a = props.modelValue) != null ? _a : []).slice();
      const [draggedItem] = value.splice(draggingIndex, 1);
      const step = dropIndex > draggingIndex && type === "before" ? -1 : dropIndex < draggingIndex && type === "after" ? 1 : 0;
      value.splice(dropIndex + step, 0, draggedItem);
      emit(UPDATE_MODEL_EVENT, value);
      emit(CHANGE_EVENT, value);
      emit("drag-tag", draggingIndex, dropIndex + step, draggedItem);
    };
    const focus = () => {
      var _a;
      (_a = inputRef.value) == null ? void 0 : _a.focus();
    };
    const blur = () => {
      var _a;
      (_a = inputRef.value) == null ? void 0 : _a.blur();
    };
    const { wrapperRef, isFocused } = useFocusController(inputRef, {
      disabled,
      beforeBlur(event) {
        var _a;
        return (_a = tagTooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event);
      },
      afterBlur() {
        var _a;
        if (props.saveOnBlur) {
          handleAddTag();
        } else {
          inputValue.value = void 0;
        }
        if (props.validateEvent) {
          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
        }
      }
    });
    const {
      isComposing,
      handleCompositionStart,
      handleCompositionUpdate,
      handleCompositionEnd
    } = useComposition({ afterComposition: handleInput });
    vue.watch(() => props.modelValue, () => {
      var _a;
      if (props.validateEvent) {
        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, CHANGE_EVENT).catch((err) => debugWarn(err));
      }
    });
    return {
      inputRef,
      wrapperRef,
      tagTooltipRef,
      isFocused,
      isComposing,
      inputValue,
      size,
      tagSize,
      placeholder,
      closable,
      disabled,
      inputLimit,
      showTagList,
      collapseTagList,
      handleDragged,
      handleInput,
      handleKeydown,
      handleKeyup,
      handleAddTag,
      handleRemoveTag,
      handleClear,
      handleCompositionStart,
      handleCompositionUpdate,
      handleCompositionEnd,
      focus,
      blur
    };
  }

  function useInputTagDom({
    props,
    isFocused,
    hovering,
    disabled,
    inputValue,
    size,
    validateState,
    validateIcon,
    needStatusIcon
  }) {
    const attrs = vue.useAttrs();
    const slots = vue.useSlots();
    const ns = useNamespace("input-tag");
    const nsInput = useNamespace("input");
    const containerKls = vue.computed(() => [
      ns.b(),
      ns.is("focused", isFocused.value),
      ns.is("hovering", hovering.value),
      ns.is("disabled", disabled.value),
      ns.m(size.value),
      ns.e("wrapper"),
      attrs.class
    ]);
    const containerStyle = vue.computed(() => [attrs.style]);
    const innerKls = vue.computed(() => {
      var _a, _b;
      return [
        ns.e("inner"),
        ns.is("draggable", props.draggable),
        ns.is("left-space", !((_a = props.modelValue) == null ? void 0 : _a.length) && !slots.prefix),
        ns.is("right-space", !((_b = props.modelValue) == null ? void 0 : _b.length) && !showSuffix.value)
      ];
    });
    const showClear = vue.computed(() => {
      var _a;
      return props.clearable && !disabled.value && !props.readonly && (((_a = props.modelValue) == null ? void 0 : _a.length) || inputValue.value) && (isFocused.value || hovering.value);
    });
    const showSuffix = vue.computed(() => {
      return slots.suffix || showClear.value || validateState.value && validateIcon.value && needStatusIcon.value;
    });
    return {
      ns,
      nsInput,
      containerKls,
      containerStyle,
      innerKls,
      showClear,
      showSuffix
    };
  }

  const __default__$S = vue.defineComponent({
    name: "ElInputTag",
    inheritAttrs: false
  });
  const _sfc_main$14 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$S,
    props: inputTagProps,
    emits: inputTagEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const attrs = useAttrs();
      const slots = vue.useSlots();
      const { form, formItem } = useFormItem();
      const { inputId } = useFormItemInputId(props, { formItemContext: formItem });
      const needStatusIcon = vue.computed(() => {
        var _a;
        return (_a = form == null ? void 0 : form.statusIcon) != null ? _a : false;
      });
      const validateState = vue.computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
      const validateIcon = vue.computed(() => {
        return validateState.value && ValidateComponentsMap[validateState.value];
      });
      const {
        inputRef,
        wrapperRef,
        tagTooltipRef,
        isFocused,
        inputValue,
        size,
        tagSize,
        placeholder,
        closable,
        disabled,
        showTagList,
        collapseTagList,
        handleDragged,
        handleInput,
        handleKeydown,
        handleKeyup,
        handleRemoveTag,
        handleClear,
        handleCompositionStart,
        handleCompositionUpdate,
        handleCompositionEnd,
        focus,
        blur
      } = useInputTag({ props, emit, formItem });
      const { hovering, handleMouseEnter, handleMouseLeave } = useHovering();
      const { calculatorRef, inputStyle } = useCalcInputWidth();
      const {
        dropIndicatorRef,
        showDropIndicator,
        handleDragStart,
        handleDragOver,
        handleDragEnd
      } = useDragTag({ wrapperRef, handleDragged, afterDragged: focus });
      const {
        ns,
        nsInput,
        containerKls,
        containerStyle,
        innerKls,
        showClear,
        showSuffix
      } = useInputTagDom({
        props,
        hovering,
        isFocused,
        inputValue,
        disabled,
        size,
        validateState,
        validateIcon,
        needStatusIcon
      });
      expose({
        focus,
        blur
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "wrapperRef",
          ref: wrapperRef,
          class: vue.normalizeClass(vue.unref(containerKls)),
          style: vue.normalizeStyle(vue.unref(containerStyle)),
          onMouseenter: vue.unref(handleMouseEnter),
          onMouseleave: vue.unref(handleMouseLeave)
        }, [
          vue.unref(slots).prefix ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("prefix"))
          }, [
            vue.renderSlot(_ctx.$slots, "prefix")
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(innerKls))
          }, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(showTagList), (item, index) => {
              return vue.openBlock(), vue.createBlock(vue.unref(ElTag), {
                key: index,
                size: vue.unref(tagSize),
                closable: vue.unref(closable),
                type: _ctx.tagType,
                effect: _ctx.tagEffect,
                draggable: vue.unref(closable) && _ctx.draggable,
                "disable-transitions": "",
                onClose: ($event) => vue.unref(handleRemoveTag)(index),
                onDragstart: (event) => vue.unref(handleDragStart)(event, index),
                onDragover: (event) => vue.unref(handleDragOver)(event, index),
                onDragend: vue.unref(handleDragEnd),
                onDrop: vue.withModifiers(() => {
                }, ["stop"])
              }, {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "tag", {
                    value: item,
                    index
                  }, () => [
                    vue.createTextVNode(vue.toDisplayString(item), 1)
                  ])
                ]),
                _: 2
              }, 1032, ["size", "closable", "type", "effect", "draggable", "onClose", "onDragstart", "onDragover", "onDragend", "onDrop"]);
            }), 128)),
            _ctx.collapseTags && _ctx.modelValue && _ctx.modelValue.length > _ctx.maxCollapseTags ? (vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
              key: 0,
              ref_key: "tagTooltipRef",
              ref: tagTooltipRef,
              disabled: !_ctx.collapseTagsTooltip,
              "fallback-placements": ["bottom", "top", "right", "left"],
              effect: _ctx.tagEffect,
              placement: "bottom"
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(vue.unref(ElTag), {
                  closable: false,
                  size: vue.unref(tagSize),
                  type: _ctx.tagType,
                  effect: _ctx.tagEffect,
                  "disable-transitions": ""
                }, {
                  default: vue.withCtx(() => [
                    vue.createTextVNode(" + " + vue.toDisplayString(_ctx.modelValue.length - _ctx.maxCollapseTags), 1)
                  ]),
                  _: 1
                }, 8, ["size", "type", "effect"])
              ]),
              content: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("input-tag-list"))
                }, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(collapseTagList), (item, index) => {
                    return vue.openBlock(), vue.createBlock(vue.unref(ElTag), {
                      key: index,
                      size: vue.unref(tagSize),
                      closable: vue.unref(closable),
                      type: _ctx.tagType,
                      effect: _ctx.tagEffect,
                      "disable-transitions": "",
                      onClose: ($event) => vue.unref(handleRemoveTag)(index + _ctx.maxCollapseTags)
                    }, {
                      default: vue.withCtx(() => [
                        vue.renderSlot(_ctx.$slots, "tag", {
                          value: item,
                          index: index + _ctx.maxCollapseTags
                        }, () => [
                          vue.createTextVNode(vue.toDisplayString(item), 1)
                        ])
                      ]),
                      _: 2
                    }, 1032, ["size", "closable", "type", "effect", "onClose"]);
                  }), 128))
                ], 2)
              ]),
              _: 3
            }, 8, ["disabled", "effect"])) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("input-wrapper"))
            }, [
              vue.withDirectives(vue.createElementVNode("input", vue.mergeProps({
                id: vue.unref(inputId),
                ref_key: "inputRef",
                ref: inputRef,
                "onUpdate:modelValue": ($event) => vue.isRef(inputValue) ? inputValue.value = $event : null
              }, vue.unref(attrs), {
                type: "text",
                minlength: _ctx.minlength,
                maxlength: _ctx.maxlength,
                disabled: vue.unref(disabled),
                readonly: _ctx.readonly,
                autocomplete: _ctx.autocomplete,
                tabindex: _ctx.tabindex,
                placeholder: vue.unref(placeholder),
                autofocus: _ctx.autofocus,
                ariaLabel: _ctx.ariaLabel,
                class: vue.unref(ns).e("input"),
                style: vue.unref(inputStyle),
                onCompositionstart: vue.unref(handleCompositionStart),
                onCompositionupdate: vue.unref(handleCompositionUpdate),
                onCompositionend: vue.unref(handleCompositionEnd),
                onInput: vue.unref(handleInput),
                onKeydown: vue.unref(handleKeydown),
                onKeyup: vue.unref(handleKeyup)
              }), null, 16, ["id", "onUpdate:modelValue", "minlength", "maxlength", "disabled", "readonly", "autocomplete", "tabindex", "placeholder", "autofocus", "ariaLabel", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onInput", "onKeydown", "onKeyup"]), [
                [vue.vModelText, vue.unref(inputValue)]
              ]),
              vue.createElementVNode("span", {
                ref_key: "calculatorRef",
                ref: calculatorRef,
                "aria-hidden": "true",
                class: vue.normalizeClass(vue.unref(ns).e("input-calculator")),
                textContent: vue.toDisplayString(vue.unref(inputValue))
              }, null, 10, ["textContent"])
            ], 2),
            vue.withDirectives(vue.createElementVNode("div", {
              ref_key: "dropIndicatorRef",
              ref: dropIndicatorRef,
              class: vue.normalizeClass(vue.unref(ns).e("drop-indicator"))
            }, null, 2), [
              [vue.vShow, vue.unref(showDropIndicator)]
            ])
          ], 2),
          vue.unref(showSuffix) ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("suffix"))
          }, [
            vue.renderSlot(_ctx.$slots, "suffix"),
            vue.unref(showClear) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 0,
              class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(ns).e("clear")]),
              onMousedown: vue.withModifiers(vue.unref(NOOP), ["prevent"]),
              onClick: vue.unref(handleClear)
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
              ]),
              _: 1
            }, 8, ["class", "onMousedown", "onClick"])) : vue.createCommentVNode("v-if", true),
            vue.unref(validateState) && vue.unref(validateIcon) && vue.unref(needStatusIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 1,
              class: vue.normalizeClass([
                vue.unref(nsInput).e("icon"),
                vue.unref(nsInput).e("validateIcon"),
                vue.unref(nsInput).is("loading", vue.unref(validateState) === "validating")
              ])
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(validateIcon))))
              ]),
              _: 1
            }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 46, ["onMouseenter", "onMouseleave"]);
      };
    }
  });
  var InputTag = /* @__PURE__ */ _export_sfc(_sfc_main$14, [["__file", "input-tag.vue"]]);

  const ElInputTag = withInstall(InputTag);

  const linkProps = buildProps({
    type: {
      type: String,
      values: ["primary", "success", "warning", "info", "danger", "default"],
      default: void 0
    },
    underline: {
      type: [Boolean, String],
      values: [true, false, "always", "never", "hover"],
      default: void 0
    },
    disabled: Boolean,
    href: { type: String, default: "" },
    target: {
      type: String,
      default: "_self"
    },
    icon: {
      type: iconPropType
    }
  });
  const linkEmits = {
    click: (evt) => evt instanceof MouseEvent
  };

  const __default__$R = vue.defineComponent({
    name: "ElLink"
  });
  const _sfc_main$13 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$R,
    props: linkProps,
    emits: linkEmits,
    setup(__props, { emit }) {
      const props = __props;
      const globalConfig = useGlobalConfig("link");
      useDeprecated({
        scope: "el-link",
        from: "The underline option (boolean)",
        replacement: "'always' | 'hover' | 'never'",
        version: "3.0.0",
        ref: "https://element-plus.org/en-US/component/link.html#underline"
      }, vue.computed(() => isBoolean(props.underline)));
      const ns = useNamespace("link");
      const linkKls = vue.computed(() => {
        var _a, _b, _c;
        return [
          ns.b(),
          ns.m((_c = (_b = props.type) != null ? _b : (_a = globalConfig.value) == null ? void 0 : _a.type) != null ? _c : "default"),
          ns.is("disabled", props.disabled),
          ns.is("underline", underline.value === "always"),
          ns.is("hover-underline", underline.value === "hover" && !props.disabled)
        ];
      });
      const underline = vue.computed(() => {
        var _a, _b, _c;
        if (isBoolean(props.underline)) {
          return props.underline ? "hover" : "never";
        } else
          return (_c = (_b = props.underline) != null ? _b : (_a = globalConfig.value) == null ? void 0 : _a.underline) != null ? _c : "hover";
      });
      function handleClick(event) {
        if (!props.disabled)
          emit("click", event);
      }
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("a", {
          class: vue.normalizeClass(vue.unref(linkKls)),
          href: _ctx.disabled || !_ctx.href ? void 0 : _ctx.href,
          target: _ctx.disabled || !_ctx.href ? void 0 : _ctx.target,
          onClick: handleClick
        }, [
          _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
            default: vue.withCtx(() => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
            ]),
            _: 1
          })) : vue.createCommentVNode("v-if", true),
          _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("span", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("inner"))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2)) : vue.createCommentVNode("v-if", true),
          _ctx.$slots.icon ? vue.renderSlot(_ctx.$slots, "icon", { key: 2 }) : vue.createCommentVNode("v-if", true)
        ], 10, ["href", "target"]);
      };
    }
  });
  var Link = /* @__PURE__ */ _export_sfc(_sfc_main$13, [["__file", "link.vue"]]);

  const ElLink = withInstall(Link);

  class SubMenu$1 {
    constructor(parent, domNode) {
      this.parent = parent;
      this.domNode = domNode;
      this.subIndex = 0;
      this.subIndex = 0;
      this.init();
    }
    init() {
      this.subMenuItems = this.domNode.querySelectorAll("li");
      this.addListeners();
    }
    gotoSubIndex(idx) {
      if (idx === this.subMenuItems.length) {
        idx = 0;
      } else if (idx < 0) {
        idx = this.subMenuItems.length - 1;
      }
      this.subMenuItems[idx].focus();
      this.subIndex = idx;
    }
    addListeners() {
      const parentNode = this.parent.domNode;
      Array.prototype.forEach.call(this.subMenuItems, (el) => {
        el.addEventListener("keydown", (event) => {
          const code = getEventCode(event);
          let prevDef = false;
          switch (code) {
            case EVENT_CODE.down: {
              this.gotoSubIndex(this.subIndex + 1);
              prevDef = true;
              break;
            }
            case EVENT_CODE.up: {
              this.gotoSubIndex(this.subIndex - 1);
              prevDef = true;
              break;
            }
            case EVENT_CODE.tab: {
              triggerEvent(parentNode, "mouseleave");
              break;
            }
            case EVENT_CODE.enter:
            case EVENT_CODE.numpadEnter:
            case EVENT_CODE.space: {
              prevDef = true;
              event.currentTarget.click();
              break;
            }
          }
          if (prevDef) {
            event.preventDefault();
            event.stopPropagation();
          }
          return false;
        });
      });
    }
  }
  var SubMenu$2 = SubMenu$1;

  class MenuItem$1 {
    constructor(domNode, namespace) {
      this.domNode = domNode;
      this.submenu = null;
      this.submenu = null;
      this.init(namespace);
    }
    init(namespace) {
      this.domNode.setAttribute("tabindex", "0");
      const menuChild = this.domNode.querySelector(`.${namespace}-menu`);
      if (menuChild) {
        this.submenu = new SubMenu$2(this, menuChild);
      }
      this.addListeners();
    }
    addListeners() {
      this.domNode.addEventListener("keydown", (event) => {
        const code = getEventCode(event);
        let prevDef = false;
        switch (code) {
          case EVENT_CODE.down: {
            triggerEvent(event.currentTarget, "mouseenter");
            this.submenu && this.submenu.gotoSubIndex(0);
            prevDef = true;
            break;
          }
          case EVENT_CODE.up: {
            triggerEvent(event.currentTarget, "mouseenter");
            this.submenu && this.submenu.gotoSubIndex(this.submenu.subMenuItems.length - 1);
            prevDef = true;
            break;
          }
          case EVENT_CODE.tab: {
            triggerEvent(event.currentTarget, "mouseleave");
            break;
          }
          case EVENT_CODE.enter:
          case EVENT_CODE.numpadEnter:
          case EVENT_CODE.space: {
            prevDef = true;
            event.currentTarget.click();
            break;
          }
        }
        if (prevDef) {
          event.preventDefault();
        }
      });
    }
  }
  var MenuItem$2 = MenuItem$1;

  class Menu$1 {
    constructor(domNode, namespace) {
      this.domNode = domNode;
      this.init(namespace);
    }
    init(namespace) {
      const menuChildren = this.domNode.childNodes;
      Array.from(menuChildren).forEach((child) => {
        if (child.nodeType === 1) {
          new MenuItem$2(child, namespace);
        }
      });
    }
  }
  var Menubar = Menu$1;

  const __default__$Q = vue.defineComponent({
    name: "ElMenuCollapseTransition"
  });
  const _sfc_main$12 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$Q,
    setup(__props) {
      const ns = useNamespace("menu");
      const listeners = {
        onBeforeEnter: (el) => el.style.opacity = "0.2",
        onEnter(el, done) {
          addClass(el, `${ns.namespace.value}-opacity-transition`);
          el.style.opacity = "1";
          done();
        },
        onAfterEnter(el) {
          removeClass(el, `${ns.namespace.value}-opacity-transition`);
          el.style.opacity = "";
        },
        onBeforeLeave(el) {
          if (!el.dataset)
            el.dataset = {};
          if (hasClass(el, ns.m("collapse"))) {
            removeClass(el, ns.m("collapse"));
            el.dataset.oldOverflow = el.style.overflow;
            el.dataset.scrollWidth = el.clientWidth.toString();
            addClass(el, ns.m("collapse"));
          } else {
            addClass(el, ns.m("collapse"));
            el.dataset.oldOverflow = el.style.overflow;
            el.dataset.scrollWidth = el.clientWidth.toString();
            removeClass(el, ns.m("collapse"));
          }
          el.style.width = `${el.scrollWidth}px`;
          el.style.overflow = "hidden";
        },
        onLeave(el) {
          addClass(el, "horizontal-collapse-transition");
          el.style.width = `${el.dataset.scrollWidth}px`;
        }
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, vue.mergeProps({ mode: "out-in" }, vue.unref(listeners)), {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 16);
      };
    }
  });
  var ElMenuCollapseTransition = /* @__PURE__ */ _export_sfc(_sfc_main$12, [["__file", "menu-collapse-transition.vue"]]);

  function useMenu(instance, currentIndex) {
    const indexPath = vue.computed(() => {
      let parent = instance.parent;
      const path = [currentIndex.value];
      while (parent.type.name !== "ElMenu") {
        if (parent.props.index) {
          path.unshift(parent.props.index);
        }
        parent = parent.parent;
      }
      return path;
    });
    const parentMenu = vue.computed(() => {
      let parent = instance.parent;
      while (parent && !["ElMenu", "ElSubMenu"].includes(parent.type.name)) {
        parent = parent.parent;
      }
      return parent;
    });
    return {
      parentMenu,
      indexPath
    };
  }

  function useMenuColor(props) {
    const menuBarColor = vue.computed(() => {
      const color = props.backgroundColor;
      return color ? new TinyColor(color).shade(20).toString() : "";
    });
    return menuBarColor;
  }

  const useMenuCssVar = (props, level) => {
    const ns = useNamespace("menu");
    return vue.computed(() => ns.cssVarBlock({
      "text-color": props.textColor || "",
      "hover-text-color": props.textColor || "",
      "bg-color": props.backgroundColor || "",
      "hover-bg-color": useMenuColor(props).value || "",
      "active-color": props.activeTextColor || "",
      level: `${level}`
    }));
  };

  const MENU_INJECTION_KEY = "rootMenu";
  const SUB_MENU_INJECTION_KEY = "subMenu:";

  const subMenuProps = buildProps({
    index: {
      type: String,
      required: true
    },
    showTimeout: Number,
    hideTimeout: Number,
    popperClass: String,
    popperStyle: {
      type: definePropType([String, Object])
    },
    disabled: Boolean,
    teleported: {
      type: Boolean,
      default: void 0
    },
    popperOffset: Number,
    expandCloseIcon: {
      type: iconPropType
    },
    expandOpenIcon: {
      type: iconPropType
    },
    collapseCloseIcon: {
      type: iconPropType
    },
    collapseOpenIcon: {
      type: iconPropType
    }
  });
  const COMPONENT_NAME$d = "ElSubMenu";
  var SubMenu = vue.defineComponent({
    name: COMPONENT_NAME$d,
    props: subMenuProps,
    setup(props, { slots, expose }) {
      const instance = vue.getCurrentInstance();
      const { indexPath, parentMenu } = useMenu(instance, vue.computed(() => props.index));
      const nsMenu = useNamespace("menu");
      const nsSubMenu = useNamespace("sub-menu");
      const rootMenu = vue.inject(MENU_INJECTION_KEY);
      if (!rootMenu)
        throwError(COMPONENT_NAME$d, "can not inject root menu");
      const subMenu = vue.inject(`${SUB_MENU_INJECTION_KEY}${parentMenu.value.uid}`);
      if (!subMenu)
        throwError(COMPONENT_NAME$d, "can not inject sub menu");
      const items = vue.ref({});
      const subMenus = vue.ref({});
      let timeout;
      const mouseInChild = vue.ref(false);
      const verticalTitleRef = vue.ref();
      const vPopper = vue.ref();
      const isFirstLevel = vue.computed(() => subMenu.level === 0);
      const currentPlacement = vue.computed(() => mode.value === "horizontal" && isFirstLevel.value ? "bottom-start" : "right-start");
      const subMenuTitleIcon = vue.computed(() => {
        const isExpandedMode = mode.value === "horizontal" && isFirstLevel.value || mode.value === "vertical" && !rootMenu.props.collapse;
        if (isExpandedMode) {
          if (props.expandCloseIcon && props.expandOpenIcon) {
            return opened.value ? props.expandOpenIcon : props.expandCloseIcon;
          }
          return arrow_down_default;
        } else {
          if (props.collapseCloseIcon && props.collapseOpenIcon) {
            return opened.value ? props.collapseOpenIcon : props.collapseCloseIcon;
          }
          return arrow_right_default;
        }
      });
      const appendToBody = vue.computed(() => {
        const value = props.teleported;
        return isUndefined(value) ? isFirstLevel.value : value;
      });
      const menuTransitionName = vue.computed(() => rootMenu.props.collapse ? `${nsMenu.namespace.value}-zoom-in-left` : `${nsMenu.namespace.value}-zoom-in-top`);
      const fallbackPlacements = vue.computed(() => mode.value === "horizontal" && isFirstLevel.value ? [
        "bottom-start",
        "bottom-end",
        "top-start",
        "top-end",
        "right-start",
        "left-start"
      ] : [
        "right-start",
        "right",
        "right-end",
        "left-start",
        "bottom-start",
        "bottom-end",
        "top-start",
        "top-end"
      ]);
      const opened = vue.computed(() => rootMenu.openedMenus.includes(props.index));
      const active = vue.computed(() => [...Object.values(items.value), ...Object.values(subMenus.value)].some(({ active: active2 }) => active2));
      const mode = vue.computed(() => rootMenu.props.mode);
      const persistent = vue.computed(() => rootMenu.props.persistent);
      const item = vue.reactive({
        index: props.index,
        indexPath,
        active
      });
      const ulStyle = useMenuCssVar(rootMenu.props, subMenu.level + 1);
      const subMenuPopperOffset = vue.computed(() => {
        var _a;
        return (_a = props.popperOffset) != null ? _a : rootMenu.props.popperOffset;
      });
      const subMenuPopperClass = vue.computed(() => {
        var _a;
        return (_a = props.popperClass) != null ? _a : rootMenu.props.popperClass;
      });
      const subMenuPopperStyle = vue.computed(() => {
        var _a;
        return (_a = props.popperStyle) != null ? _a : rootMenu.props.popperStyle;
      });
      const subMenuShowTimeout = vue.computed(() => {
        var _a;
        return (_a = props.showTimeout) != null ? _a : rootMenu.props.showTimeout;
      });
      const subMenuHideTimeout = vue.computed(() => {
        var _a;
        return (_a = props.hideTimeout) != null ? _a : rootMenu.props.hideTimeout;
      });
      const doDestroy = () => {
        var _a, _b, _c;
        return (_c = (_b = (_a = vPopper.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.popperInstanceRef) == null ? void 0 : _c.destroy();
      };
      const handleCollapseToggle = (value) => {
        if (!value) {
          doDestroy();
        }
      };
      const handleClick = () => {
        if (rootMenu.props.menuTrigger === "hover" && rootMenu.props.mode === "horizontal" || rootMenu.props.collapse && rootMenu.props.mode === "vertical" || props.disabled)
          return;
        rootMenu.handleSubMenuClick({
          index: props.index,
          indexPath: indexPath.value,
          active: active.value
        });
      };
      const handleMouseenter = (event, showTimeout = subMenuShowTimeout.value) => {
        var _a;
        if (event.type === "focus")
          return;
        if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical" || props.disabled) {
          subMenu.mouseInChild.value = true;
          return;
        }
        subMenu.mouseInChild.value = true;
        timeout == null ? void 0 : timeout();
        ({ stop: timeout } = useTimeoutFn(() => {
          rootMenu.openMenu(props.index, indexPath.value);
        }, showTimeout));
        if (appendToBody.value) {
          (_a = parentMenu.value.vnode.el) == null ? void 0 : _a.dispatchEvent(new MouseEvent("mouseenter"));
        }
        if (event.type === "mouseenter" && event.target) {
          vue.nextTick(() => {
            focusElement(event.target, { preventScroll: true });
          });
        }
      };
      const handleMouseleave = (deepDispatch = false) => {
        var _a;
        if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical") {
          subMenu.mouseInChild.value = false;
          return;
        }
        timeout == null ? void 0 : timeout();
        subMenu.mouseInChild.value = false;
        ({ stop: timeout } = useTimeoutFn(() => !mouseInChild.value && rootMenu.closeMenu(props.index, indexPath.value), subMenuHideTimeout.value));
        if (appendToBody.value && deepDispatch) {
          (_a = subMenu.handleMouseleave) == null ? void 0 : _a.call(subMenu, true);
        }
      };
      vue.watch(() => rootMenu.props.collapse, (value) => handleCollapseToggle(Boolean(value)));
      {
        const addSubMenu = (item2) => {
          subMenus.value[item2.index] = item2;
        };
        const removeSubMenu = (item2) => {
          delete subMenus.value[item2.index];
        };
        vue.provide(`${SUB_MENU_INJECTION_KEY}${instance.uid}`, {
          addSubMenu,
          removeSubMenu,
          handleMouseleave,
          mouseInChild,
          level: subMenu.level + 1
        });
      }
      expose({
        opened
      });
      vue.onMounted(() => {
        rootMenu.addSubMenu(item);
        subMenu.addSubMenu(item);
      });
      vue.onBeforeUnmount(() => {
        subMenu.removeSubMenu(item);
        rootMenu.removeSubMenu(item);
      });
      return () => {
        var _a;
        const titleTag = [
          (_a = slots.title) == null ? void 0 : _a.call(slots),
          vue.h(ElIcon, {
            class: nsSubMenu.e("icon-arrow"),
            style: {
              transform: opened.value ? props.expandCloseIcon && props.expandOpenIcon || props.collapseCloseIcon && props.collapseOpenIcon && rootMenu.props.collapse ? "none" : "rotateZ(180deg)" : "none"
            }
          }, {
            default: () => isString$1(subMenuTitleIcon.value) ? vue.h(instance.appContext.components[subMenuTitleIcon.value]) : vue.h(subMenuTitleIcon.value)
          })
        ];
        const child = rootMenu.isMenuPopup ? vue.h(ElTooltip, {
          ref: vPopper,
          visible: opened.value,
          effect: "light",
          pure: true,
          offset: subMenuPopperOffset.value,
          showArrow: false,
          persistent: persistent.value,
          popperClass: subMenuPopperClass.value,
          popperStyle: subMenuPopperStyle.value,
          placement: currentPlacement.value,
          teleported: appendToBody.value,
          fallbackPlacements: fallbackPlacements.value,
          transition: menuTransitionName.value,
          gpuAcceleration: false
        }, {
          content: () => {
            var _a2;
            return vue.h("div", {
              class: [
                nsMenu.m(mode.value),
                nsMenu.m("popup-container"),
                subMenuPopperClass.value
              ],
              onMouseenter: (evt) => handleMouseenter(evt, 100),
              onMouseleave: () => handleMouseleave(true),
              onFocus: (evt) => handleMouseenter(evt, 100)
            }, [
              vue.h("ul", {
                class: [
                  nsMenu.b(),
                  nsMenu.m("popup"),
                  nsMenu.m(`popup-${currentPlacement.value}`)
                ],
                style: ulStyle.value
              }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)])
            ]);
          },
          default: () => vue.h("div", {
            class: nsSubMenu.e("title"),
            onClick: handleClick
          }, titleTag)
        }) : vue.h(vue.Fragment, {}, [
          vue.h("div", {
            class: nsSubMenu.e("title"),
            ref: verticalTitleRef,
            onClick: handleClick
          }, titleTag),
          vue.h(ElCollapseTransition, {}, {
            default: () => {
              var _a2;
              return vue.withDirectives(vue.h("ul", {
                role: "menu",
                class: [nsMenu.b(), nsMenu.m("inline")],
                style: ulStyle.value
              }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]), [[vue.vShow, opened.value]]);
            }
          })
        ]);
        return vue.h("li", {
          class: [
            nsSubMenu.b(),
            nsSubMenu.is("active", active.value),
            nsSubMenu.is("opened", opened.value),
            nsSubMenu.is("disabled", props.disabled)
          ],
          role: "menuitem",
          ariaHaspopup: true,
          ariaExpanded: opened.value,
          onMouseenter: handleMouseenter,
          onMouseleave: () => handleMouseleave(),
          onFocus: handleMouseenter
        }, [child]);
      };
    }
  });

  const menuProps = buildProps({
    mode: {
      type: String,
      values: ["horizontal", "vertical"],
      default: "vertical"
    },
    defaultActive: {
      type: String,
      default: ""
    },
    defaultOpeneds: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    uniqueOpened: Boolean,
    router: Boolean,
    menuTrigger: {
      type: String,
      values: ["hover", "click"],
      default: "hover"
    },
    collapse: Boolean,
    backgroundColor: String,
    textColor: String,
    activeTextColor: String,
    closeOnClickOutside: Boolean,
    collapseTransition: {
      type: Boolean,
      default: true
    },
    ellipsis: {
      type: Boolean,
      default: true
    },
    popperOffset: {
      type: Number,
      default: 6
    },
    ellipsisIcon: {
      type: iconPropType,
      default: () => more_default
    },
    popperEffect: {
      type: definePropType(String),
      default: "dark"
    },
    popperClass: String,
    popperStyle: {
      type: definePropType([String, Object])
    },
    showTimeout: {
      type: Number,
      default: 300
    },
    hideTimeout: {
      type: Number,
      default: 300
    },
    persistent: {
      type: Boolean,
      default: true
    }
  });
  const checkIndexPath = (indexPath) => isArray$1(indexPath) && indexPath.every((path) => isString$1(path));
  const menuEmits = {
    close: (index, indexPath) => isString$1(index) && checkIndexPath(indexPath),
    open: (index, indexPath) => isString$1(index) && checkIndexPath(indexPath),
    select: (index, indexPath, item, routerResult) => isString$1(index) && checkIndexPath(indexPath) && isObject$1(item) && (isUndefined(routerResult) || routerResult instanceof Promise)
  };
  var Menu = vue.defineComponent({
    name: "ElMenu",
    props: menuProps,
    emits: menuEmits,
    setup(props, { emit, slots, expose }) {
      const instance = vue.getCurrentInstance();
      const router = instance.appContext.config.globalProperties.$router;
      const menu = vue.ref();
      const subMenu = vue.ref();
      const nsMenu = useNamespace("menu");
      const nsSubMenu = useNamespace("sub-menu");
      let moreItemWidth = 64;
      const sliceIndex = vue.ref(-1);
      const openedMenus = vue.ref(props.defaultOpeneds && !props.collapse ? props.defaultOpeneds.slice(0) : []);
      const activeIndex = vue.ref(props.defaultActive);
      const items = vue.ref({});
      const subMenus = vue.ref({});
      const isMenuPopup = vue.computed(() => props.mode === "horizontal" || props.mode === "vertical" && props.collapse);
      const initMenu = () => {
        const activeItem = activeIndex.value && items.value[activeIndex.value];
        if (!activeItem || props.mode === "horizontal" || props.collapse)
          return;
        const indexPath = activeItem.indexPath;
        indexPath.forEach((index) => {
          const subMenu2 = subMenus.value[index];
          subMenu2 && openMenu(index, subMenu2.indexPath);
        });
      };
      const openMenu = (index, indexPath) => {
        if (openedMenus.value.includes(index))
          return;
        if (props.uniqueOpened) {
          openedMenus.value = openedMenus.value.filter((index2) => indexPath.includes(index2));
        }
        openedMenus.value.push(index);
        emit("open", index, indexPath);
      };
      const close = (index) => {
        const i = openedMenus.value.indexOf(index);
        if (i !== -1) {
          openedMenus.value.splice(i, 1);
        }
      };
      const closeMenu = (index, indexPath) => {
        close(index);
        emit("close", index, indexPath);
      };
      const handleSubMenuClick = ({
        index,
        indexPath
      }) => {
        const isOpened = openedMenus.value.includes(index);
        isOpened ? closeMenu(index, indexPath) : openMenu(index, indexPath);
      };
      const handleMenuItemClick = (menuItem) => {
        if (props.mode === "horizontal" || props.collapse) {
          openedMenus.value = [];
        }
        const { index, indexPath } = menuItem;
        if (isNil(index) || isNil(indexPath))
          return;
        if (props.router && router) {
          const route = menuItem.route || index;
          const routerResult = router.push(route).then((res) => {
            if (!res)
              activeIndex.value = index;
            return res;
          });
          emit("select", index, indexPath, { index, indexPath, route }, routerResult);
        } else {
          activeIndex.value = index;
          emit("select", index, indexPath, { index, indexPath });
        }
      };
      const updateActiveIndex = (val) => {
        var _a;
        const itemsInData = items.value;
        const item = itemsInData[val] || activeIndex.value && itemsInData[activeIndex.value] || itemsInData[props.defaultActive];
        activeIndex.value = (_a = item == null ? void 0 : item.index) != null ? _a : val;
      };
      const calcMenuItemWidth = (menuItem) => {
        const computedStyle = getComputedStyle(menuItem);
        const marginLeft = Number.parseInt(computedStyle.marginLeft, 10);
        const marginRight = Number.parseInt(computedStyle.marginRight, 10);
        return menuItem.offsetWidth + marginLeft + marginRight || 0;
      };
      const calcSliceIndex = () => {
        var _a, _b;
        if (!menu.value)
          return -1;
        const items2 = Array.from((_b = (_a = menu.value) == null ? void 0 : _a.childNodes) != null ? _b : []).filter((item) => item.nodeName !== "#comment" && (item.nodeName !== "#text" || item.nodeValue));
        const computedMenuStyle = getComputedStyle(menu.value);
        const paddingLeft = Number.parseInt(computedMenuStyle.paddingLeft, 10);
        const paddingRight = Number.parseInt(computedMenuStyle.paddingRight, 10);
        const menuWidth = menu.value.clientWidth - paddingLeft - paddingRight;
        let calcWidth = 0;
        let sliceIndex2 = 0;
        items2.forEach((item, index) => {
          calcWidth += calcMenuItemWidth(item);
          if (calcWidth <= menuWidth - moreItemWidth) {
            sliceIndex2 = index + 1;
          }
        });
        return sliceIndex2 === items2.length ? -1 : sliceIndex2;
      };
      const getIndexPath = (index) => subMenus.value[index].indexPath;
      const debounce = (fn, wait = 33.34) => {
        let timer;
        return () => {
          timer && clearTimeout(timer);
          timer = setTimeout(() => {
            fn();
          }, wait);
        };
      };
      let isFirstTimeRender = true;
      const handleResize = () => {
        const el = unrefElement(subMenu);
        if (el)
          moreItemWidth = calcMenuItemWidth(el) || 64;
        if (sliceIndex.value === calcSliceIndex())
          return;
        const callback = () => {
          sliceIndex.value = -1;
          vue.nextTick(() => {
            sliceIndex.value = calcSliceIndex();
          });
        };
        isFirstTimeRender ? callback() : debounce(callback)();
        isFirstTimeRender = false;
      };
      vue.watch(() => props.defaultActive, (currentActive) => {
        if (!items.value[currentActive]) {
          activeIndex.value = "";
        }
        updateActiveIndex(currentActive);
      });
      vue.watch(() => props.collapse, (value) => {
        if (value)
          openedMenus.value = [];
      });
      vue.watch(items.value, initMenu);
      let resizeStopper;
      vue.watchEffect(() => {
        if (props.mode === "horizontal" && props.ellipsis)
          resizeStopper = useResizeObserver(menu, handleResize).stop;
        else
          resizeStopper == null ? void 0 : resizeStopper();
      });
      const mouseInChild = vue.ref(false);
      {
        const addSubMenu = (item) => {
          subMenus.value[item.index] = item;
        };
        const removeSubMenu = (item) => {
          delete subMenus.value[item.index];
        };
        const addMenuItem = (item) => {
          items.value[item.index] = item;
        };
        const removeMenuItem = (item) => {
          delete items.value[item.index];
        };
        vue.provide(MENU_INJECTION_KEY, vue.reactive({
          props,
          openedMenus,
          items,
          subMenus,
          activeIndex,
          isMenuPopup,
          addMenuItem,
          removeMenuItem,
          addSubMenu,
          removeSubMenu,
          openMenu,
          closeMenu,
          handleMenuItemClick,
          handleSubMenuClick
        }));
        vue.provide(`${SUB_MENU_INJECTION_KEY}${instance.uid}`, {
          addSubMenu,
          removeSubMenu,
          mouseInChild,
          level: 0
        });
      }
      vue.onMounted(() => {
        if (props.mode === "horizontal") {
          new Menubar(instance.vnode.el, nsMenu.namespace.value);
        }
      });
      {
        const open = (index) => {
          const { indexPath } = subMenus.value[index];
          indexPath.forEach((i) => openMenu(i, indexPath));
        };
        expose({
          open,
          close,
          updateActiveIndex,
          handleResize
        });
      }
      const ulStyle = useMenuCssVar(props, 0);
      return () => {
        var _a, _b;
        let slot = (_b = (_a = slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : [];
        const vShowMore = [];
        if (props.mode === "horizontal" && menu.value) {
          const originalSlot = flattedChildren(slot).filter((vnode) => {
            return (vnode == null ? void 0 : vnode.shapeFlag) !== 8;
          });
          const slotDefault = sliceIndex.value === -1 ? originalSlot : originalSlot.slice(0, sliceIndex.value);
          const slotMore = sliceIndex.value === -1 ? [] : originalSlot.slice(sliceIndex.value);
          if ((slotMore == null ? void 0 : slotMore.length) && props.ellipsis) {
            slot = slotDefault;
            vShowMore.push(vue.h(SubMenu, {
              ref: subMenu,
              index: "sub-menu-more",
              class: nsSubMenu.e("hide-arrow"),
              popperOffset: props.popperOffset
            }, {
              title: () => vue.h(ElIcon, {
                class: nsSubMenu.e("icon-more")
              }, {
                default: () => vue.h(props.ellipsisIcon)
              }),
              default: () => slotMore
            }));
          }
        }
        const directives = props.closeOnClickOutside ? [
          [
            ClickOutside,
            () => {
              if (!openedMenus.value.length)
                return;
              if (!mouseInChild.value) {
                openedMenus.value.forEach((openedMenu) => emit("close", openedMenu, getIndexPath(openedMenu)));
                openedMenus.value = [];
              }
            }
          ]
        ] : [];
        const vMenu = vue.withDirectives(vue.h("ul", {
          key: String(props.collapse),
          role: "menubar",
          ref: menu,
          style: ulStyle.value,
          class: {
            [nsMenu.b()]: true,
            [nsMenu.m(props.mode)]: true,
            [nsMenu.m("collapse")]: props.collapse
          }
        }, [...slot, ...vShowMore]), directives);
        if (props.collapseTransition && props.mode === "vertical") {
          return vue.h(ElMenuCollapseTransition, () => vMenu);
        }
        return vMenu;
      };
    }
  });

  const menuItemProps = buildProps({
    index: {
      type: definePropType([String, null]),
      default: null
    },
    route: {
      type: definePropType([String, Object])
    },
    disabled: Boolean
  });
  const menuItemEmits = {
    click: (item) => isString$1(item.index) && isArray$1(item.indexPath)
  };

  const COMPONENT_NAME$c = "ElMenuItem";
  const __default__$P = vue.defineComponent({
    name: COMPONENT_NAME$c
  });
  const _sfc_main$11 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$P,
    props: menuItemProps,
    emits: menuItemEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      isPropAbsent(props.index) && debugWarn(COMPONENT_NAME$c, 'Missing required prop: "index"');
      const instance = vue.getCurrentInstance();
      const rootMenu = vue.inject(MENU_INJECTION_KEY);
      const nsMenu = useNamespace("menu");
      const nsMenuItem = useNamespace("menu-item");
      if (!rootMenu)
        throwError(COMPONENT_NAME$c, "can not inject root menu");
      const { parentMenu, indexPath } = useMenu(instance, vue.toRef(props, "index"));
      const subMenu = vue.inject(`${SUB_MENU_INJECTION_KEY}${parentMenu.value.uid}`);
      if (!subMenu)
        throwError(COMPONENT_NAME$c, "can not inject sub menu");
      const active = vue.computed(() => props.index === rootMenu.activeIndex);
      const item = vue.reactive({
        index: props.index,
        indexPath,
        active
      });
      const handleClick = () => {
        if (!props.disabled) {
          rootMenu.handleMenuItemClick({
            index: props.index,
            indexPath: indexPath.value,
            route: props.route
          });
          emit("click", item);
        }
      };
      vue.onMounted(() => {
        subMenu.addSubMenu(item);
        rootMenu.addMenuItem(item);
      });
      vue.onBeforeUnmount(() => {
        subMenu.removeSubMenu(item);
        rootMenu.removeMenuItem(item);
      });
      expose({
        parentMenu,
        rootMenu,
        active,
        nsMenu,
        nsMenuItem,
        handleClick
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("li", {
          class: vue.normalizeClass([
            vue.unref(nsMenuItem).b(),
            vue.unref(nsMenuItem).is("active", vue.unref(active)),
            vue.unref(nsMenuItem).is("disabled", _ctx.disabled)
          ]),
          role: "menuitem",
          tabindex: "-1",
          onClick: handleClick
        }, [
          vue.unref(parentMenu).type.name === "ElMenu" && vue.unref(rootMenu).props.collapse && _ctx.$slots.title ? (vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
            key: 0,
            effect: vue.unref(rootMenu).props.popperEffect,
            placement: "right",
            "fallback-placements": ["left"],
            persistent: vue.unref(rootMenu).props.persistent,
            "focus-on-target": ""
          }, {
            content: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "title")
            ]),
            default: vue.withCtx(() => [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(nsMenu).be("tooltip", "trigger"))
              }, [
                vue.renderSlot(_ctx.$slots, "default")
              ], 2)
            ]),
            _: 3
          }, 8, ["effect", "persistent"])) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
            vue.renderSlot(_ctx.$slots, "default"),
            vue.renderSlot(_ctx.$slots, "title")
          ], 64))
        ], 2);
      };
    }
  });
  var MenuItem = /* @__PURE__ */ _export_sfc(_sfc_main$11, [["__file", "menu-item.vue"]]);

  const menuItemGroupProps = {
    title: String
  };

  const __default__$O = vue.defineComponent({
    name: "ElMenuItemGroup"
  });
  const _sfc_main$10 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$O,
    props: menuItemGroupProps,
    setup(__props) {
      const ns = useNamespace("menu-item-group");
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("li", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("title"))
          }, [
            !_ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
              vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
            ], 64)) : vue.renderSlot(_ctx.$slots, "title", { key: 1 })
          ], 2),
          vue.createElementVNode("ul", null, [
            vue.renderSlot(_ctx.$slots, "default")
          ])
        ], 2);
      };
    }
  });
  var MenuItemGroup = /* @__PURE__ */ _export_sfc(_sfc_main$10, [["__file", "menu-item-group.vue"]]);

  const ElMenu = withInstall(Menu, {
    MenuItem,
    MenuItemGroup,
    SubMenu
  });
  const ElMenuItem = withNoopInstall(MenuItem);
  const ElMenuItemGroup = withNoopInstall(MenuItemGroup);
  const ElSubMenu = withNoopInstall(SubMenu);

  const pageHeaderProps = buildProps({
    icon: {
      type: iconPropType,
      default: () => back_default
    },
    title: String,
    content: {
      type: String,
      default: ""
    }
  });
  const pageHeaderEmits = {
    back: () => true
  };

  const __default__$N = vue.defineComponent({
    name: "ElPageHeader"
  });
  const _sfc_main$$ = /* @__PURE__ */ vue.defineComponent({
    ...__default__$N,
    props: pageHeaderProps,
    emits: pageHeaderEmits,
    setup(__props, { emit }) {
      const { t } = useLocale();
      const ns = useNamespace("page-header");
      function handleClick() {
        emit("back");
      }
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ns).b(),
            vue.unref(ns).is("contentful", !!_ctx.$slots.default),
            {
              [vue.unref(ns).m("has-breadcrumb")]: !!_ctx.$slots.breadcrumb,
              [vue.unref(ns).m("has-extra")]: !!_ctx.$slots.extra
            }
          ])
        }, [
          _ctx.$slots.breadcrumb ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("breadcrumb"))
          }, [
            vue.renderSlot(_ctx.$slots, "breadcrumb")
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("header"))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("left"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("back")),
                role: "button",
                tabindex: "0",
                onClick: handleClick
              }, [
                _ctx.icon || _ctx.$slots.icon ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  "aria-label": _ctx.title || vue.unref(t)("el.pageHeader.title"),
                  class: vue.normalizeClass(vue.unref(ns).e("icon"))
                }, [
                  vue.renderSlot(_ctx.$slots, "icon", {}, () => [
                    _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
                      default: vue.withCtx(() => [
                        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                      ]),
                      _: 1
                    })) : vue.createCommentVNode("v-if", true)
                  ])
                ], 10, ["aria-label"])) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("title"))
                }, [
                  vue.renderSlot(_ctx.$slots, "title", {}, () => [
                    vue.createTextVNode(vue.toDisplayString(_ctx.title || vue.unref(t)("el.pageHeader.title")), 1)
                  ])
                ], 2)
              ], 2),
              vue.createVNode(vue.unref(ElDivider), { direction: "vertical" }),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("content"))
              }, [
                vue.renderSlot(_ctx.$slots, "content", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.content), 1)
                ])
              ], 2)
            ], 2),
            _ctx.$slots.extra ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("extra"))
            }, [
              vue.renderSlot(_ctx.$slots, "extra")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 2),
          _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("main"))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var PageHeader = /* @__PURE__ */ _export_sfc(_sfc_main$$, [["__file", "page-header.vue"]]);

  const ElPageHeader = withInstall(PageHeader);

  const elPaginationKey = Symbol("elPaginationKey");

  const paginationPrevProps = buildProps({
    disabled: Boolean,
    currentPage: {
      type: Number,
      default: 1
    },
    prevText: {
      type: String
    },
    prevIcon: {
      type: iconPropType
    }
  });
  const paginationPrevEmits = {
    click: (evt) => evt instanceof MouseEvent
  };

  const __default__$M = vue.defineComponent({
    name: "ElPaginationPrev"
  });
  const _sfc_main$_ = /* @__PURE__ */ vue.defineComponent({
    ...__default__$M,
    props: paginationPrevProps,
    emits: paginationPrevEmits,
    setup(__props) {
      const props = __props;
      const { t } = useLocale();
      const internalDisabled = vue.computed(() => props.disabled || props.currentPage <= 1);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("button", {
          type: "button",
          class: "btn-prev",
          disabled: vue.unref(internalDisabled),
          "aria-label": _ctx.prevText || vue.unref(t)("el.pagination.prev"),
          "aria-disabled": vue.unref(internalDisabled),
          onClick: ($event) => _ctx.$emit("click", $event)
        }, [
          _ctx.prevText ? (vue.openBlock(), vue.createElementBlock("span", { key: 0 }, vue.toDisplayString(_ctx.prevText), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
            default: vue.withCtx(() => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.prevIcon)))
            ]),
            _: 1
          }))
        ], 8, ["disabled", "aria-label", "aria-disabled", "onClick"]);
      };
    }
  });
  var Prev = /* @__PURE__ */ _export_sfc(_sfc_main$_, [["__file", "prev.vue"]]);

  const paginationNextProps = buildProps({
    disabled: Boolean,
    currentPage: {
      type: Number,
      default: 1
    },
    pageCount: {
      type: Number,
      default: 50
    },
    nextText: {
      type: String
    },
    nextIcon: {
      type: iconPropType
    }
  });

  const __default__$L = vue.defineComponent({
    name: "ElPaginationNext"
  });
  const _sfc_main$Z = /* @__PURE__ */ vue.defineComponent({
    ...__default__$L,
    props: paginationNextProps,
    emits: ["click"],
    setup(__props) {
      const props = __props;
      const { t } = useLocale();
      const internalDisabled = vue.computed(() => props.disabled || props.currentPage === props.pageCount || props.pageCount === 0);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("button", {
          type: "button",
          class: "btn-next",
          disabled: vue.unref(internalDisabled),
          "aria-label": _ctx.nextText || vue.unref(t)("el.pagination.next"),
          "aria-disabled": vue.unref(internalDisabled),
          onClick: ($event) => _ctx.$emit("click", $event)
        }, [
          _ctx.nextText ? (vue.openBlock(), vue.createElementBlock("span", { key: 0 }, vue.toDisplayString(_ctx.nextText), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
            default: vue.withCtx(() => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.nextIcon)))
            ]),
            _: 1
          }))
        ], 8, ["disabled", "aria-label", "aria-disabled", "onClick"]);
      };
    }
  });
  var Next = /* @__PURE__ */ _export_sfc(_sfc_main$Z, [["__file", "next.vue"]]);

  const defaultProps$5 = {
    label: "label",
    value: "value",
    disabled: "disabled",
    options: "options"
  };
  function useProps(props) {
    const aliasProps = vue.computed(() => ({ ...defaultProps$5, ...props.props }));
    const getLabel = (option) => get(option, aliasProps.value.label);
    const getValue = (option) => get(option, aliasProps.value.value);
    const getDisabled = (option) => get(option, aliasProps.value.disabled);
    const getOptions = (option) => get(option, aliasProps.value.options);
    return {
      aliasProps,
      getLabel,
      getValue,
      getDisabled,
      getOptions
    };
  }

  const selectGroupKey = Symbol("ElSelectGroup");
  const selectKey = Symbol("ElSelect");

  const COMPONENT_NAME$b = "ElOption";
  const optionProps = buildProps({
    value: {
      type: [String, Number, Boolean, Object],
      required: true
    },
    label: {
      type: [String, Number]
    },
    created: Boolean,
    disabled: Boolean
  });

  function useOption$1(props, states) {
    const select = vue.inject(selectKey);
    if (!select) {
      throwError(COMPONENT_NAME$b, "usage: <el-select><el-option /></el-select/>");
    }
    const selectGroup = vue.inject(selectGroupKey, { disabled: false });
    const itemSelected = vue.computed(() => {
      return contains(castArray$1(select.props.modelValue), props.value);
    });
    const limitReached = vue.computed(() => {
      var _a;
      if (select.props.multiple) {
        const modelValue = castArray$1((_a = select.props.modelValue) != null ? _a : []);
        return !itemSelected.value && modelValue.length >= select.props.multipleLimit && select.props.multipleLimit > 0;
      } else {
        return false;
      }
    });
    const currentLabel = vue.computed(() => {
      var _a;
      return (_a = props.label) != null ? _a : isObject$1(props.value) ? "" : props.value;
    });
    const currentValue = vue.computed(() => {
      return props.value || props.label || "";
    });
    const isDisabled = vue.computed(() => {
      return props.disabled || states.groupDisabled || limitReached.value;
    });
    const instance = vue.getCurrentInstance();
    const contains = (arr = [], target) => {
      if (!isObject$1(props.value)) {
        return arr && arr.includes(target);
      } else {
        const valueKey = select.props.valueKey;
        return arr && arr.some((item) => {
          return vue.toRaw(get(item, valueKey)) === get(target, valueKey);
        });
      }
    };
    const hoverItem = () => {
      if (!props.disabled && !selectGroup.disabled) {
        select.states.hoveringIndex = select.optionsArray.indexOf(instance.proxy);
      }
    };
    const updateOption = (query) => {
      const regexp = new RegExp(escapeStringRegexp(query), "i");
      states.visible = regexp.test(String(currentLabel.value)) || props.created;
    };
    vue.watch(() => currentLabel.value, () => {
      if (!props.created && !select.props.remote)
        select.setSelected();
    });
    vue.watch(() => props.value, (val, oldVal) => {
      const { remote, valueKey } = select.props;
      const shouldUpdate = remote ? val !== oldVal : !isEqual$1(val, oldVal);
      if (shouldUpdate) {
        select.onOptionDestroy(oldVal, instance.proxy);
        select.onOptionCreate(instance.proxy);
      }
      if (!props.created && !remote) {
        if (valueKey && isObject$1(val) && isObject$1(oldVal) && val[valueKey] === oldVal[valueKey]) {
          return;
        }
        select.setSelected();
      }
    });
    vue.watch(() => selectGroup.disabled, () => {
      states.groupDisabled = selectGroup.disabled;
    }, { immediate: true });
    return {
      select,
      currentLabel,
      currentValue,
      itemSelected,
      isDisabled,
      hoverItem,
      updateOption
    };
  }

  const _sfc_main$Y = vue.defineComponent({
    name: COMPONENT_NAME$b,
    componentName: COMPONENT_NAME$b,
    props: optionProps,
    setup(props) {
      const ns = useNamespace("select");
      const id = useId();
      const containerKls = vue.computed(() => [
        ns.be("dropdown", "item"),
        ns.is("disabled", vue.unref(isDisabled)),
        ns.is("selected", vue.unref(itemSelected)),
        ns.is("hovering", vue.unref(hover))
      ]);
      const states = vue.reactive({
        index: -1,
        groupDisabled: false,
        visible: true,
        hover: false
      });
      const {
        currentLabel,
        itemSelected,
        isDisabled,
        select,
        hoverItem,
        updateOption
      } = useOption$1(props, states);
      const { visible, hover } = vue.toRefs(states);
      const vm = vue.getCurrentInstance().proxy;
      select.onOptionCreate(vm);
      vue.onBeforeUnmount(() => {
        const key = vm.value;
        vue.nextTick(() => {
          const { selected: selectedOptions } = select.states;
          const doesSelected = selectedOptions.some((item) => {
            return item.value === vm.value;
          });
          if (select.states.cachedOptions.get(key) === vm && !doesSelected) {
            select.states.cachedOptions.delete(key);
          }
        });
        select.onOptionDestroy(key, vm);
      });
      function selectOptionClick() {
        if (!isDisabled.value) {
          select.handleOptionSelect(vm);
        }
      }
      return {
        ns,
        id,
        containerKls,
        currentLabel,
        itemSelected,
        isDisabled,
        select,
        visible,
        hover,
        states,
        hoverItem,
        updateOption,
        selectOptionClick
      };
    }
  });
  function _sfc_render$b(_ctx, _cache) {
    return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
      id: _ctx.id,
      class: vue.normalizeClass(_ctx.containerKls),
      role: "option",
      "aria-disabled": _ctx.isDisabled || void 0,
      "aria-selected": _ctx.itemSelected,
      onMousemove: _ctx.hoverItem,
      onClick: vue.withModifiers(_ctx.selectOptionClick, ["stop"])
    }, [
      vue.renderSlot(_ctx.$slots, "default", {}, () => [
        vue.createElementVNode("span", null, vue.toDisplayString(_ctx.currentLabel), 1)
      ])
    ], 42, ["id", "aria-disabled", "aria-selected", "onMousemove", "onClick"])), [
      [vue.vShow, _ctx.visible]
    ]);
  }
  var Option = /* @__PURE__ */ _export_sfc(_sfc_main$Y, [["render", _sfc_render$b], ["__file", "option.vue"]]);

  const _sfc_main$X = vue.defineComponent({
    name: "ElSelectDropdown",
    componentName: "ElSelectDropdown",
    setup() {
      const select = vue.inject(selectKey);
      const ns = useNamespace("select");
      const popperClass = vue.computed(() => select.props.popperClass);
      const isMultiple = vue.computed(() => select.props.multiple);
      const isFitInputWidth = vue.computed(() => select.props.fitInputWidth);
      const minWidth = vue.ref("");
      function updateMinWidth() {
        var _a;
        const offsetWidth = (_a = select.selectRef) == null ? void 0 : _a.offsetWidth;
        if (offsetWidth) {
          minWidth.value = `${offsetWidth - BORDER_HORIZONTAL_WIDTH}px`;
        } else {
          minWidth.value = "";
        }
      }
      vue.onMounted(() => {
        updateMinWidth();
        useResizeObserver(select.selectRef, updateMinWidth);
      });
      return {
        ns,
        minWidth,
        popperClass,
        isMultiple,
        isFitInputWidth
      };
    }
  });
  function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("div", {
      class: vue.normalizeClass([_ctx.ns.b("dropdown"), _ctx.ns.is("multiple", _ctx.isMultiple), _ctx.popperClass]),
      style: vue.normalizeStyle({ [_ctx.isFitInputWidth ? "width" : "minWidth"]: _ctx.minWidth })
    }, [
      _ctx.$slots.header ? (vue.openBlock(), vue.createElementBlock("div", {
        key: 0,
        class: vue.normalizeClass(_ctx.ns.be("dropdown", "header"))
      }, [
        vue.renderSlot(_ctx.$slots, "header")
      ], 2)) : vue.createCommentVNode("v-if", true),
      vue.renderSlot(_ctx.$slots, "default"),
      _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", {
        key: 1,
        class: vue.normalizeClass(_ctx.ns.be("dropdown", "footer"))
      }, [
        vue.renderSlot(_ctx.$slots, "footer")
      ], 2)) : vue.createCommentVNode("v-if", true)
    ], 6);
  }
  var ElSelectMenu$1 = /* @__PURE__ */ _export_sfc(_sfc_main$X, [["render", _sfc_render$a], ["__file", "select-dropdown.vue"]]);

  const useSelect$3 = (props, emit) => {
    const { t } = useLocale();
    const contentId = useId();
    const nsSelect = useNamespace("select");
    const nsInput = useNamespace("input");
    const states = vue.reactive({
      inputValue: "",
      options: /* @__PURE__ */ new Map(),
      cachedOptions: /* @__PURE__ */ new Map(),
      optionValues: [],
      selected: [],
      selectionWidth: 0,
      collapseItemWidth: 0,
      selectedLabel: "",
      hoveringIndex: -1,
      previousQuery: null,
      inputHovering: false,
      menuVisibleOnFocus: false,
      isBeforeHide: false
    });
    const selectRef = vue.ref();
    const selectionRef = vue.ref();
    const tooltipRef = vue.ref();
    const tagTooltipRef = vue.ref();
    const inputRef = vue.ref();
    const prefixRef = vue.ref();
    const suffixRef = vue.ref();
    const menuRef = vue.ref();
    const tagMenuRef = vue.ref();
    const collapseItemRef = vue.ref();
    const scrollbarRef = vue.ref();
    const expanded = vue.ref(false);
    const hoverOption = vue.ref();
    const debouncing = vue.ref(false);
    const { form, formItem } = useFormItem();
    const { inputId } = useFormItemInputId(props, {
      formItemContext: formItem
    });
    const { valueOnClear, isEmptyValue } = useEmptyValues(props);
    const {
      isComposing,
      handleCompositionStart,
      handleCompositionUpdate,
      handleCompositionEnd
    } = useComposition({
      afterComposition: (e) => onInput(e)
    });
    const selectDisabled = vue.computed(() => props.disabled || !!(form == null ? void 0 : form.disabled));
    const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
      disabled: selectDisabled,
      afterFocus() {
        if (props.automaticDropdown && !expanded.value) {
          expanded.value = true;
          states.menuVisibleOnFocus = true;
        }
      },
      beforeBlur(event) {
        var _a, _b;
        return ((_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
      },
      afterBlur() {
        var _a;
        expanded.value = false;
        states.menuVisibleOnFocus = false;
        if (props.validateEvent) {
          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
        }
      }
    });
    const hasModelValue = vue.computed(() => {
      return isArray$1(props.modelValue) ? props.modelValue.length > 0 : !isEmptyValue(props.modelValue);
    });
    const needStatusIcon = vue.computed(() => {
      var _a;
      return (_a = form == null ? void 0 : form.statusIcon) != null ? _a : false;
    });
    const showClearBtn = vue.computed(() => {
      return props.clearable && !selectDisabled.value && hasModelValue.value && (isFocused.value || states.inputHovering);
    });
    const iconComponent = vue.computed(() => props.remote && props.filterable && !props.remoteShowSuffix ? "" : props.suffixIcon);
    const iconReverse = vue.computed(() => nsSelect.is("reverse", !!(iconComponent.value && expanded.value)));
    const validateState = vue.computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
    const validateIcon = vue.computed(() => validateState.value && ValidateComponentsMap[validateState.value]);
    const debounce = vue.computed(() => props.remote ? props.debounce : 0);
    const isRemoteSearchEmpty = vue.computed(() => props.remote && !states.inputValue && states.options.size === 0);
    const emptyText = vue.computed(() => {
      if (props.loading) {
        return props.loadingText || t("el.select.loading");
      } else {
        if (props.filterable && states.inputValue && states.options.size > 0 && filteredOptionsCount.value === 0) {
          return props.noMatchText || t("el.select.noMatch");
        }
        if (states.options.size === 0) {
          return props.noDataText || t("el.select.noData");
        }
      }
      return null;
    });
    const filteredOptionsCount = vue.computed(() => optionsArray.value.filter((option) => option.visible).length);
    const optionsArray = vue.computed(() => {
      const list = Array.from(states.options.values());
      const newList = [];
      states.optionValues.forEach((item) => {
        const index = list.findIndex((i) => i.value === item);
        if (index > -1) {
          newList.push(list[index]);
        }
      });
      return newList.length >= list.length ? newList : list;
    });
    const cachedOptionsArray = vue.computed(() => Array.from(states.cachedOptions.values()));
    const showNewOption = vue.computed(() => {
      const hasExistingOption = optionsArray.value.filter((option) => {
        return !option.created;
      }).some((option) => {
        return option.currentLabel === states.inputValue;
      });
      return props.filterable && props.allowCreate && states.inputValue !== "" && !hasExistingOption;
    });
    const updateOptions = () => {
      if (props.filterable && isFunction$1(props.filterMethod))
        return;
      if (props.filterable && props.remote && isFunction$1(props.remoteMethod))
        return;
      optionsArray.value.forEach((option) => {
        var _a;
        (_a = option.updateOption) == null ? void 0 : _a.call(option, states.inputValue);
      });
    };
    const selectSize = useFormSize();
    const collapseTagSize = vue.computed(() => ["small"].includes(selectSize.value) ? "small" : "default");
    const dropdownMenuVisible = vue.computed({
      get() {
        return expanded.value && (props.loading || !isRemoteSearchEmpty.value) && (!debouncing.value || !isEmpty(states.previousQuery));
      },
      set(val) {
        expanded.value = val;
      }
    });
    const shouldShowPlaceholder = vue.computed(() => {
      if (props.multiple && !isUndefined(props.modelValue)) {
        return castArray$1(props.modelValue).length === 0 && !states.inputValue;
      }
      const value = isArray$1(props.modelValue) ? props.modelValue[0] : props.modelValue;
      return props.filterable || isUndefined(value) ? !states.inputValue : true;
    });
    const currentPlaceholder = vue.computed(() => {
      var _a;
      const _placeholder = (_a = props.placeholder) != null ? _a : t("el.select.placeholder");
      return props.multiple || !hasModelValue.value ? _placeholder : states.selectedLabel;
    });
    const mouseEnterEventName = vue.computed(() => isIOS ? null : "mouseenter");
    vue.watch(() => props.modelValue, (val, oldVal) => {
      if (props.multiple) {
        if (props.filterable && !props.reserveKeyword) {
          states.inputValue = "";
          handleQueryChange("");
        }
      }
      setSelected();
      if (!isEqual$1(val, oldVal) && props.validateEvent) {
        formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
      }
    }, {
      flush: "post",
      deep: true
    });
    vue.watch(() => expanded.value, (val) => {
      if (val) {
        handleQueryChange(states.inputValue);
      } else {
        states.inputValue = "";
        states.previousQuery = null;
        states.isBeforeHide = true;
      }
      emit("visible-change", val);
    });
    vue.watch(() => states.options.entries(), () => {
      if (!isClient)
        return;
      setSelected();
      if (props.defaultFirstOption && (props.filterable || props.remote) && filteredOptionsCount.value) {
        checkDefaultFirstOption();
      }
    }, {
      flush: "post"
    });
    vue.watch([() => states.hoveringIndex, optionsArray], ([val]) => {
      if (isNumber(val) && val > -1) {
        hoverOption.value = optionsArray.value[val] || {};
      } else {
        hoverOption.value = {};
      }
      optionsArray.value.forEach((option) => {
        option.hover = hoverOption.value === option;
      });
    });
    vue.watchEffect(() => {
      if (states.isBeforeHide)
        return;
      updateOptions();
    });
    const handleQueryChange = (val) => {
      if (states.previousQuery === val || isComposing.value) {
        return;
      }
      states.previousQuery = val;
      if (props.filterable && isFunction$1(props.filterMethod)) {
        props.filterMethod(val);
      } else if (props.filterable && props.remote && isFunction$1(props.remoteMethod)) {
        props.remoteMethod(val);
      }
      if (props.defaultFirstOption && (props.filterable || props.remote) && filteredOptionsCount.value) {
        vue.nextTick(checkDefaultFirstOption);
      } else {
        vue.nextTick(updateHoveringIndex);
      }
    };
    const checkDefaultFirstOption = () => {
      const optionsInDropdown = optionsArray.value.filter((n) => n.visible && !n.disabled && !n.states.groupDisabled);
      const userCreatedOption = optionsInDropdown.find((n) => n.created);
      const firstOriginOption = optionsInDropdown[0];
      const valueList = optionsArray.value.map((item) => item.value);
      states.hoveringIndex = getValueIndex(valueList, userCreatedOption || firstOriginOption);
    };
    const setSelected = () => {
      if (!props.multiple) {
        const value = isArray$1(props.modelValue) ? props.modelValue[0] : props.modelValue;
        const option = getOption(value);
        states.selectedLabel = option.currentLabel;
        states.selected = [option];
        return;
      } else {
        states.selectedLabel = "";
      }
      const result = [];
      if (!isUndefined(props.modelValue)) {
        castArray$1(props.modelValue).forEach((value) => {
          result.push(getOption(value));
        });
      }
      states.selected = result;
    };
    const getOption = (value) => {
      let option;
      const isObjectValue = isPlainObject$1(value);
      for (let i = states.cachedOptions.size - 1; i >= 0; i--) {
        const cachedOption = cachedOptionsArray.value[i];
        const isEqualValue = isObjectValue ? get(cachedOption.value, props.valueKey) === get(value, props.valueKey) : cachedOption.value === value;
        if (isEqualValue) {
          option = {
            index: optionsArray.value.filter((opt) => !opt.created).indexOf(cachedOption),
            value,
            currentLabel: cachedOption.currentLabel,
            get isDisabled() {
              return cachedOption.isDisabled;
            }
          };
          break;
        }
      }
      if (option)
        return option;
      const label = isObjectValue ? value.label : value != null ? value : "";
      const newOption = {
        index: -1,
        value,
        currentLabel: label
      };
      return newOption;
    };
    const updateHoveringIndex = () => {
      states.hoveringIndex = optionsArray.value.findIndex((item) => states.selected.some((selected) => getValueKey(selected) === getValueKey(item)));
    };
    const resetSelectionWidth = () => {
      states.selectionWidth = Number.parseFloat(window.getComputedStyle(selectionRef.value).width);
    };
    const resetCollapseItemWidth = () => {
      states.collapseItemWidth = collapseItemRef.value.getBoundingClientRect().width;
    };
    const updateTooltip = () => {
      var _a, _b;
      (_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
    };
    const updateTagTooltip = () => {
      var _a, _b;
      (_b = (_a = tagTooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
    };
    const onInputChange = () => {
      if (states.inputValue.length > 0 && !expanded.value) {
        expanded.value = true;
      }
      handleQueryChange(states.inputValue);
    };
    const onInput = (event) => {
      states.inputValue = event.target.value;
      if (props.remote) {
        debouncing.value = true;
        debouncedOnInputChange();
      } else {
        return onInputChange();
      }
    };
    const debouncedOnInputChange = useDebounceFn(() => {
      onInputChange();
      debouncing.value = false;
    }, debounce);
    const emitChange = (val) => {
      if (!isEqual$1(props.modelValue, val)) {
        emit(CHANGE_EVENT, val);
      }
    };
    const getLastNotDisabledIndex = (value) => findLastIndex(value, (it) => {
      const option = states.cachedOptions.get(it);
      return option && !option.disabled && !option.states.groupDisabled;
    });
    const deletePrevTag = (e) => {
      const code = getEventCode(e);
      if (!props.multiple)
        return;
      if (code === EVENT_CODE.delete)
        return;
      if (e.target.value.length <= 0) {
        const value = castArray$1(props.modelValue).slice();
        const lastNotDisabledIndex = getLastNotDisabledIndex(value);
        if (lastNotDisabledIndex < 0)
          return;
        const removeTagValue = value[lastNotDisabledIndex];
        value.splice(lastNotDisabledIndex, 1);
        emit(UPDATE_MODEL_EVENT, value);
        emitChange(value);
        emit("remove-tag", removeTagValue);
      }
    };
    const deleteTag = (event, tag) => {
      const index = states.selected.indexOf(tag);
      if (index > -1 && !selectDisabled.value) {
        const value = castArray$1(props.modelValue).slice();
        value.splice(index, 1);
        emit(UPDATE_MODEL_EVENT, value);
        emitChange(value);
        emit("remove-tag", tag.value);
      }
      event.stopPropagation();
      focus();
    };
    const deleteSelected = (event) => {
      event.stopPropagation();
      const value = props.multiple ? [] : valueOnClear.value;
      if (props.multiple) {
        for (const item of states.selected) {
          if (item.isDisabled)
            value.push(item.value);
        }
      }
      emit(UPDATE_MODEL_EVENT, value);
      emitChange(value);
      states.hoveringIndex = -1;
      expanded.value = false;
      emit("clear");
      focus();
    };
    const handleOptionSelect = (option) => {
      var _a;
      if (props.multiple) {
        const value = castArray$1((_a = props.modelValue) != null ? _a : []).slice();
        const optionIndex = getValueIndex(value, option);
        if (optionIndex > -1) {
          value.splice(optionIndex, 1);
        } else if (props.multipleLimit <= 0 || value.length < props.multipleLimit) {
          value.push(option.value);
        }
        emit(UPDATE_MODEL_EVENT, value);
        emitChange(value);
        if (option.created) {
          handleQueryChange("");
        }
        if (props.filterable && !props.reserveKeyword) {
          states.inputValue = "";
        }
      } else {
        !isEqual$1(props.modelValue, option.value) && emit(UPDATE_MODEL_EVENT, option.value);
        emitChange(option.value);
        expanded.value = false;
      }
      focus();
      if (expanded.value)
        return;
      vue.nextTick(() => {
        scrollToOption(option);
      });
    };
    const getValueIndex = (arr, option) => {
      if (isUndefined(option))
        return -1;
      if (!isObject$1(option.value))
        return arr.indexOf(option.value);
      return arr.findIndex((item) => {
        return isEqual$1(get(item, props.valueKey), getValueKey(option));
      });
    };
    const scrollToOption = (option) => {
      var _a, _b, _c, _d, _e;
      const targetOption = isArray$1(option) ? option[0] : option;
      let target = null;
      if (!isNil(targetOption == null ? void 0 : targetOption.value)) {
        const options = optionsArray.value.filter((item) => item.value === targetOption.value);
        if (options.length > 0) {
          target = options[0].$el;
        }
      }
      if (tooltipRef.value && target) {
        const menu = (_d = (_c = (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef) == null ? void 0 : _c.querySelector) == null ? void 0 : _d.call(_c, `.${nsSelect.be("dropdown", "wrap")}`);
        if (menu) {
          scrollIntoView(menu, target);
        }
      }
      (_e = scrollbarRef.value) == null ? void 0 : _e.handleScroll();
    };
    const onOptionCreate = (vm) => {
      states.options.set(vm.value, vm);
      states.cachedOptions.set(vm.value, vm);
    };
    const onOptionDestroy = (key, vm) => {
      if (states.options.get(key) === vm) {
        states.options.delete(key);
      }
    };
    const popperRef = vue.computed(() => {
      var _a, _b;
      return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
    });
    const handleMenuEnter = () => {
      states.isBeforeHide = false;
      vue.nextTick(() => {
        var _a;
        (_a = scrollbarRef.value) == null ? void 0 : _a.update();
        scrollToOption(states.selected);
      });
    };
    const focus = () => {
      var _a;
      (_a = inputRef.value) == null ? void 0 : _a.focus();
    };
    const blur = () => {
      var _a;
      if (expanded.value) {
        expanded.value = false;
        vue.nextTick(() => {
          var _a2;
          return (_a2 = inputRef.value) == null ? void 0 : _a2.blur();
        });
        return;
      }
      (_a = inputRef.value) == null ? void 0 : _a.blur();
    };
    const handleClearClick = (event) => {
      deleteSelected(event);
    };
    const handleClickOutside = (event) => {
      expanded.value = false;
      if (isFocused.value) {
        const _event = new FocusEvent("blur", event);
        vue.nextTick(() => handleBlur(_event));
      }
    };
    const handleEsc = () => {
      if (states.inputValue.length > 0) {
        states.inputValue = "";
      } else {
        expanded.value = false;
      }
    };
    const toggleMenu = () => {
      if (selectDisabled.value)
        return;
      if (isIOS)
        states.inputHovering = true;
      if (states.menuVisibleOnFocus) {
        states.menuVisibleOnFocus = false;
      } else {
        expanded.value = !expanded.value;
      }
    };
    const selectOption = () => {
      if (!expanded.value) {
        toggleMenu();
      } else {
        const option = optionsArray.value[states.hoveringIndex];
        if (option && !option.isDisabled) {
          handleOptionSelect(option);
        }
      }
    };
    const getValueKey = (item) => {
      return isObject$1(item.value) ? get(item.value, props.valueKey) : item.value;
    };
    const optionsAllDisabled = vue.computed(() => optionsArray.value.filter((option) => option.visible).every((option) => option.isDisabled));
    const showTagList = vue.computed(() => {
      if (!props.multiple) {
        return [];
      }
      return props.collapseTags ? states.selected.slice(0, props.maxCollapseTags) : states.selected;
    });
    const collapseTagList = vue.computed(() => {
      if (!props.multiple) {
        return [];
      }
      return props.collapseTags ? states.selected.slice(props.maxCollapseTags) : [];
    });
    const navigateOptions = (direction) => {
      if (!expanded.value) {
        expanded.value = true;
        return;
      }
      if (states.options.size === 0 || filteredOptionsCount.value === 0 || isComposing.value)
        return;
      if (!optionsAllDisabled.value) {
        if (direction === "next") {
          states.hoveringIndex++;
          if (states.hoveringIndex === states.options.size) {
            states.hoveringIndex = 0;
          }
        } else if (direction === "prev") {
          states.hoveringIndex--;
          if (states.hoveringIndex < 0) {
            states.hoveringIndex = states.options.size - 1;
          }
        }
        const option = optionsArray.value[states.hoveringIndex];
        if (option.isDisabled || !option.visible) {
          navigateOptions(direction);
        }
        vue.nextTick(() => scrollToOption(hoverOption.value));
      }
    };
    const findFocusableIndex = (arr, start, step, len) => {
      for (let i = start; i >= 0 && i < len; i += step) {
        const obj = arr[i];
        if (!(obj == null ? void 0 : obj.isDisabled) && (obj == null ? void 0 : obj.visible)) {
          return i;
        }
      }
      return null;
    };
    const focusOption = (targetIndex, mode) => {
      var _a;
      const len = states.options.size;
      if (len === 0)
        return;
      const start = clamp$1(targetIndex, 0, len - 1);
      const options = optionsArray.value;
      const direction = mode === "up" ? -1 : 1;
      const newIndex = (_a = findFocusableIndex(options, start, direction, len)) != null ? _a : findFocusableIndex(options, start - direction, -direction, len);
      if (newIndex != null) {
        states.hoveringIndex = newIndex;
        vue.nextTick(() => scrollToOption(hoverOption.value));
      }
    };
    const handleKeydown = (e) => {
      const code = getEventCode(e);
      let isPreventDefault = true;
      switch (code) {
        case EVENT_CODE.up:
          navigateOptions("prev");
          break;
        case EVENT_CODE.down:
          navigateOptions("next");
          break;
        case EVENT_CODE.enter:
          selectOption();
          break;
        case EVENT_CODE.esc:
          handleEsc();
          break;
        case EVENT_CODE.backspace:
          isPreventDefault = false;
          deletePrevTag(e);
          return;
        case EVENT_CODE.home:
          if (!expanded.value)
            return;
          focusOption(0, "down");
          break;
        case EVENT_CODE.end:
          if (!expanded.value)
            return;
          focusOption(states.options.size - 1, "up");
          break;
        case EVENT_CODE.pageUp:
          if (!expanded.value)
            return;
          focusOption(states.hoveringIndex - 10, "up");
          break;
        case EVENT_CODE.pageDown:
          if (!expanded.value)
            return;
          focusOption(states.hoveringIndex + 10, "down");
          break;
        default:
          isPreventDefault = false;
          break;
      }
      if (isPreventDefault) {
        e.preventDefault();
        e.stopPropagation();
      }
    };
    const getGapWidth = () => {
      if (!selectionRef.value)
        return 0;
      const style = window.getComputedStyle(selectionRef.value);
      return Number.parseFloat(style.gap || "6px");
    };
    const tagStyle = vue.computed(() => {
      const gapWidth = getGapWidth();
      const inputSlotWidth = props.filterable ? gapWidth + MINIMUM_INPUT_WIDTH : 0;
      const maxWidth = collapseItemRef.value && props.maxCollapseTags === 1 ? states.selectionWidth - states.collapseItemWidth - gapWidth - inputSlotWidth : states.selectionWidth - inputSlotWidth;
      return { maxWidth: `${maxWidth}px` };
    });
    const collapseTagStyle = vue.computed(() => {
      return { maxWidth: `${states.selectionWidth}px` };
    });
    const popupScroll = (data) => {
      emit("popup-scroll", data);
    };
    useResizeObserver(selectionRef, resetSelectionWidth);
    useResizeObserver(wrapperRef, updateTooltip);
    useResizeObserver(tagMenuRef, updateTagTooltip);
    useResizeObserver(collapseItemRef, resetCollapseItemWidth);
    let stop;
    vue.watch(() => dropdownMenuVisible.value, (newVal) => {
      if (newVal) {
        stop = useResizeObserver(menuRef, updateTooltip).stop;
      } else {
        stop == null ? void 0 : stop();
        stop = void 0;
      }
    });
    vue.onMounted(() => {
      setSelected();
    });
    return {
      inputId,
      contentId,
      nsSelect,
      nsInput,
      states,
      isFocused,
      expanded,
      optionsArray,
      hoverOption,
      selectSize,
      filteredOptionsCount,
      updateTooltip,
      updateTagTooltip,
      debouncedOnInputChange,
      onInput,
      deletePrevTag,
      deleteTag,
      deleteSelected,
      handleOptionSelect,
      scrollToOption,
      hasModelValue,
      shouldShowPlaceholder,
      currentPlaceholder,
      mouseEnterEventName,
      needStatusIcon,
      showClearBtn,
      iconComponent,
      iconReverse,
      validateState,
      validateIcon,
      showNewOption,
      updateOptions,
      collapseTagSize,
      setSelected,
      selectDisabled,
      emptyText,
      handleCompositionStart,
      handleCompositionUpdate,
      handleCompositionEnd,
      handleKeydown,
      onOptionCreate,
      onOptionDestroy,
      handleMenuEnter,
      focus,
      blur,
      handleClearClick,
      handleClickOutside,
      handleEsc,
      toggleMenu,
      selectOption,
      getValueKey,
      navigateOptions,
      dropdownMenuVisible,
      showTagList,
      collapseTagList,
      popupScroll,
      getOption,
      tagStyle,
      collapseTagStyle,
      popperRef,
      inputRef,
      tooltipRef,
      tagTooltipRef,
      prefixRef,
      suffixRef,
      selectRef,
      wrapperRef,
      selectionRef,
      scrollbarRef,
      menuRef,
      tagMenuRef,
      collapseItemRef
    };
  };

  var ElOptions = vue.defineComponent({
    name: "ElOptions",
    setup(_, { slots }) {
      const select = vue.inject(selectKey);
      let cachedValueList = [];
      return () => {
        var _a, _b;
        const children = (_a = slots.default) == null ? void 0 : _a.call(slots);
        const valueList = [];
        function filterOptions(children2) {
          if (!isArray$1(children2))
            return;
          children2.forEach((item) => {
            var _a2, _b2, _c, _d;
            const name = (_a2 = (item == null ? void 0 : item.type) || {}) == null ? void 0 : _a2.name;
            if (name === "ElOptionGroup") {
              filterOptions(!isString$1(item.children) && !isArray$1(item.children) && isFunction$1((_b2 = item.children) == null ? void 0 : _b2.default) ? (_c = item.children) == null ? void 0 : _c.default() : item.children);
            } else if (name === "ElOption") {
              valueList.push((_d = item.props) == null ? void 0 : _d.value);
            } else if (isArray$1(item.children)) {
              filterOptions(item.children);
            }
          });
        }
        if (children.length) {
          filterOptions((_b = children[0]) == null ? void 0 : _b.children);
        }
        if (!isEqual$1(valueList, cachedValueList)) {
          cachedValueList = valueList;
          if (select) {
            select.states.optionValues = valueList;
          }
        }
        return children;
      };
    }
  });

  const selectProps = buildProps({
    name: String,
    id: String,
    modelValue: {
      type: definePropType([
        Array,
        String,
        Number,
        Boolean,
        Object
      ]),
      default: void 0
    },
    autocomplete: {
      type: String,
      default: "off"
    },
    automaticDropdown: Boolean,
    size: useSizeProp,
    effect: {
      type: definePropType(String),
      default: "light"
    },
    disabled: Boolean,
    clearable: Boolean,
    filterable: Boolean,
    allowCreate: Boolean,
    loading: Boolean,
    popperClass: {
      type: String,
      default: ""
    },
    popperStyle: {
      type: definePropType([String, Object])
    },
    popperOptions: {
      type: definePropType(Object),
      default: () => ({})
    },
    remote: Boolean,
    debounce: {
      type: Number,
      default: 300
    },
    loadingText: String,
    noMatchText: String,
    noDataText: String,
    remoteMethod: {
      type: definePropType(Function)
    },
    filterMethod: {
      type: definePropType(Function)
    },
    multiple: Boolean,
    multipleLimit: {
      type: Number,
      default: 0
    },
    placeholder: {
      type: String
    },
    defaultFirstOption: Boolean,
    reserveKeyword: {
      type: Boolean,
      default: true
    },
    valueKey: {
      type: String,
      default: "value"
    },
    collapseTags: Boolean,
    collapseTagsTooltip: Boolean,
    maxCollapseTags: {
      type: Number,
      default: 1
    },
    teleported: useTooltipContentProps.teleported,
    persistent: {
      type: Boolean,
      default: true
    },
    clearIcon: {
      type: iconPropType,
      default: circle_close_default
    },
    fitInputWidth: Boolean,
    suffixIcon: {
      type: iconPropType,
      default: arrow_down_default
    },
    tagType: { ...tagProps.type, default: "info" },
    tagEffect: { ...tagProps.effect, default: "light" },
    validateEvent: {
      type: Boolean,
      default: true
    },
    remoteShowSuffix: Boolean,
    showArrow: {
      type: Boolean,
      default: true
    },
    offset: {
      type: Number,
      default: 12
    },
    placement: {
      type: definePropType(String),
      values: Ee,
      default: "bottom-start"
    },
    fallbackPlacements: {
      type: definePropType(Array),
      default: ["bottom-start", "top-start", "right", "left"]
    },
    tabindex: {
      type: [String, Number],
      default: 0
    },
    appendTo: useTooltipContentProps.appendTo,
    options: {
      type: definePropType(Array)
    },
    props: {
      type: definePropType(Object),
      default: () => defaultProps$5
    },
    ...useEmptyValuesProps,
    ...useAriaProps(["ariaLabel"])
  });
  const selectEmits = {
    [UPDATE_MODEL_EVENT]: (val) => true,
    [CHANGE_EVENT]: (val) => true,
    "popup-scroll": scrollbarEmits.scroll,
    "remove-tag": (val) => true,
    "visible-change": (visible) => true,
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent,
    clear: () => true
  };

  const _sfc_main$W = vue.defineComponent({
    name: "ElOptionGroup",
    componentName: "ElOptionGroup",
    props: {
      label: String,
      disabled: Boolean
    },
    setup(props) {
      const ns = useNamespace("select");
      const groupRef = vue.ref();
      const instance = vue.getCurrentInstance();
      const children = vue.ref([]);
      vue.provide(selectGroupKey, vue.reactive({
        ...vue.toRefs(props)
      }));
      const visible = vue.computed(() => children.value.some((option) => option.visible === true));
      const isOption = (node) => {
        var _a;
        return node.type.name === "ElOption" && !!((_a = node.component) == null ? void 0 : _a.proxy);
      };
      const flattedChildren = (node) => {
        const nodes = castArray$1(node);
        const children2 = [];
        nodes.forEach((child) => {
          var _a;
          if (!vue.isVNode(child))
            return;
          if (isOption(child)) {
            children2.push(child.component.proxy);
          } else if (isArray$1(child.children) && child.children.length) {
            children2.push(...flattedChildren(child.children));
          } else if ((_a = child.component) == null ? void 0 : _a.subTree) {
            children2.push(...flattedChildren(child.component.subTree));
          }
        });
        return children2;
      };
      const updateChildren = () => {
        children.value = flattedChildren(instance.subTree);
      };
      vue.onMounted(() => {
        updateChildren();
      });
      useMutationObserver(groupRef, updateChildren, {
        attributes: true,
        subtree: true,
        childList: true
      });
      return {
        groupRef,
        visible,
        ns
      };
    }
  });
  function _sfc_render$9(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.withDirectives((vue.openBlock(), vue.createElementBlock("ul", {
      ref: "groupRef",
      class: vue.normalizeClass(_ctx.ns.be("group", "wrap"))
    }, [
      vue.createElementVNode("li", {
        class: vue.normalizeClass(_ctx.ns.be("group", "title"))
      }, vue.toDisplayString(_ctx.label), 3),
      vue.createElementVNode("li", null, [
        vue.createElementVNode("ul", {
          class: vue.normalizeClass(_ctx.ns.b("group"))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2)
      ])
    ], 2)), [
      [vue.vShow, _ctx.visible]
    ]);
  }
  var OptionGroup = /* @__PURE__ */ _export_sfc(_sfc_main$W, [["render", _sfc_render$9], ["__file", "option-group.vue"]]);

  const COMPONENT_NAME$a = "ElSelect";
  const _sfc_main$V = vue.defineComponent({
    name: COMPONENT_NAME$a,
    componentName: COMPONENT_NAME$a,
    components: {
      ElSelectMenu: ElSelectMenu$1,
      ElOption: Option,
      ElOptions,
      ElOptionGroup: OptionGroup,
      ElTag,
      ElScrollbar,
      ElTooltip,
      ElIcon
    },
    directives: { ClickOutside },
    props: selectProps,
    emits: [
      UPDATE_MODEL_EVENT,
      CHANGE_EVENT,
      "remove-tag",
      "clear",
      "visible-change",
      "focus",
      "blur",
      "popup-scroll"
    ],
    setup(props, { emit, slots }) {
      const instance = vue.getCurrentInstance();
      const originalWarnHandler = instance.appContext.config.warnHandler;
      instance.appContext.config.warnHandler = (...args) => {
        if (!args[0] || args[0].includes('Slot "default" invoked outside of the render function')) {
          return;
        }
        console.warn(...args);
      };
      const modelValue = vue.computed(() => {
        const { modelValue: rawModelValue, multiple } = props;
        const fallback = multiple ? [] : void 0;
        if (isArray$1(rawModelValue)) {
          return multiple ? rawModelValue : fallback;
        }
        return multiple ? fallback : rawModelValue;
      });
      const _props = vue.reactive({
        ...vue.toRefs(props),
        modelValue
      });
      const API = useSelect$3(_props, emit);
      const { calculatorRef, inputStyle } = useCalcInputWidth();
      const { getLabel, getValue, getOptions, getDisabled } = useProps(props);
      const getOptionProps = (option) => ({
        label: getLabel(option),
        value: getValue(option),
        disabled: getDisabled(option)
      });
      const flatTreeSelectData = (data) => {
        return data.reduce((acc, item) => {
          acc.push(item);
          if (item.children && item.children.length > 0) {
            acc.push(...flatTreeSelectData(item.children));
          }
          return acc;
        }, []);
      };
      const manuallyRenderSlots = (vnodes) => {
        const children = flattedChildren(vnodes || []);
        children.forEach((item) => {
          var _a;
          if (isObject$1(item) && (item.type.name === "ElOption" || item.type.name === "ElTree")) {
            const _name = item.type.name;
            if (_name === "ElTree") {
              const treeData = ((_a = item.props) == null ? void 0 : _a.data) || [];
              const flatData = flatTreeSelectData(treeData);
              flatData.forEach((treeItem) => {
                treeItem.currentLabel = treeItem.label || (isObject$1(treeItem.value) ? "" : treeItem.value);
                API.onOptionCreate(treeItem);
              });
            } else if (_name === "ElOption") {
              const obj = { ...item.props };
              obj.currentLabel = obj.label || (isObject$1(obj.value) ? "" : obj.value);
              API.onOptionCreate(obj);
            }
          }
        });
      };
      vue.watch(() => {
        var _a;
        return [(_a = slots.default) == null ? void 0 : _a.call(slots), modelValue.value];
      }, () => {
        var _a;
        if (props.persistent || API.states.options.size > 0) {
          return;
        }
        manuallyRenderSlots((_a = slots.default) == null ? void 0 : _a.call(slots));
      }, {
        immediate: true
      });
      vue.provide(selectKey, vue.reactive({
        props: _props,
        states: API.states,
        selectRef: API.selectRef,
        optionsArray: API.optionsArray,
        setSelected: API.setSelected,
        handleOptionSelect: API.handleOptionSelect,
        onOptionCreate: API.onOptionCreate,
        onOptionDestroy: API.onOptionDestroy
      }));
      const selectedLabel = vue.computed(() => {
        if (!props.multiple) {
          return API.states.selectedLabel;
        }
        return API.states.selected.map((i) => i.currentLabel);
      });
      vue.onBeforeUnmount(() => {
        instance.appContext.config.warnHandler = originalWarnHandler;
      });
      return {
        ...API,
        modelValue,
        selectedLabel,
        calculatorRef,
        inputStyle,
        getLabel,
        getValue,
        getOptions,
        getDisabled,
        getOptionProps
      };
    }
  });
  function _sfc_render$8(_ctx, _cache) {
    const _component_el_tag = vue.resolveComponent("el-tag");
    const _component_el_tooltip = vue.resolveComponent("el-tooltip");
    const _component_el_icon = vue.resolveComponent("el-icon");
    const _component_el_option = vue.resolveComponent("el-option");
    const _component_el_option_group = vue.resolveComponent("el-option-group");
    const _component_el_options = vue.resolveComponent("el-options");
    const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
    const _component_el_select_menu = vue.resolveComponent("el-select-menu");
    const _directive_click_outside = vue.resolveDirective("click-outside");
    return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
      ref: "selectRef",
      class: vue.normalizeClass([_ctx.nsSelect.b(), _ctx.nsSelect.m(_ctx.selectSize)]),
      [vue.toHandlerKey(_ctx.mouseEnterEventName)]: ($event) => _ctx.states.inputHovering = true,
      onMouseleave: ($event) => _ctx.states.inputHovering = false
    }, [
      vue.createVNode(_component_el_tooltip, {
        ref: "tooltipRef",
        visible: _ctx.dropdownMenuVisible,
        placement: _ctx.placement,
        teleported: _ctx.teleported,
        "popper-class": [_ctx.nsSelect.e("popper"), _ctx.popperClass],
        "popper-style": _ctx.popperStyle,
        "popper-options": _ctx.popperOptions,
        "fallback-placements": _ctx.fallbackPlacements,
        effect: _ctx.effect,
        pure: "",
        trigger: "click",
        transition: `${_ctx.nsSelect.namespace.value}-zoom-in-top`,
        "stop-popper-mouse-event": false,
        "gpu-acceleration": false,
        persistent: _ctx.persistent,
        "append-to": _ctx.appendTo,
        "show-arrow": _ctx.showArrow,
        offset: _ctx.offset,
        onBeforeShow: _ctx.handleMenuEnter,
        onHide: ($event) => _ctx.states.isBeforeHide = false
      }, {
        default: vue.withCtx(() => {
          var _a;
          return [
            vue.createElementVNode("div", {
              ref: "wrapperRef",
              class: vue.normalizeClass([
                _ctx.nsSelect.e("wrapper"),
                _ctx.nsSelect.is("focused", _ctx.isFocused),
                _ctx.nsSelect.is("hovering", _ctx.states.inputHovering),
                _ctx.nsSelect.is("filterable", _ctx.filterable),
                _ctx.nsSelect.is("disabled", _ctx.selectDisabled)
              ]),
              onClick: vue.withModifiers(_ctx.toggleMenu, ["prevent"])
            }, [
              _ctx.$slots.prefix ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                ref: "prefixRef",
                class: vue.normalizeClass(_ctx.nsSelect.e("prefix"))
              }, [
                vue.renderSlot(_ctx.$slots, "prefix")
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                ref: "selectionRef",
                class: vue.normalizeClass([
                  _ctx.nsSelect.e("selection"),
                  _ctx.nsSelect.is("near", _ctx.multiple && !_ctx.$slots.prefix && !!_ctx.states.selected.length)
                ])
              }, [
                _ctx.multiple ? vue.renderSlot(_ctx.$slots, "tag", {
                  key: 0,
                  data: _ctx.states.selected,
                  deleteTag: _ctx.deleteTag,
                  selectDisabled: _ctx.selectDisabled
                }, () => [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.showTagList, (item) => {
                    return vue.openBlock(), vue.createElementBlock("div", {
                      key: _ctx.getValueKey(item),
                      class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
                    }, [
                      vue.createVNode(_component_el_tag, {
                        closable: !_ctx.selectDisabled && !item.isDisabled,
                        size: _ctx.collapseTagSize,
                        type: _ctx.tagType,
                        effect: _ctx.tagEffect,
                        "disable-transitions": "",
                        style: vue.normalizeStyle(_ctx.tagStyle),
                        onClose: ($event) => _ctx.deleteTag($event, item)
                      }, {
                        default: vue.withCtx(() => [
                          vue.createElementVNode("span", {
                            class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                          }, [
                            vue.renderSlot(_ctx.$slots, "label", {
                              index: item.index,
                              label: item.currentLabel,
                              value: item.value
                            }, () => [
                              vue.createTextVNode(vue.toDisplayString(item.currentLabel), 1)
                            ])
                          ], 2)
                        ]),
                        _: 2
                      }, 1032, ["closable", "size", "type", "effect", "style", "onClose"])
                    ], 2);
                  }), 128)),
                  _ctx.collapseTags && _ctx.states.selected.length > _ctx.maxCollapseTags ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
                    key: 0,
                    ref: "tagTooltipRef",
                    disabled: _ctx.dropdownMenuVisible || !_ctx.collapseTagsTooltip,
                    "fallback-placements": ["bottom", "top", "right", "left"],
                    effect: _ctx.effect,
                    placement: "bottom",
                    "popper-class": _ctx.popperClass,
                    "popper-style": _ctx.popperStyle,
                    teleported: _ctx.teleported
                  }, {
                    default: vue.withCtx(() => [
                      vue.createElementVNode("div", {
                        ref: "collapseItemRef",
                        class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
                      }, [
                        vue.createVNode(_component_el_tag, {
                          closable: false,
                          size: _ctx.collapseTagSize,
                          type: _ctx.tagType,
                          effect: _ctx.tagEffect,
                          "disable-transitions": "",
                          style: vue.normalizeStyle(_ctx.collapseTagStyle)
                        }, {
                          default: vue.withCtx(() => [
                            vue.createElementVNode("span", {
                              class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                            }, " + " + vue.toDisplayString(_ctx.states.selected.length - _ctx.maxCollapseTags), 3)
                          ]),
                          _: 1
                        }, 8, ["size", "type", "effect", "style"])
                      ], 2)
                    ]),
                    content: vue.withCtx(() => [
                      vue.createElementVNode("div", {
                        ref: "tagMenuRef",
                        class: vue.normalizeClass(_ctx.nsSelect.e("selection"))
                      }, [
                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.collapseTagList, (item) => {
                          return vue.openBlock(), vue.createElementBlock("div", {
                            key: _ctx.getValueKey(item),
                            class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
                          }, [
                            vue.createVNode(_component_el_tag, {
                              class: "in-tooltip",
                              closable: !_ctx.selectDisabled && !item.isDisabled,
                              size: _ctx.collapseTagSize,
                              type: _ctx.tagType,
                              effect: _ctx.tagEffect,
                              "disable-transitions": "",
                              onClose: ($event) => _ctx.deleteTag($event, item)
                            }, {
                              default: vue.withCtx(() => [
                                vue.createElementVNode("span", {
                                  class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                                }, [
                                  vue.renderSlot(_ctx.$slots, "label", {
                                    index: item.index,
                                    label: item.currentLabel,
                                    value: item.value
                                  }, () => [
                                    vue.createTextVNode(vue.toDisplayString(item.currentLabel), 1)
                                  ])
                                ], 2)
                              ]),
                              _: 2
                            }, 1032, ["closable", "size", "type", "effect", "onClose"])
                          ], 2);
                        }), 128))
                      ], 2)
                    ]),
                    _: 3
                  }, 8, ["disabled", "effect", "popper-class", "popper-style", "teleported"])) : vue.createCommentVNode("v-if", true)
                ]) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([
                    _ctx.nsSelect.e("selected-item"),
                    _ctx.nsSelect.e("input-wrapper"),
                    _ctx.nsSelect.is("hidden", !_ctx.filterable)
                  ])
                }, [
                  vue.withDirectives(vue.createElementVNode("input", {
                    id: _ctx.inputId,
                    ref: "inputRef",
                    "onUpdate:modelValue": ($event) => _ctx.states.inputValue = $event,
                    type: "text",
                    name: _ctx.name,
                    class: vue.normalizeClass([_ctx.nsSelect.e("input"), _ctx.nsSelect.is(_ctx.selectSize)]),
                    disabled: _ctx.selectDisabled,
                    autocomplete: _ctx.autocomplete,
                    style: vue.normalizeStyle(_ctx.inputStyle),
                    tabindex: _ctx.tabindex,
                    role: "combobox",
                    readonly: !_ctx.filterable,
                    spellcheck: "false",
                    "aria-activedescendant": ((_a = _ctx.hoverOption) == null ? void 0 : _a.id) || "",
                    "aria-controls": _ctx.contentId,
                    "aria-expanded": _ctx.dropdownMenuVisible,
                    "aria-label": _ctx.ariaLabel,
                    "aria-autocomplete": "none",
                    "aria-haspopup": "listbox",
                    onKeydown: _ctx.handleKeydown,
                    onCompositionstart: _ctx.handleCompositionStart,
                    onCompositionupdate: _ctx.handleCompositionUpdate,
                    onCompositionend: _ctx.handleCompositionEnd,
                    onInput: _ctx.onInput,
                    onClick: vue.withModifiers(_ctx.toggleMenu, ["stop"])
                  }, null, 46, ["id", "onUpdate:modelValue", "name", "disabled", "autocomplete", "tabindex", "readonly", "aria-activedescendant", "aria-controls", "aria-expanded", "aria-label", "onKeydown", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onInput", "onClick"]), [
                    [vue.vModelText, _ctx.states.inputValue]
                  ]),
                  _ctx.filterable ? (vue.openBlock(), vue.createElementBlock("span", {
                    key: 0,
                    ref: "calculatorRef",
                    "aria-hidden": "true",
                    class: vue.normalizeClass(_ctx.nsSelect.e("input-calculator")),
                    textContent: vue.toDisplayString(_ctx.states.inputValue)
                  }, null, 10, ["textContent"])) : vue.createCommentVNode("v-if", true)
                ], 2),
                _ctx.shouldShowPlaceholder ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 1,
                  class: vue.normalizeClass([
                    _ctx.nsSelect.e("selected-item"),
                    _ctx.nsSelect.e("placeholder"),
                    _ctx.nsSelect.is("transparent", !_ctx.hasModelValue || _ctx.expanded && !_ctx.states.inputValue)
                  ])
                }, [
                  _ctx.hasModelValue ? vue.renderSlot(_ctx.$slots, "label", {
                    key: 0,
                    index: _ctx.getOption(_ctx.modelValue).index,
                    label: _ctx.currentPlaceholder,
                    value: _ctx.modelValue
                  }, () => [
                    vue.createElementVNode("span", null, vue.toDisplayString(_ctx.currentPlaceholder), 1)
                  ]) : (vue.openBlock(), vue.createElementBlock("span", { key: 1 }, vue.toDisplayString(_ctx.currentPlaceholder), 1))
                ], 2)) : vue.createCommentVNode("v-if", true)
              ], 2),
              vue.createElementVNode("div", {
                ref: "suffixRef",
                class: vue.normalizeClass(_ctx.nsSelect.e("suffix"))
              }, [
                _ctx.iconComponent && !_ctx.showClearBtn ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: 0,
                  class: vue.normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsSelect.e("icon"), _ctx.iconReverse])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                _ctx.showClearBtn && _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: 1,
                  class: vue.normalizeClass([
                    _ctx.nsSelect.e("caret"),
                    _ctx.nsSelect.e("icon"),
                    _ctx.nsSelect.e("clear")
                  ]),
                  onClick: _ctx.handleClearClick
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
                _ctx.validateState && _ctx.validateIcon && _ctx.needStatusIcon ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: 2,
                  class: vue.normalizeClass([
                    _ctx.nsInput.e("icon"),
                    _ctx.nsInput.e("validateIcon"),
                    _ctx.nsInput.is("loading", _ctx.validateState === "validating")
                  ])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.validateIcon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
              ], 2)
            ], 10, ["onClick"])
          ];
        }),
        content: vue.withCtx(() => [
          vue.createVNode(_component_el_select_menu, { ref: "menuRef" }, {
            default: vue.withCtx(() => [
              _ctx.$slots.header ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "header")),
                onClick: vue.withModifiers(() => {
                }, ["stop"])
              }, [
                vue.renderSlot(_ctx.$slots, "header")
              ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true),
              vue.withDirectives(vue.createVNode(_component_el_scrollbar, {
                id: _ctx.contentId,
                ref: "scrollbarRef",
                tag: "ul",
                "wrap-class": _ctx.nsSelect.be("dropdown", "wrap"),
                "view-class": _ctx.nsSelect.be("dropdown", "list"),
                class: vue.normalizeClass([_ctx.nsSelect.is("empty", _ctx.filteredOptionsCount === 0)]),
                role: "listbox",
                "aria-label": _ctx.ariaLabel,
                "aria-orientation": "vertical",
                onScroll: _ctx.popupScroll
              }, {
                default: vue.withCtx(() => [
                  _ctx.showNewOption ? (vue.openBlock(), vue.createBlock(_component_el_option, {
                    key: 0,
                    value: _ctx.states.inputValue,
                    created: true
                  }, null, 8, ["value"])) : vue.createCommentVNode("v-if", true),
                  vue.createVNode(_component_el_options, null, {
                    default: vue.withCtx(() => [
                      vue.renderSlot(_ctx.$slots, "default", {}, () => [
                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.options, (option, index) => {
                          var _a;
                          return vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: index }, [
                            ((_a = _ctx.getOptions(option)) == null ? void 0 : _a.length) ? (vue.openBlock(), vue.createBlock(_component_el_option_group, {
                              key: 0,
                              label: _ctx.getLabel(option),
                              disabled: _ctx.getDisabled(option)
                            }, {
                              default: vue.withCtx(() => [
                                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.getOptions(option), (item) => {
                                  return vue.openBlock(), vue.createBlock(_component_el_option, vue.mergeProps({
                                    key: _ctx.getValue(item)
                                  }, _ctx.getOptionProps(item)), null, 16);
                                }), 128))
                              ]),
                              _: 2
                            }, 1032, ["label", "disabled"])) : (vue.openBlock(), vue.createBlock(_component_el_option, vue.normalizeProps(vue.mergeProps({ key: 1 }, _ctx.getOptionProps(option))), null, 16))
                          ], 64);
                        }), 128))
                      ])
                    ]),
                    _: 3
                  })
                ]),
                _: 3
              }, 8, ["id", "wrap-class", "view-class", "class", "aria-label", "onScroll"]), [
                [vue.vShow, _ctx.states.options.size > 0 && !_ctx.loading]
              ]),
              _ctx.$slots.loading && _ctx.loading ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "loading"))
              }, [
                vue.renderSlot(_ctx.$slots, "loading")
              ], 2)) : _ctx.loading || _ctx.filteredOptionsCount === 0 ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 2,
                class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "empty"))
              }, [
                vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                  vue.createElementVNode("span", null, vue.toDisplayString(_ctx.emptyText), 1)
                ])
              ], 2)) : vue.createCommentVNode("v-if", true),
              _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 3,
                class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "footer")),
                onClick: vue.withModifiers(() => {
                }, ["stop"])
              }, [
                vue.renderSlot(_ctx.$slots, "footer")
              ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 512)
        ]),
        _: 3
      }, 8, ["visible", "placement", "teleported", "popper-class", "popper-style", "popper-options", "fallback-placements", "effect", "transition", "persistent", "append-to", "show-arrow", "offset", "onBeforeShow", "onHide"])
    ], 16, ["onMouseleave"])), [
      [_directive_click_outside, _ctx.handleClickOutside, _ctx.popperRef]
    ]);
  }
  var Select$1 = /* @__PURE__ */ _export_sfc(_sfc_main$V, [["render", _sfc_render$8], ["__file", "select.vue"]]);

  const ElSelect = withInstall(Select$1, {
    Option,
    OptionGroup
  });
  const ElOption = withNoopInstall(Option);
  const ElOptionGroup = withNoopInstall(OptionGroup);

  const usePagination = () => vue.inject(elPaginationKey, {});

  const paginationSizesProps = buildProps({
    pageSize: {
      type: Number,
      required: true
    },
    pageSizes: {
      type: definePropType(Array),
      default: () => mutable([10, 20, 30, 40, 50, 100])
    },
    popperClass: {
      type: String
    },
    popperStyle: {
      type: definePropType([String, Object])
    },
    disabled: Boolean,
    teleported: Boolean,
    size: {
      type: String,
      values: componentSizes
    },
    appendSizeTo: String
  });

  const __default__$K = vue.defineComponent({
    name: "ElPaginationSizes"
  });
  const _sfc_main$U = /* @__PURE__ */ vue.defineComponent({
    ...__default__$K,
    props: paginationSizesProps,
    emits: ["page-size-change"],
    setup(__props, { emit }) {
      const props = __props;
      const { t } = useLocale();
      const ns = useNamespace("pagination");
      const pagination = usePagination();
      const innerPageSize = vue.ref(props.pageSize);
      vue.watch(() => props.pageSizes, (newVal, oldVal) => {
        if (isEqual$1(newVal, oldVal))
          return;
        if (isArray$1(newVal)) {
          const pageSize = newVal.includes(props.pageSize) ? props.pageSize : props.pageSizes[0];
          emit("page-size-change", pageSize);
        }
      });
      vue.watch(() => props.pageSize, (newVal) => {
        innerPageSize.value = newVal;
      });
      const innerPageSizes = vue.computed(() => props.pageSizes);
      function handleChange(val) {
        var _a;
        if (val !== innerPageSize.value) {
          innerPageSize.value = val;
          (_a = pagination.handleSizeChange) == null ? void 0 : _a.call(pagination, Number(val));
        }
      }
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("span", {
          class: vue.normalizeClass(vue.unref(ns).e("sizes"))
        }, [
          vue.createVNode(vue.unref(ElSelect), {
            "model-value": innerPageSize.value,
            disabled: _ctx.disabled,
            "popper-class": _ctx.popperClass,
            "popper-style": _ctx.popperStyle,
            size: _ctx.size,
            teleported: _ctx.teleported,
            "validate-event": false,
            "append-to": _ctx.appendSizeTo,
            onChange: handleChange
          }, {
            default: vue.withCtx(() => [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(innerPageSizes), (item) => {
                return vue.openBlock(), vue.createBlock(vue.unref(ElOption), {
                  key: item,
                  value: item,
                  label: item + vue.unref(t)("el.pagination.pagesize")
                }, null, 8, ["value", "label"]);
              }), 128))
            ]),
            _: 1
          }, 8, ["model-value", "disabled", "popper-class", "popper-style", "size", "teleported", "append-to"])
        ], 2);
      };
    }
  });
  var Sizes = /* @__PURE__ */ _export_sfc(_sfc_main$U, [["__file", "sizes.vue"]]);

  const paginationJumperProps = buildProps({
    size: {
      type: String,
      values: componentSizes
    }
  });

  const __default__$J = vue.defineComponent({
    name: "ElPaginationJumper"
  });
  const _sfc_main$T = /* @__PURE__ */ vue.defineComponent({
    ...__default__$J,
    props: paginationJumperProps,
    setup(__props) {
      const { t } = useLocale();
      const ns = useNamespace("pagination");
      const { pageCount, disabled, currentPage, changeEvent } = usePagination();
      const userInput = vue.ref();
      const innerValue = vue.computed(() => {
        var _a;
        return (_a = userInput.value) != null ? _a : currentPage == null ? void 0 : currentPage.value;
      });
      function handleInput(val) {
        userInput.value = val ? +val : "";
      }
      function handleChange(val) {
        val = Math.trunc(+val);
        changeEvent == null ? void 0 : changeEvent(val);
        userInput.value = void 0;
      }
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("span", {
          class: vue.normalizeClass(vue.unref(ns).e("jump")),
          disabled: vue.unref(disabled)
        }, [
          vue.createElementVNode("span", {
            class: vue.normalizeClass([vue.unref(ns).e("goto")])
          }, vue.toDisplayString(vue.unref(t)("el.pagination.goto")), 3),
          vue.createVNode(vue.unref(ElInput), {
            size: _ctx.size,
            class: vue.normalizeClass([vue.unref(ns).e("editor"), vue.unref(ns).is("in-pagination")]),
            min: 1,
            max: vue.unref(pageCount),
            disabled: vue.unref(disabled),
            "model-value": vue.unref(innerValue),
            "validate-event": false,
            "aria-label": vue.unref(t)("el.pagination.page"),
            type: "number",
            "onUpdate:modelValue": handleInput,
            onChange: handleChange
          }, null, 8, ["size", "class", "max", "disabled", "model-value", "aria-label"]),
          vue.createElementVNode("span", {
            class: vue.normalizeClass([vue.unref(ns).e("classifier")])
          }, vue.toDisplayString(vue.unref(t)("el.pagination.pageClassifier")), 3)
        ], 10, ["disabled"]);
      };
    }
  });
  var Jumper = /* @__PURE__ */ _export_sfc(_sfc_main$T, [["__file", "jumper.vue"]]);

  const paginationTotalProps = buildProps({
    total: {
      type: Number,
      default: 1e3
    }
  });

  const __default__$I = vue.defineComponent({
    name: "ElPaginationTotal"
  });
  const _sfc_main$S = /* @__PURE__ */ vue.defineComponent({
    ...__default__$I,
    props: paginationTotalProps,
    setup(__props) {
      const { t } = useLocale();
      const ns = useNamespace("pagination");
      const { disabled } = usePagination();
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("span", {
          class: vue.normalizeClass(vue.unref(ns).e("total")),
          disabled: vue.unref(disabled)
        }, vue.toDisplayString(vue.unref(t)("el.pagination.total", {
          total: _ctx.total
        })), 11, ["disabled"]);
      };
    }
  });
  var Total = /* @__PURE__ */ _export_sfc(_sfc_main$S, [["__file", "total.vue"]]);

  const paginationPagerProps = buildProps({
    currentPage: {
      type: Number,
      default: 1
    },
    pageCount: {
      type: Number,
      required: true
    },
    pagerCount: {
      type: Number,
      default: 7
    },
    disabled: Boolean
  });

  const __default__$H = vue.defineComponent({
    name: "ElPaginationPager"
  });
  const _sfc_main$R = /* @__PURE__ */ vue.defineComponent({
    ...__default__$H,
    props: paginationPagerProps,
    emits: [CHANGE_EVENT],
    setup(__props, { emit }) {
      const props = __props;
      const nsPager = useNamespace("pager");
      const nsIcon = useNamespace("icon");
      const { t } = useLocale();
      const showPrevMore = vue.ref(false);
      const showNextMore = vue.ref(false);
      const quickPrevHover = vue.ref(false);
      const quickNextHover = vue.ref(false);
      const quickPrevFocus = vue.ref(false);
      const quickNextFocus = vue.ref(false);
      const pagers = vue.computed(() => {
        const pagerCount = props.pagerCount;
        const halfPagerCount = (pagerCount - 1) / 2;
        const currentPage = Number(props.currentPage);
        const pageCount = Number(props.pageCount);
        let showPrevMore2 = false;
        let showNextMore2 = false;
        if (pageCount > pagerCount) {
          if (currentPage > pagerCount - halfPagerCount) {
            showPrevMore2 = true;
          }
          if (currentPage < pageCount - halfPagerCount) {
            showNextMore2 = true;
          }
        }
        const array = [];
        if (showPrevMore2 && !showNextMore2) {
          const startPage = pageCount - (pagerCount - 2);
          for (let i = startPage; i < pageCount; i++) {
            array.push(i);
          }
        } else if (!showPrevMore2 && showNextMore2) {
          for (let i = 2; i < pagerCount; i++) {
            array.push(i);
          }
        } else if (showPrevMore2 && showNextMore2) {
          const offset = Math.floor(pagerCount / 2) - 1;
          for (let i = currentPage - offset; i <= currentPage + offset; i++) {
            array.push(i);
          }
        } else {
          for (let i = 2; i < pageCount; i++) {
            array.push(i);
          }
        }
        return array;
      });
      const prevMoreKls = vue.computed(() => [
        "more",
        "btn-quickprev",
        nsIcon.b(),
        nsPager.is("disabled", props.disabled)
      ]);
      const nextMoreKls = vue.computed(() => [
        "more",
        "btn-quicknext",
        nsIcon.b(),
        nsPager.is("disabled", props.disabled)
      ]);
      const tabindex = vue.computed(() => props.disabled ? -1 : 0);
      vue.watch(() => [props.pageCount, props.pagerCount, props.currentPage], ([pageCount, pagerCount, currentPage]) => {
        const halfPagerCount = (pagerCount - 1) / 2;
        let showPrev = false;
        let showNext = false;
        if (pageCount > pagerCount) {
          showPrev = currentPage > pagerCount - halfPagerCount;
          showNext = currentPage < pageCount - halfPagerCount;
        }
        quickPrevHover.value && (quickPrevHover.value = showPrev);
        quickNextHover.value && (quickNextHover.value = showNext);
        showPrevMore.value = showPrev;
        showNextMore.value = showNext;
      }, { immediate: true });
      function onMouseEnter(forward = false) {
        if (props.disabled)
          return;
        if (forward) {
          quickPrevHover.value = true;
        } else {
          quickNextHover.value = true;
        }
      }
      function onFocus(forward = false) {
        if (forward) {
          quickPrevFocus.value = true;
        } else {
          quickNextFocus.value = true;
        }
      }
      function onEnter(e) {
        const target = e.target;
        if (target.tagName.toLowerCase() === "li" && Array.from(target.classList).includes("number")) {
          const newPage = Number(target.textContent);
          if (newPage !== props.currentPage) {
            emit(CHANGE_EVENT, newPage);
          }
        } else if (target.tagName.toLowerCase() === "li" && Array.from(target.classList).includes("more")) {
          onPagerClick(e);
        }
      }
      function onPagerClick(event) {
        const target = event.target;
        if (target.tagName.toLowerCase() === "ul" || props.disabled) {
          return;
        }
        let newPage = Number(target.textContent);
        const pageCount = props.pageCount;
        const currentPage = props.currentPage;
        const pagerCountOffset = props.pagerCount - 2;
        if (target.className.includes("more")) {
          if (target.className.includes("quickprev")) {
            newPage = currentPage - pagerCountOffset;
          } else if (target.className.includes("quicknext")) {
            newPage = currentPage + pagerCountOffset;
          }
        }
        if (!Number.isNaN(+newPage)) {
          if (newPage < 1) {
            newPage = 1;
          }
          if (newPage > pageCount) {
            newPage = pageCount;
          }
        }
        if (newPage !== currentPage) {
          emit(CHANGE_EVENT, newPage);
        }
      }
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("ul", {
          class: vue.normalizeClass(vue.unref(nsPager).b()),
          onClick: onPagerClick,
          onKeyup: vue.withKeys(onEnter, ["enter"])
        }, [
          _ctx.pageCount > 0 ? (vue.openBlock(), vue.createElementBlock("li", {
            key: 0,
            class: vue.normalizeClass([[
              vue.unref(nsPager).is("active", _ctx.currentPage === 1),
              vue.unref(nsPager).is("disabled", _ctx.disabled)
            ], "number"]),
            "aria-current": _ctx.currentPage === 1,
            "aria-label": vue.unref(t)("el.pagination.currentPage", { pager: 1 }),
            tabindex: vue.unref(tabindex)
          }, " 1 ", 10, ["aria-current", "aria-label", "tabindex"])) : vue.createCommentVNode("v-if", true),
          showPrevMore.value ? (vue.openBlock(), vue.createElementBlock("li", {
            key: 1,
            class: vue.normalizeClass(vue.unref(prevMoreKls)),
            tabindex: vue.unref(tabindex),
            "aria-label": vue.unref(t)("el.pagination.prevPages", { pager: _ctx.pagerCount - 2 }),
            onMouseenter: ($event) => onMouseEnter(true),
            onMouseleave: ($event) => quickPrevHover.value = false,
            onFocus: ($event) => onFocus(true),
            onBlur: ($event) => quickPrevFocus.value = false
          }, [
            (quickPrevHover.value || quickPrevFocus.value) && !_ctx.disabled ? (vue.openBlock(), vue.createBlock(vue.unref(d_arrow_left_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(more_filled_default), { key: 1 }))
          ], 42, ["tabindex", "aria-label", "onMouseenter", "onMouseleave", "onFocus", "onBlur"])) : vue.createCommentVNode("v-if", true),
          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(pagers), (pager) => {
            return vue.openBlock(), vue.createElementBlock("li", {
              key: pager,
              class: vue.normalizeClass([[
                vue.unref(nsPager).is("active", _ctx.currentPage === pager),
                vue.unref(nsPager).is("disabled", _ctx.disabled)
              ], "number"]),
              "aria-current": _ctx.currentPage === pager,
              "aria-label": vue.unref(t)("el.pagination.currentPage", { pager }),
              tabindex: vue.unref(tabindex)
            }, vue.toDisplayString(pager), 11, ["aria-current", "aria-label", "tabindex"]);
          }), 128)),
          showNextMore.value ? (vue.openBlock(), vue.createElementBlock("li", {
            key: 2,
            class: vue.normalizeClass(vue.unref(nextMoreKls)),
            tabindex: vue.unref(tabindex),
            "aria-label": vue.unref(t)("el.pagination.nextPages", { pager: _ctx.pagerCount - 2 }),
            onMouseenter: ($event) => onMouseEnter(),
            onMouseleave: ($event) => quickNextHover.value = false,
            onFocus: ($event) => onFocus(),
            onBlur: ($event) => quickNextFocus.value = false
          }, [
            (quickNextHover.value || quickNextFocus.value) && !_ctx.disabled ? (vue.openBlock(), vue.createBlock(vue.unref(d_arrow_right_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(more_filled_default), { key: 1 }))
          ], 42, ["tabindex", "aria-label", "onMouseenter", "onMouseleave", "onFocus", "onBlur"])) : vue.createCommentVNode("v-if", true),
          _ctx.pageCount > 1 ? (vue.openBlock(), vue.createElementBlock("li", {
            key: 3,
            class: vue.normalizeClass([[
              vue.unref(nsPager).is("active", _ctx.currentPage === _ctx.pageCount),
              vue.unref(nsPager).is("disabled", _ctx.disabled)
            ], "number"]),
            "aria-current": _ctx.currentPage === _ctx.pageCount,
            "aria-label": vue.unref(t)("el.pagination.currentPage", { pager: _ctx.pageCount }),
            tabindex: vue.unref(tabindex)
          }, vue.toDisplayString(_ctx.pageCount), 11, ["aria-current", "aria-label", "tabindex"])) : vue.createCommentVNode("v-if", true)
        ], 42, ["onKeyup"]);
      };
    }
  });
  var Pager = /* @__PURE__ */ _export_sfc(_sfc_main$R, [["__file", "pager.vue"]]);

  const isAbsent = (v) => typeof v !== "number";
  const paginationProps = buildProps({
    pageSize: Number,
    defaultPageSize: Number,
    total: Number,
    pageCount: Number,
    pagerCount: {
      type: Number,
      validator: (value) => {
        return isNumber(value) && Math.trunc(value) === value && value > 4 && value < 22 && value % 2 === 1;
      },
      default: 7
    },
    currentPage: Number,
    defaultCurrentPage: Number,
    layout: {
      type: String,
      default: ["prev", "pager", "next", "jumper", "->", "total"].join(", ")
    },
    pageSizes: {
      type: definePropType(Array),
      default: () => mutable([10, 20, 30, 40, 50, 100])
    },
    popperClass: {
      type: String,
      default: ""
    },
    popperStyle: {
      type: definePropType([String, Object])
    },
    prevText: {
      type: String,
      default: ""
    },
    prevIcon: {
      type: iconPropType,
      default: () => arrow_left_default
    },
    nextText: {
      type: String,
      default: ""
    },
    nextIcon: {
      type: iconPropType,
      default: () => arrow_right_default
    },
    teleported: {
      type: Boolean,
      default: true
    },
    small: Boolean,
    size: useSizeProp,
    background: Boolean,
    disabled: Boolean,
    hideOnSinglePage: Boolean,
    appendSizeTo: String
  });
  const paginationEmits = {
    "update:current-page": (val) => isNumber(val),
    "update:page-size": (val) => isNumber(val),
    "size-change": (val) => isNumber(val),
    change: (currentPage, pageSize) => isNumber(currentPage) && isNumber(pageSize),
    "current-change": (val) => isNumber(val),
    "prev-click": (val) => isNumber(val),
    "next-click": (val) => isNumber(val)
  };
  const componentName = "ElPagination";
  var Pagination = vue.defineComponent({
    name: componentName,
    props: paginationProps,
    emits: paginationEmits,
    setup(props, { emit, slots }) {
      const { t } = useLocale();
      const ns = useNamespace("pagination");
      const vnodeProps = vue.getCurrentInstance().vnode.props || {};
      const _globalSize = useGlobalSize();
      const _size = vue.computed(() => {
        var _a;
        return props.small ? "small" : (_a = props.size) != null ? _a : _globalSize.value;
      });
      useDeprecated({
        from: "small",
        replacement: "size",
        version: "3.0.0",
        scope: "el-pagination",
        ref: "https://element-plus.org/zh-CN/component/pagination.html"
      }, vue.computed(() => !!props.small));
      const hasCurrentPageListener = "onUpdate:currentPage" in vnodeProps || "onUpdate:current-page" in vnodeProps || "onCurrentChange" in vnodeProps;
      const hasPageSizeListener = "onUpdate:pageSize" in vnodeProps || "onUpdate:page-size" in vnodeProps || "onSizeChange" in vnodeProps;
      const assertValidUsage = vue.computed(() => {
        if (isAbsent(props.total) && isAbsent(props.pageCount))
          return false;
        if (!isAbsent(props.currentPage) && !hasCurrentPageListener)
          return false;
        if (props.layout.includes("sizes")) {
          if (!isAbsent(props.pageCount)) {
            if (!hasPageSizeListener)
              return false;
          } else if (!isAbsent(props.total)) {
            if (!isAbsent(props.pageSize)) {
              if (!hasPageSizeListener) {
                return false;
              }
            }
          }
        }
        return true;
      });
      const innerPageSize = vue.ref(isAbsent(props.defaultPageSize) ? 10 : props.defaultPageSize);
      const innerCurrentPage = vue.ref(isAbsent(props.defaultCurrentPage) ? 1 : props.defaultCurrentPage);
      const pageSizeBridge = vue.computed({
        get() {
          return isAbsent(props.pageSize) ? innerPageSize.value : props.pageSize;
        },
        set(v) {
          if (isAbsent(props.pageSize)) {
            innerPageSize.value = v;
          }
          if (hasPageSizeListener) {
            emit("update:page-size", v);
            emit("size-change", v);
          }
        }
      });
      const pageCountBridge = vue.computed(() => {
        let pageCount = 0;
        if (!isAbsent(props.pageCount)) {
          pageCount = props.pageCount;
        } else if (!isAbsent(props.total)) {
          pageCount = Math.max(1, Math.ceil(props.total / pageSizeBridge.value));
        }
        return pageCount;
      });
      const currentPageBridge = vue.computed({
        get() {
          return isAbsent(props.currentPage) ? innerCurrentPage.value : props.currentPage;
        },
        set(v) {
          let newCurrentPage = v;
          if (v < 1) {
            newCurrentPage = 1;
          } else if (v > pageCountBridge.value) {
            newCurrentPage = pageCountBridge.value;
          }
          if (isAbsent(props.currentPage)) {
            innerCurrentPage.value = newCurrentPage;
          }
          if (hasCurrentPageListener) {
            emit("update:current-page", newCurrentPage);
            emit("current-change", newCurrentPage);
          }
        }
      });
      vue.watch(pageCountBridge, (val) => {
        if (currentPageBridge.value > val)
          currentPageBridge.value = val;
      });
      vue.watch([currentPageBridge, pageSizeBridge], (value) => {
        emit(CHANGE_EVENT, ...value);
      }, { flush: "post" });
      function handleCurrentChange(val) {
        currentPageBridge.value = val;
      }
      function handleSizeChange(val) {
        pageSizeBridge.value = val;
        const newPageCount = pageCountBridge.value;
        if (currentPageBridge.value > newPageCount) {
          currentPageBridge.value = newPageCount;
        }
      }
      function prev() {
        if (props.disabled)
          return;
        currentPageBridge.value -= 1;
        emit("prev-click", currentPageBridge.value);
      }
      function next() {
        if (props.disabled)
          return;
        currentPageBridge.value += 1;
        emit("next-click", currentPageBridge.value);
      }
      function addClass(element, cls) {
        if (element) {
          if (!element.props) {
            element.props = {};
          }
          element.props.class = [element.props.class, cls].join(" ");
        }
      }
      vue.provide(elPaginationKey, {
        pageCount: pageCountBridge,
        disabled: vue.computed(() => props.disabled),
        currentPage: currentPageBridge,
        changeEvent: handleCurrentChange,
        handleSizeChange
      });
      return () => {
        var _a, _b;
        if (!assertValidUsage.value) {
          debugWarn(componentName, t("el.pagination.deprecationWarning"));
          return null;
        }
        if (!props.layout)
          return null;
        if (props.hideOnSinglePage && pageCountBridge.value <= 1)
          return null;
        const rootChildren = [];
        const rightWrapperChildren = [];
        const rightWrapperRoot = vue.h("div", { class: ns.e("rightwrapper") }, rightWrapperChildren);
        const TEMPLATE_MAP = {
          prev: vue.h(Prev, {
            disabled: props.disabled,
            currentPage: currentPageBridge.value,
            prevText: props.prevText,
            prevIcon: props.prevIcon,
            onClick: prev
          }),
          jumper: vue.h(Jumper, {
            size: _size.value
          }),
          pager: vue.h(Pager, {
            currentPage: currentPageBridge.value,
            pageCount: pageCountBridge.value,
            pagerCount: props.pagerCount,
            onChange: handleCurrentChange,
            disabled: props.disabled
          }),
          next: vue.h(Next, {
            disabled: props.disabled,
            currentPage: currentPageBridge.value,
            pageCount: pageCountBridge.value,
            nextText: props.nextText,
            nextIcon: props.nextIcon,
            onClick: next
          }),
          sizes: vue.h(Sizes, {
            pageSize: pageSizeBridge.value,
            pageSizes: props.pageSizes,
            popperClass: props.popperClass,
            popperStyle: props.popperStyle,
            disabled: props.disabled,
            teleported: props.teleported,
            size: _size.value,
            appendSizeTo: props.appendSizeTo
          }),
          slot: (_b = (_a = slots == null ? void 0 : slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : null,
          total: vue.h(Total, { total: isAbsent(props.total) ? 0 : props.total })
        };
        const components = props.layout.split(",").map((item) => item.trim());
        let haveRightWrapper = false;
        components.forEach((c) => {
          if (c === "->") {
            haveRightWrapper = true;
            return;
          }
          if (!haveRightWrapper) {
            rootChildren.push(TEMPLATE_MAP[c]);
          } else {
            rightWrapperChildren.push(TEMPLATE_MAP[c]);
          }
        });
        addClass(rootChildren[0], ns.is("first"));
        addClass(rootChildren[rootChildren.length - 1], ns.is("last"));
        if (haveRightWrapper && rightWrapperChildren.length > 0) {
          addClass(rightWrapperChildren[0], ns.is("first"));
          addClass(rightWrapperChildren[rightWrapperChildren.length - 1], ns.is("last"));
          rootChildren.push(rightWrapperRoot);
        }
        return vue.h("div", {
          class: [
            ns.b(),
            ns.is("background", props.background),
            ns.m(_size.value)
          ]
        }, rootChildren);
      };
    }
  });

  const ElPagination = withInstall(Pagination);

  const popconfirmProps = buildProps({
    title: String,
    confirmButtonText: String,
    cancelButtonText: String,
    confirmButtonType: {
      type: String,
      values: buttonTypes,
      default: "primary"
    },
    cancelButtonType: {
      type: String,
      values: buttonTypes,
      default: "text"
    },
    icon: {
      type: iconPropType,
      default: () => question_filled_default
    },
    iconColor: {
      type: String,
      default: "#f90"
    },
    hideIcon: Boolean,
    hideAfter: {
      type: Number,
      default: 200
    },
    effect: {
      ...useTooltipContentProps.effect,
      default: "light"
    },
    teleported: useTooltipContentProps.teleported,
    persistent: useTooltipContentProps.persistent,
    width: {
      type: [String, Number],
      default: 150
    },
    virtualTriggering: useTooltipTriggerProps.virtualTriggering,
    virtualRef: useTooltipTriggerProps.virtualRef
  });
  const popconfirmEmits = {
    confirm: (e) => e instanceof MouseEvent,
    cancel: (e) => e instanceof MouseEvent
  };

  const __default__$G = vue.defineComponent({
    name: "ElPopconfirm"
  });
  const _sfc_main$Q = /* @__PURE__ */ vue.defineComponent({
    ...__default__$G,
    props: popconfirmProps,
    emits: popconfirmEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const { t } = useLocale();
      const ns = useNamespace("popconfirm");
      const tooltipRef = vue.ref();
      const rootRef = vue.ref();
      const popperRef = vue.computed(() => {
        var _a;
        return (_a = vue.unref(tooltipRef)) == null ? void 0 : _a.popperRef;
      });
      const showPopper = () => {
        var _a, _b;
        (_b = (_a = rootRef.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
      };
      const hidePopper = () => {
        var _a, _b;
        (_b = (_a = tooltipRef.value) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
      };
      const style = vue.computed(() => {
        return {
          width: addUnit(props.width)
        };
      });
      const confirm = (e) => {
        emit("confirm", e);
        hidePopper();
      };
      const cancel = (e) => {
        emit("cancel", e);
        hidePopper();
      };
      const finalConfirmButtonText = vue.computed(() => props.confirmButtonText || t("el.popconfirm.confirmButtonText"));
      const finalCancelButtonText = vue.computed(() => props.cancelButtonText || t("el.popconfirm.cancelButtonText"));
      expose({
        popperRef,
        hide: hidePopper
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), vue.mergeProps({
          ref_key: "tooltipRef",
          ref: tooltipRef,
          trigger: "click",
          effect: _ctx.effect
        }, _ctx.$attrs, {
          "popper-class": `${vue.unref(ns).namespace.value}-popover`,
          "popper-style": vue.unref(style),
          teleported: _ctx.teleported,
          "fallback-placements": ["bottom", "top", "right", "left"],
          "hide-after": _ctx.hideAfter,
          persistent: _ctx.persistent,
          loop: "",
          onShow: showPopper
        }), {
          content: vue.withCtx(() => [
            vue.createElementVNode("div", {
              ref_key: "rootRef",
              ref: rootRef,
              tabindex: "-1",
              class: vue.normalizeClass(vue.unref(ns).b())
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("main"))
              }, [
                !_ctx.hideIcon && _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).e("icon")),
                  style: vue.normalizeStyle({ color: _ctx.iconColor })
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                  ]),
                  _: 1
                }, 8, ["class", "style"])) : vue.createCommentVNode("v-if", true),
                vue.createTextVNode(" " + vue.toDisplayString(_ctx.title), 1)
              ], 2),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("action"))
              }, [
                vue.renderSlot(_ctx.$slots, "actions", {
                  confirm,
                  cancel
                }, () => [
                  vue.createVNode(vue.unref(ElButton), {
                    size: "small",
                    type: _ctx.cancelButtonType === "text" ? "" : _ctx.cancelButtonType,
                    text: _ctx.cancelButtonType === "text",
                    onClick: cancel
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(finalCancelButtonText)), 1)
                    ]),
                    _: 1
                  }, 8, ["type", "text"]),
                  vue.createVNode(vue.unref(ElButton), {
                    size: "small",
                    type: _ctx.confirmButtonType === "text" ? "" : _ctx.confirmButtonType,
                    text: _ctx.confirmButtonType === "text",
                    onClick: confirm
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(finalConfirmButtonText)), 1)
                    ]),
                    _: 1
                  }, 8, ["type", "text"])
                ])
              ], 2)
            ], 2)
          ]),
          default: vue.withCtx(() => [
            _ctx.$slots.reference ? vue.renderSlot(_ctx.$slots, "reference", { key: 0 }) : vue.createCommentVNode("v-if", true)
          ]),
          _: 3
        }, 16, ["effect", "popper-class", "popper-style", "teleported", "hide-after", "persistent"]);
      };
    }
  });
  var Popconfirm = /* @__PURE__ */ _export_sfc(_sfc_main$Q, [["__file", "popconfirm.vue"]]);

  const ElPopconfirm = withInstall(Popconfirm);

  const popoverProps = buildProps({
    trigger: useTooltipTriggerProps.trigger,
    triggerKeys: useTooltipTriggerProps.triggerKeys,
    placement: dropdownProps.placement,
    disabled: useTooltipTriggerProps.disabled,
    visible: useTooltipContentProps.visible,
    transition: useTooltipContentProps.transition,
    popperOptions: dropdownProps.popperOptions,
    tabindex: dropdownProps.tabindex,
    content: useTooltipContentProps.content,
    popperStyle: useTooltipContentProps.popperStyle,
    popperClass: useTooltipContentProps.popperClass,
    enterable: {
      ...useTooltipContentProps.enterable,
      default: true
    },
    effect: {
      ...useTooltipContentProps.effect,
      default: "light"
    },
    teleported: useTooltipContentProps.teleported,
    appendTo: useTooltipContentProps.appendTo,
    title: String,
    width: {
      type: [String, Number],
      default: 150
    },
    offset: {
      type: Number,
      default: void 0
    },
    showAfter: {
      type: Number,
      default: 0
    },
    hideAfter: {
      type: Number,
      default: 200
    },
    autoClose: {
      type: Number,
      default: 0
    },
    showArrow: {
      type: Boolean,
      default: true
    },
    persistent: {
      type: Boolean,
      default: true
    },
    "onUpdate:visible": {
      type: Function
    }
  });
  const popoverEmits = {
    "update:visible": (value) => isBoolean(value),
    "before-enter": () => true,
    "before-leave": () => true,
    "after-enter": () => true,
    "after-leave": () => true
  };

  const updateEventKeyRaw = `onUpdate:visible`;
  const __default__$F = vue.defineComponent({
    name: "ElPopover"
  });
  const _sfc_main$P = /* @__PURE__ */ vue.defineComponent({
    ...__default__$F,
    props: popoverProps,
    emits: popoverEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const onUpdateVisible = vue.computed(() => {
        return props[updateEventKeyRaw];
      });
      const ns = useNamespace("popover");
      const tooltipRef = vue.ref();
      const popperRef = vue.computed(() => {
        var _a;
        return (_a = vue.unref(tooltipRef)) == null ? void 0 : _a.popperRef;
      });
      const style = vue.computed(() => {
        return [
          {
            width: addUnit(props.width)
          },
          props.popperStyle
        ];
      });
      const kls = vue.computed(() => {
        return [ns.b(), props.popperClass, { [ns.m("plain")]: !!props.content }];
      });
      const gpuAcceleration = vue.computed(() => {
        return props.transition === `${ns.namespace.value}-fade-in-linear`;
      });
      const hide = () => {
        var _a;
        (_a = tooltipRef.value) == null ? void 0 : _a.hide();
      };
      const beforeEnter = () => {
        emit("before-enter");
      };
      const beforeLeave = () => {
        emit("before-leave");
      };
      const afterEnter = () => {
        emit("after-enter");
      };
      const afterLeave = () => {
        emit("update:visible", false);
        emit("after-leave");
      };
      expose({
        popperRef,
        hide
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), vue.mergeProps({
          ref_key: "tooltipRef",
          ref: tooltipRef
        }, _ctx.$attrs, {
          trigger: _ctx.trigger,
          "trigger-keys": _ctx.triggerKeys,
          placement: _ctx.placement,
          disabled: _ctx.disabled,
          visible: _ctx.visible,
          transition: _ctx.transition,
          "popper-options": _ctx.popperOptions,
          tabindex: _ctx.tabindex,
          content: _ctx.content,
          offset: _ctx.offset,
          "show-after": _ctx.showAfter,
          "hide-after": _ctx.hideAfter,
          "auto-close": _ctx.autoClose,
          "show-arrow": _ctx.showArrow,
          "aria-label": _ctx.title,
          effect: _ctx.effect,
          enterable: _ctx.enterable,
          "popper-class": vue.unref(kls),
          "popper-style": vue.unref(style),
          teleported: _ctx.teleported,
          "append-to": _ctx.appendTo,
          persistent: _ctx.persistent,
          "gpu-acceleration": vue.unref(gpuAcceleration),
          "onUpdate:visible": vue.unref(onUpdateVisible),
          onBeforeShow: beforeEnter,
          onBeforeHide: beforeLeave,
          onShow: afterEnter,
          onHide: afterLeave
        }), {
          content: vue.withCtx(() => [
            _ctx.title ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("title")),
              role: "title"
            }, vue.toDisplayString(_ctx.title), 3)) : vue.createCommentVNode("v-if", true),
            vue.renderSlot(_ctx.$slots, "default", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.content), 1)
            ])
          ]),
          default: vue.withCtx(() => [
            _ctx.$slots.reference ? vue.renderSlot(_ctx.$slots, "reference", { key: 0 }) : vue.createCommentVNode("v-if", true)
          ]),
          _: 3
        }, 16, ["trigger", "trigger-keys", "placement", "disabled", "visible", "transition", "popper-options", "tabindex", "content", "offset", "show-after", "hide-after", "auto-close", "show-arrow", "aria-label", "effect", "enterable", "popper-class", "popper-style", "teleported", "append-to", "persistent", "gpu-acceleration", "onUpdate:visible"]);
      };
    }
  });
  var Popover = /* @__PURE__ */ _export_sfc(_sfc_main$P, [["__file", "popover.vue"]]);

  const attachEvents = (el, binding) => {
    const popperComponent = binding.arg || binding.value;
    const popover = popperComponent == null ? void 0 : popperComponent.popperRef;
    if (popover) {
      popover.triggerRef = el;
    }
  };
  var PopoverDirective = {
    mounted(el, binding) {
      attachEvents(el, binding);
    },
    updated(el, binding) {
      attachEvents(el, binding);
    }
  };
  const VPopover = "popover";

  const ElPopoverDirective = withInstallDirective(PopoverDirective, VPopover);
  const ElPopover = withInstall(Popover, {
    directive: ElPopoverDirective
  });

  const progressProps = buildProps({
    type: {
      type: String,
      default: "line",
      values: ["line", "circle", "dashboard"]
    },
    percentage: {
      type: Number,
      default: 0,
      validator: (val) => val >= 0 && val <= 100
    },
    status: {
      type: String,
      default: "",
      values: ["", "success", "exception", "warning"]
    },
    indeterminate: Boolean,
    duration: {
      type: Number,
      default: 3
    },
    strokeWidth: {
      type: Number,
      default: 6
    },
    strokeLinecap: {
      type: definePropType(String),
      default: "round"
    },
    textInside: Boolean,
    width: {
      type: Number,
      default: 126
    },
    showText: {
      type: Boolean,
      default: true
    },
    color: {
      type: definePropType([
        String,
        Array,
        Function
      ]),
      default: ""
    },
    striped: Boolean,
    stripedFlow: Boolean,
    format: {
      type: definePropType(Function),
      default: (percentage) => `${percentage}%`
    }
  });

  const __default__$E = vue.defineComponent({
    name: "ElProgress"
  });
  const _sfc_main$O = /* @__PURE__ */ vue.defineComponent({
    ...__default__$E,
    props: progressProps,
    setup(__props) {
      const props = __props;
      const STATUS_COLOR_MAP = {
        success: "#13ce66",
        exception: "#ff4949",
        warning: "#e6a23c",
        default: "#20a0ff"
      };
      const ns = useNamespace("progress");
      const barStyle = vue.computed(() => {
        const barStyle2 = {
          width: `${props.percentage}%`,
          animationDuration: `${props.duration}s`
        };
        const color = getCurrentColor(props.percentage);
        if (color.includes("gradient")) {
          barStyle2.background = color;
        } else {
          barStyle2.backgroundColor = color;
        }
        return barStyle2;
      });
      const relativeStrokeWidth = vue.computed(() => (props.strokeWidth / props.width * 100).toFixed(1));
      const radius = vue.computed(() => {
        if (["circle", "dashboard"].includes(props.type)) {
          return Number.parseInt(`${50 - Number.parseFloat(relativeStrokeWidth.value) / 2}`, 10);
        }
        return 0;
      });
      const trackPath = vue.computed(() => {
        const r = radius.value;
        const isDashboard = props.type === "dashboard";
        return `
          M 50 50
          m 0 ${isDashboard ? "" : "-"}${r}
          a ${r} ${r} 0 1 1 0 ${isDashboard ? "-" : ""}${r * 2}
          a ${r} ${r} 0 1 1 0 ${isDashboard ? "" : "-"}${r * 2}
          `;
      });
      const perimeter = vue.computed(() => 2 * Math.PI * radius.value);
      const rate = vue.computed(() => props.type === "dashboard" ? 0.75 : 1);
      const strokeDashoffset = vue.computed(() => {
        const offset = -1 * perimeter.value * (1 - rate.value) / 2;
        return `${offset}px`;
      });
      const trailPathStyle = vue.computed(() => ({
        strokeDasharray: `${perimeter.value * rate.value}px, ${perimeter.value}px`,
        strokeDashoffset: strokeDashoffset.value
      }));
      const circlePathStyle = vue.computed(() => ({
        strokeDasharray: `${perimeter.value * rate.value * (props.percentage / 100)}px, ${perimeter.value}px`,
        strokeDashoffset: strokeDashoffset.value,
        transition: "stroke-dasharray 0.6s ease 0s, stroke 0.6s ease, opacity ease 0.6s"
      }));
      const stroke = vue.computed(() => {
        let ret;
        if (props.color) {
          ret = getCurrentColor(props.percentage);
        } else {
          ret = STATUS_COLOR_MAP[props.status] || STATUS_COLOR_MAP.default;
        }
        return ret;
      });
      const statusIcon = vue.computed(() => {
        if (props.status === "warning") {
          return warning_filled_default;
        }
        if (props.type === "line") {
          return props.status === "success" ? circle_check_default : circle_close_default;
        } else {
          return props.status === "success" ? check_default : close_default;
        }
      });
      const progressTextSize = vue.computed(() => {
        return props.type === "line" ? 12 + props.strokeWidth * 0.4 : props.width * 0.111111 + 2;
      });
      const content = vue.computed(() => props.format(props.percentage));
      function getColors(color) {
        const span = 100 / color.length;
        const seriesColors = color.map((seriesColor, index) => {
          if (isString$1(seriesColor)) {
            return {
              color: seriesColor,
              percentage: (index + 1) * span
            };
          }
          return seriesColor;
        });
        return seriesColors.sort((a, b) => a.percentage - b.percentage);
      }
      const getCurrentColor = (percentage) => {
        var _a;
        const { color } = props;
        if (isFunction$1(color)) {
          return color(percentage);
        } else if (isString$1(color)) {
          return color;
        } else {
          const colors = getColors(color);
          for (const color2 of colors) {
            if (color2.percentage > percentage)
              return color2.color;
          }
          return (_a = colors[colors.length - 1]) == null ? void 0 : _a.color;
        }
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ns).b(),
            vue.unref(ns).m(_ctx.type),
            vue.unref(ns).is(_ctx.status),
            {
              [vue.unref(ns).m("without-text")]: !_ctx.showText,
              [vue.unref(ns).m("text-inside")]: _ctx.textInside
            }
          ]),
          role: "progressbar",
          "aria-valuenow": _ctx.percentage,
          "aria-valuemin": "0",
          "aria-valuemax": "100"
        }, [
          _ctx.type === "line" ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).b("bar"))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).be("bar", "outer")),
              style: vue.normalizeStyle({ height: `${_ctx.strokeWidth}px` })
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass([
                  vue.unref(ns).be("bar", "inner"),
                  { [vue.unref(ns).bem("bar", "inner", "indeterminate")]: _ctx.indeterminate },
                  { [vue.unref(ns).bem("bar", "inner", "striped")]: _ctx.striped },
                  { [vue.unref(ns).bem("bar", "inner", "striped-flow")]: _ctx.stripedFlow }
                ]),
                style: vue.normalizeStyle(vue.unref(barStyle))
              }, [
                (_ctx.showText || _ctx.$slots.default) && _ctx.textInside ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).be("bar", "innerText"))
                }, [
                  vue.renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
                    vue.createElementVNode("span", null, vue.toDisplayString(vue.unref(content)), 1)
                  ])
                ], 2)) : vue.createCommentVNode("v-if", true)
              ], 6)
            ], 6)
          ], 2)) : (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).b("circle")),
            style: vue.normalizeStyle({ height: `${_ctx.width}px`, width: `${_ctx.width}px` })
          }, [
            (vue.openBlock(), vue.createElementBlock("svg", { viewBox: "0 0 100 100" }, [
              vue.createElementVNode("path", {
                class: vue.normalizeClass(vue.unref(ns).be("circle", "track")),
                d: vue.unref(trackPath),
                stroke: `var(${vue.unref(ns).cssVarName("fill-color-light")}, #e5e9f2)`,
                "stroke-linecap": _ctx.strokeLinecap,
                "stroke-width": vue.unref(relativeStrokeWidth),
                fill: "none",
                style: vue.normalizeStyle(vue.unref(trailPathStyle))
              }, null, 14, ["d", "stroke", "stroke-linecap", "stroke-width"]),
              vue.createElementVNode("path", {
                class: vue.normalizeClass(vue.unref(ns).be("circle", "path")),
                d: vue.unref(trackPath),
                stroke: vue.unref(stroke),
                fill: "none",
                opacity: _ctx.percentage ? 1 : 0,
                "stroke-linecap": _ctx.strokeLinecap,
                "stroke-width": vue.unref(relativeStrokeWidth),
                style: vue.normalizeStyle(vue.unref(circlePathStyle))
              }, null, 14, ["d", "stroke", "opacity", "stroke-linecap", "stroke-width"])
            ]))
          ], 6)),
          (_ctx.showText || _ctx.$slots.default) && !_ctx.textInside ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 2,
            class: vue.normalizeClass(vue.unref(ns).e("text")),
            style: vue.normalizeStyle({ fontSize: `${vue.unref(progressTextSize)}px` })
          }, [
            vue.renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
              !_ctx.status ? (vue.openBlock(), vue.createElementBlock("span", { key: 0 }, vue.toDisplayString(vue.unref(content)), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(statusIcon))))
                ]),
                _: 1
              }))
            ])
          ], 6)) : vue.createCommentVNode("v-if", true)
        ], 10, ["aria-valuenow"]);
      };
    }
  });
  var Progress = /* @__PURE__ */ _export_sfc(_sfc_main$O, [["__file", "progress.vue"]]);

  const ElProgress = withInstall(Progress);

  const rateProps = buildProps({
    modelValue: {
      type: Number,
      default: 0
    },
    id: {
      type: String,
      default: void 0
    },
    lowThreshold: {
      type: Number,
      default: 2
    },
    highThreshold: {
      type: Number,
      default: 4
    },
    max: {
      type: Number,
      default: 5
    },
    colors: {
      type: definePropType([Array, Object]),
      default: () => mutable(["", "", ""])
    },
    voidColor: {
      type: String,
      default: ""
    },
    disabledVoidColor: {
      type: String,
      default: ""
    },
    icons: {
      type: definePropType([Array, Object]),
      default: () => [star_filled_default, star_filled_default, star_filled_default]
    },
    voidIcon: {
      type: iconPropType,
      default: () => star_default
    },
    disabledVoidIcon: {
      type: iconPropType,
      default: () => star_filled_default
    },
    disabled: Boolean,
    allowHalf: Boolean,
    showText: Boolean,
    showScore: Boolean,
    textColor: {
      type: String,
      default: ""
    },
    texts: {
      type: definePropType(Array),
      default: () => mutable([
        "Extremely bad",
        "Disappointed",
        "Fair",
        "Satisfied",
        "Surprise"
      ])
    },
    scoreTemplate: {
      type: String,
      default: "{value}"
    },
    size: useSizeProp,
    clearable: Boolean,
    ...useAriaProps(["ariaLabel"])
  });
  const rateEmits = {
    [CHANGE_EVENT]: (value) => isNumber(value),
    [UPDATE_MODEL_EVENT]: (value) => isNumber(value)
  };

  const __default__$D = vue.defineComponent({
    name: "ElRate"
  });
  const _sfc_main$N = /* @__PURE__ */ vue.defineComponent({
    ...__default__$D,
    props: rateProps,
    emits: rateEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      function getValueFromMap(value, map) {
        const isExcludedObject = (val) => isObject$1(val);
        const matchedKeys = Object.keys(map).map((key) => +key).filter((key) => {
          const val = map[key];
          const excluded = isExcludedObject(val) ? val.excluded : false;
          return excluded ? value < key : value <= key;
        }).sort((a, b) => a - b);
        const matchedValue = map[matchedKeys[0]];
        return isExcludedObject(matchedValue) && matchedValue.value || matchedValue;
      }
      const formContext = vue.inject(formContextKey, void 0);
      const formItemContext = vue.inject(formItemContextKey, void 0);
      const rateSize = useFormSize();
      const ns = useNamespace("rate");
      const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
        formItemContext
      });
      const currentValue = vue.ref(props.modelValue);
      const hoverIndex = vue.ref(-1);
      const pointerAtLeftHalf = vue.ref(true);
      const iconRefs = vue.ref([]);
      const iconClientWidths = vue.computed(() => iconRefs.value.map((icon) => icon.$el.clientWidth));
      const rateClasses = vue.computed(() => [ns.b(), ns.m(rateSize.value)]);
      const rateDisabled = vue.computed(() => props.disabled || (formContext == null ? void 0 : formContext.disabled));
      const rateStyles = vue.computed(() => {
        return ns.cssVarBlock({
          "void-color": props.voidColor,
          "disabled-void-color": props.disabledVoidColor,
          "fill-color": activeColor.value
        });
      });
      const text = vue.computed(() => {
        let result = "";
        if (props.showScore) {
          result = props.scoreTemplate.replace(/\{\s*value\s*\}/, rateDisabled.value ? `${props.modelValue}` : `${currentValue.value}`);
        } else if (props.showText) {
          result = props.texts[Math.ceil(currentValue.value) - 1];
        }
        return result;
      });
      const valueDecimal = vue.computed(() => props.modelValue * 100 - Math.floor(props.modelValue) * 100);
      const colorMap = vue.computed(() => isArray$1(props.colors) ? {
        [props.lowThreshold]: props.colors[0],
        [props.highThreshold]: { value: props.colors[1], excluded: true },
        [props.max]: props.colors[2]
      } : props.colors);
      const activeColor = vue.computed(() => {
        const color = getValueFromMap(currentValue.value, colorMap.value);
        return isObject$1(color) ? "" : color;
      });
      const decimalStyle = vue.computed(() => {
        let width = "";
        if (rateDisabled.value) {
          width = `${valueDecimal.value}%`;
        } else if (props.allowHalf) {
          width = "50%";
        }
        return {
          color: activeColor.value,
          width
        };
      });
      const componentMap = vue.computed(() => {
        let icons = isArray$1(props.icons) ? [...props.icons] : { ...props.icons };
        icons = vue.markRaw(icons);
        return isArray$1(icons) ? {
          [props.lowThreshold]: icons[0],
          [props.highThreshold]: {
            value: icons[1],
            excluded: true
          },
          [props.max]: icons[2]
        } : icons;
      });
      const decimalIconComponent = vue.computed(() => getValueFromMap(props.modelValue, componentMap.value));
      const voidComponent = vue.computed(() => rateDisabled.value ? isString$1(props.disabledVoidIcon) ? props.disabledVoidIcon : vue.markRaw(props.disabledVoidIcon) : isString$1(props.voidIcon) ? props.voidIcon : vue.markRaw(props.voidIcon));
      const activeComponent = vue.computed(() => getValueFromMap(currentValue.value, componentMap.value));
      function showDecimalIcon(item) {
        const showWhenDisabled = rateDisabled.value && valueDecimal.value > 0 && item - 1 < props.modelValue && item > props.modelValue;
        const showWhenAllowHalf = props.allowHalf && pointerAtLeftHalf.value && item - 0.5 <= currentValue.value && item > currentValue.value;
        return showWhenDisabled || showWhenAllowHalf;
      }
      function emitValue(value) {
        if (props.clearable && value === props.modelValue) {
          value = 0;
        }
        emit(UPDATE_MODEL_EVENT, value);
        if (props.modelValue !== value) {
          emit(CHANGE_EVENT, value);
        }
      }
      function selectValue(value) {
        if (rateDisabled.value) {
          return;
        }
        if (props.allowHalf && pointerAtLeftHalf.value) {
          emitValue(currentValue.value);
        } else {
          emitValue(value);
        }
      }
      function handleKey(e) {
        if (rateDisabled.value) {
          return;
        }
        const code = getEventCode(e);
        const step = props.allowHalf ? 0.5 : 1;
        let _currentValue = currentValue.value;
        switch (code) {
          case EVENT_CODE.up:
          case EVENT_CODE.right:
            _currentValue += step;
            break;
          case EVENT_CODE.left:
          case EVENT_CODE.down:
            _currentValue -= step;
            break;
        }
        _currentValue = clamp$1(_currentValue, 0, props.max);
        if (_currentValue === currentValue.value) {
          return;
        }
        e.stopPropagation();
        e.preventDefault();
        emit(UPDATE_MODEL_EVENT, _currentValue);
        emit(CHANGE_EVENT, _currentValue);
        return _currentValue;
      }
      function setCurrentValue(value, event) {
        if (rateDisabled.value) {
          return;
        }
        if (props.allowHalf && event) {
          pointerAtLeftHalf.value = event.offsetX * 2 <= iconClientWidths.value[value - 1];
          currentValue.value = pointerAtLeftHalf.value ? value - 0.5 : value;
        } else {
          currentValue.value = value;
        }
        hoverIndex.value = value;
      }
      function resetCurrentValue() {
        if (rateDisabled.value) {
          return;
        }
        if (props.allowHalf) {
          pointerAtLeftHalf.value = props.modelValue !== Math.floor(props.modelValue);
        }
        currentValue.value = props.modelValue;
        hoverIndex.value = -1;
      }
      vue.watch(() => props.modelValue, (val) => {
        currentValue.value = val;
        pointerAtLeftHalf.value = props.modelValue !== Math.floor(props.modelValue);
      });
      if (!props.modelValue) {
        emit(UPDATE_MODEL_EVENT, 0);
      }
      expose({
        setCurrentValue,
        resetCurrentValue
      });
      return (_ctx, _cache) => {
        var _a;
        return vue.openBlock(), vue.createElementBlock("div", {
          id: vue.unref(inputId),
          class: vue.normalizeClass([vue.unref(rateClasses), vue.unref(ns).is("disabled", vue.unref(rateDisabled))]),
          role: "slider",
          "aria-label": !vue.unref(isLabeledByFormItem) ? _ctx.ariaLabel || "rating" : void 0,
          "aria-labelledby": vue.unref(isLabeledByFormItem) ? (_a = vue.unref(formItemContext)) == null ? void 0 : _a.labelId : void 0,
          "aria-valuenow": currentValue.value,
          "aria-valuetext": vue.unref(text) || void 0,
          "aria-valuemin": "0",
          "aria-valuemax": _ctx.max,
          tabindex: "0",
          style: vue.normalizeStyle(vue.unref(rateStyles)),
          onKeydown: handleKey
        }, [
          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.max, (item, key) => {
            return vue.openBlock(), vue.createElementBlock("span", {
              key,
              class: vue.normalizeClass(vue.unref(ns).e("item")),
              onMousemove: ($event) => setCurrentValue(item, $event),
              onMouseleave: resetCurrentValue,
              onClick: ($event) => selectValue(item)
            }, [
              vue.createVNode(vue.unref(ElIcon), {
                ref_for: true,
                ref_key: "iconRefs",
                ref: iconRefs,
                class: vue.normalizeClass([
                  vue.unref(ns).e("icon"),
                  { hover: hoverIndex.value === item },
                  vue.unref(ns).is("active", item <= currentValue.value),
                  vue.unref(ns).is("focus-visible", item === Math.ceil(currentValue.value || 1))
                ])
              }, {
                default: vue.withCtx(() => [
                  vue.withDirectives((vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(activeComponent)), null, null, 512)), [
                    [vue.vShow, !showDecimalIcon(item) && item <= currentValue.value]
                  ]),
                  vue.withDirectives((vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(voidComponent)), null, null, 512)), [
                    [vue.vShow, !showDecimalIcon(item) && item > currentValue.value]
                  ]),
                  vue.withDirectives((vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(voidComponent)), {
                    class: vue.normalizeClass([vue.unref(ns).em("decimal", "box")])
                  }, null, 8, ["class"])), [
                    [vue.vShow, showDecimalIcon(item)]
                  ]),
                  vue.withDirectives(vue.createVNode(vue.unref(ElIcon), {
                    style: vue.normalizeStyle(vue.unref(decimalStyle)),
                    class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(ns).e("decimal")])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(decimalIconComponent))))
                    ]),
                    _: 2
                  }, 1032, ["style", "class"]), [
                    [vue.vShow, showDecimalIcon(item)]
                  ])
                ]),
                _: 2
              }, 1032, ["class"])
            ], 42, ["onMousemove", "onClick"]);
          }), 128)),
          _ctx.showText || _ctx.showScore ? (vue.openBlock(), vue.createElementBlock("span", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("text")),
            style: vue.normalizeStyle({ color: _ctx.textColor })
          }, vue.toDisplayString(vue.unref(text)), 7)) : vue.createCommentVNode("v-if", true)
        ], 46, ["id", "aria-label", "aria-labelledby", "aria-valuenow", "aria-valuetext", "aria-valuemax"]);
      };
    }
  });
  var Rate = /* @__PURE__ */ _export_sfc(_sfc_main$N, [["__file", "rate.vue"]]);

  const ElRate = withInstall(Rate);

  const IconMap = {
    primary: "icon-primary",
    success: "icon-success",
    warning: "icon-warning",
    error: "icon-error",
    info: "icon-info"
  };
  const IconComponentMap = {
    [IconMap.primary]: info_filled_default,
    [IconMap.success]: circle_check_filled_default,
    [IconMap.warning]: warning_filled_default,
    [IconMap.error]: circle_close_filled_default,
    [IconMap.info]: info_filled_default
  };
  const resultProps = buildProps({
    title: {
      type: String,
      default: ""
    },
    subTitle: {
      type: String,
      default: ""
    },
    icon: {
      type: String,
      values: ["primary", "success", "warning", "info", "error"],
      default: "info"
    }
  });

  const __default__$C = vue.defineComponent({
    name: "ElResult"
  });
  const _sfc_main$M = /* @__PURE__ */ vue.defineComponent({
    ...__default__$C,
    props: resultProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("result");
      const resultIcon = vue.computed(() => {
        const icon = props.icon;
        const iconClass = icon && IconMap[icon] ? IconMap[icon] : "icon-info";
        const iconComponent = IconComponentMap[iconClass] || IconComponentMap["icon-info"];
        return {
          class: iconClass,
          component: iconComponent
        };
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("icon"))
          }, [
            vue.renderSlot(_ctx.$slots, "icon", {}, () => [
              vue.unref(resultIcon).component ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(resultIcon).component), {
                key: 0,
                class: vue.normalizeClass(vue.unref(resultIcon).class)
              }, null, 8, ["class"])) : vue.createCommentVNode("v-if", true)
            ])
          ], 2),
          _ctx.title || _ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("title"))
          }, [
            vue.renderSlot(_ctx.$slots, "title", {}, () => [
              vue.createElementVNode("p", null, vue.toDisplayString(_ctx.title), 1)
            ])
          ], 2)) : vue.createCommentVNode("v-if", true),
          _ctx.subTitle || _ctx.$slots["sub-title"] ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("subtitle"))
          }, [
            vue.renderSlot(_ctx.$slots, "sub-title", {}, () => [
              vue.createElementVNode("p", null, vue.toDisplayString(_ctx.subTitle), 1)
            ])
          ], 2)) : vue.createCommentVNode("v-if", true),
          _ctx.$slots.extra ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 2,
            class: vue.normalizeClass(vue.unref(ns).e("extra"))
          }, [
            vue.renderSlot(_ctx.$slots, "extra")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var Result = /* @__PURE__ */ _export_sfc(_sfc_main$M, [["__file", "result.vue"]]);

  const ElResult = withInstall(Result);

  var safeIsNaN = Number.isNaN || function ponyfill(value) {
    return typeof value === "number" && value !== value;
  };
  function isEqual(first, second) {
    if (first === second) {
      return true;
    }
    if (safeIsNaN(first) && safeIsNaN(second)) {
      return true;
    }
    return false;
  }
  function areInputsEqual(newInputs, lastInputs) {
    if (newInputs.length !== lastInputs.length) {
      return false;
    }
    for (var i = 0; i < newInputs.length; i++) {
      if (!isEqual(newInputs[i], lastInputs[i])) {
        return false;
      }
    }
    return true;
  }
  function memoizeOne(resultFn, isEqual2) {
    if (isEqual2 === void 0) {
      isEqual2 = areInputsEqual;
    }
    var cache = null;
    function memoized() {
      var newArgs = [];
      for (var _i = 0; _i < arguments.length; _i++) {
        newArgs[_i] = arguments[_i];
      }
      if (cache && cache.lastThis === this && isEqual2(newArgs, cache.lastArgs)) {
        return cache.lastResult;
      }
      var lastResult = resultFn.apply(this, newArgs);
      cache = {
        lastResult,
        lastArgs: newArgs,
        lastThis: this
      };
      return lastResult;
    }
    memoized.clear = function clear() {
      cache = null;
    };
    return memoized;
  }

  const useCache = () => {
    const vm = vue.getCurrentInstance();
    const props = vm.proxy.$props;
    return vue.computed(() => {
      const _getItemStyleCache = (_, __, ___) => ({});
      return props.perfMode ? memoize(_getItemStyleCache) : memoizeOne(_getItemStyleCache);
    });
  };

  const DEFAULT_DYNAMIC_LIST_ITEM_SIZE = 50;
  const ITEM_RENDER_EVT = "itemRendered";
  const SCROLL_EVT = "scroll";
  const FORWARD = "forward";
  const BACKWARD = "backward";
  const AUTO_ALIGNMENT = "auto";
  const SMART_ALIGNMENT = "smart";
  const START_ALIGNMENT = "start";
  const CENTERED_ALIGNMENT = "center";
  const END_ALIGNMENT = "end";
  const HORIZONTAL = "horizontal";
  const VERTICAL = "vertical";
  const LTR = "ltr";
  const RTL = "rtl";
  const RTL_OFFSET_NAG = "negative";
  const RTL_OFFSET_POS_ASC = "positive-ascending";
  const RTL_OFFSET_POS_DESC = "positive-descending";
  const ScrollbarDirKey = {
    [HORIZONTAL]: "left",
    [VERTICAL]: "top"
  };
  const SCROLLBAR_MIN_SIZE = 20;

  const LayoutKeys = {
    [HORIZONTAL]: "deltaX",
    [VERTICAL]: "deltaY"
  };
  const useWheel = ({ atEndEdge, atStartEdge, layout }, onWheelDelta) => {
    let frameHandle;
    let offset = 0;
    const hasReachedEdge = (offset2) => {
      const edgeReached = offset2 < 0 && atStartEdge.value || offset2 > 0 && atEndEdge.value;
      return edgeReached;
    };
    const onWheel = (e) => {
      cAF(frameHandle);
      const newOffset = e[LayoutKeys[layout.value]];
      if (hasReachedEdge(offset) && hasReachedEdge(offset + newOffset))
        return;
      offset += newOffset;
      if (!isFirefox()) {
        e.preventDefault();
      }
      frameHandle = rAF(() => {
        onWheelDelta(offset);
        offset = 0;
      });
    };
    return {
      hasReachedEdge,
      onWheel
    };
  };
  var useWheel$1 = useWheel;

  const itemSize$1 = buildProp({
    type: definePropType([Number, Function]),
    required: true
  });
  const estimatedItemSize = buildProp({
    type: Number
  });
  const cache = buildProp({
    type: Number,
    default: 2
  });
  const direction = buildProp({
    type: String,
    values: ["ltr", "rtl"],
    default: "ltr"
  });
  const initScrollOffset = buildProp({
    type: Number,
    default: 0
  });
  const total = buildProp({
    type: Number,
    required: true
  });
  const layout = buildProp({
    type: String,
    values: ["horizontal", "vertical"],
    default: VERTICAL
  });
  const virtualizedProps = buildProps({
    className: {
      type: String,
      default: ""
    },
    containerElement: {
      type: definePropType([String, Object]),
      default: "div"
    },
    data: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    direction,
    height: {
      type: [String, Number],
      required: true
    },
    innerElement: {
      type: [String, Object],
      default: "div"
    },
    innerProps: {
      type: definePropType(Object),
      default: () => ({})
    },
    style: {
      type: definePropType([Object, String, Array])
    },
    useIsScrolling: Boolean,
    width: {
      type: [Number, String],
      required: false
    },
    perfMode: {
      type: Boolean,
      default: true
    },
    scrollbarAlwaysOn: Boolean
  });
  const virtualizedListProps = buildProps({
    cache,
    estimatedItemSize,
    layout,
    initScrollOffset,
    total,
    itemSize: itemSize$1,
    ...virtualizedProps
  });
  const scrollbarSize = {
    type: Number,
    default: 6
  };
  const startGap = { type: Number, default: 0 };
  const endGap = { type: Number, default: 2 };
  const virtualizedGridProps = buildProps({
    columnCache: cache,
    columnWidth: itemSize$1,
    estimatedColumnWidth: estimatedItemSize,
    estimatedRowHeight: estimatedItemSize,
    initScrollLeft: initScrollOffset,
    initScrollTop: initScrollOffset,
    itemKey: {
      type: definePropType(Function),
      default: ({
        columnIndex,
        rowIndex
      }) => `${rowIndex}:${columnIndex}`
    },
    rowCache: cache,
    rowHeight: itemSize$1,
    totalColumn: total,
    totalRow: total,
    hScrollbarSize: scrollbarSize,
    vScrollbarSize: scrollbarSize,
    scrollbarStartGap: startGap,
    scrollbarEndGap: endGap,
    role: String,
    ...virtualizedProps
  });
  const virtualizedScrollbarProps = buildProps({
    alwaysOn: Boolean,
    class: String,
    layout,
    total,
    ratio: {
      type: Number,
      required: true
    },
    clientSize: {
      type: Number,
      required: true
    },
    scrollFrom: {
      type: Number,
      required: true
    },
    scrollbarSize,
    startGap,
    endGap,
    visible: Boolean
  });

  const getScrollDir = (prev, cur) => prev < cur ? FORWARD : BACKWARD;
  const isHorizontal = (dir) => dir === LTR || dir === RTL || dir === HORIZONTAL;
  const isRTL = (dir) => dir === RTL;
  let cachedRTLResult = null;
  function getRTLOffsetType(recalculate = false) {
    if (cachedRTLResult === null || recalculate) {
      const outerDiv = document.createElement("div");
      const outerStyle = outerDiv.style;
      outerStyle.width = "50px";
      outerStyle.height = "50px";
      outerStyle.overflow = "scroll";
      outerStyle.direction = "rtl";
      const innerDiv = document.createElement("div");
      const innerStyle = innerDiv.style;
      innerStyle.width = "100px";
      innerStyle.height = "100px";
      outerDiv.appendChild(innerDiv);
      document.body.appendChild(outerDiv);
      if (outerDiv.scrollLeft > 0) {
        cachedRTLResult = RTL_OFFSET_POS_DESC;
      } else {
        outerDiv.scrollLeft = 1;
        if (outerDiv.scrollLeft === 0) {
          cachedRTLResult = RTL_OFFSET_NAG;
        } else {
          cachedRTLResult = RTL_OFFSET_POS_ASC;
        }
      }
      document.body.removeChild(outerDiv);
      return cachedRTLResult;
    }
    return cachedRTLResult;
  }
  function renderThumbStyle({ move, size, bar }, layout) {
    const style = {};
    const translate = `translate${bar.axis}(${move}px)`;
    style[bar.size] = size;
    style.transform = translate;
    if (layout === "horizontal") {
      style.height = "100%";
    } else {
      style.width = "100%";
    }
    return style;
  }

  const ScrollBar = vue.defineComponent({
    name: "ElVirtualScrollBar",
    props: virtualizedScrollbarProps,
    emits: ["scroll", "start-move", "stop-move"],
    setup(props, { emit }) {
      const GAP = vue.computed(() => props.startGap + props.endGap);
      const nsVirtualScrollbar = useNamespace("virtual-scrollbar");
      const nsScrollbar = useNamespace("scrollbar");
      const trackRef = vue.ref();
      const thumbRef = vue.ref();
      let frameHandle = null;
      let onselectstartStore = null;
      const state = vue.reactive({
        isDragging: false,
        traveled: 0
      });
      const bar = vue.computed(() => BAR_MAP[props.layout]);
      const trackSize = vue.computed(() => props.clientSize - vue.unref(GAP));
      const trackStyle = vue.computed(() => ({
        position: "absolute",
        width: `${HORIZONTAL === props.layout ? trackSize.value : props.scrollbarSize}px`,
        height: `${HORIZONTAL === props.layout ? props.scrollbarSize : trackSize.value}px`,
        [ScrollbarDirKey[props.layout]]: "2px",
        right: "2px",
        bottom: "2px",
        borderRadius: "4px"
      }));
      const thumbSize = vue.computed(() => {
        const ratio = props.ratio;
        if (ratio >= 100) {
          return Number.POSITIVE_INFINITY;
        }
        if (ratio >= 50) {
          return ratio * trackSize.value / 100;
        }
        const SCROLLBAR_MAX_SIZE = trackSize.value / 3;
        return Math.floor(Math.min(Math.max(ratio * trackSize.value / 100, SCROLLBAR_MIN_SIZE), SCROLLBAR_MAX_SIZE));
      });
      const thumbStyle = vue.computed(() => {
        if (!Number.isFinite(thumbSize.value)) {
          return {
            display: "none"
          };
        }
        const thumb = `${thumbSize.value}px`;
        const style = renderThumbStyle({
          bar: bar.value,
          size: thumb,
          move: state.traveled
        }, props.layout);
        return style;
      });
      const totalSteps = vue.computed(() => Math.ceil(props.clientSize - thumbSize.value - vue.unref(GAP)));
      const attachEvents = () => {
        window.addEventListener("mousemove", onMouseMove);
        window.addEventListener("mouseup", onMouseUp);
        const thumbEl = vue.unref(thumbRef);
        if (!thumbEl)
          return;
        onselectstartStore = document.onselectstart;
        document.onselectstart = () => false;
        thumbEl.addEventListener("touchmove", onMouseMove, { passive: true });
        thumbEl.addEventListener("touchend", onMouseUp);
      };
      const detachEvents = () => {
        window.removeEventListener("mousemove", onMouseMove);
        window.removeEventListener("mouseup", onMouseUp);
        document.onselectstart = onselectstartStore;
        onselectstartStore = null;
        const thumbEl = vue.unref(thumbRef);
        if (!thumbEl)
          return;
        thumbEl.removeEventListener("touchmove", onMouseMove);
        thumbEl.removeEventListener("touchend", onMouseUp);
      };
      const onThumbMouseDown = (e) => {
        e.stopImmediatePropagation();
        if (e.ctrlKey || [1, 2].includes(e.button)) {
          return;
        }
        state.isDragging = true;
        state[bar.value.axis] = e.currentTarget[bar.value.offset] - (e[bar.value.client] - e.currentTarget.getBoundingClientRect()[bar.value.direction]);
        emit("start-move");
        attachEvents();
      };
      const onMouseUp = () => {
        state.isDragging = false;
        state[bar.value.axis] = 0;
        emit("stop-move");
        detachEvents();
      };
      const onMouseMove = (e) => {
        const { isDragging } = state;
        if (!isDragging)
          return;
        if (!thumbRef.value || !trackRef.value)
          return;
        const prevPage = state[bar.value.axis];
        if (!prevPage)
          return;
        cAF(frameHandle);
        const offset = (trackRef.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
        const thumbClickPosition = thumbRef.value[bar.value.offset] - prevPage;
        const distance = offset - thumbClickPosition;
        frameHandle = rAF(() => {
          state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
          emit("scroll", distance, totalSteps.value);
        });
      };
      const clickTrackHandler = (e) => {
        const offset = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
        const thumbHalf = thumbRef.value[bar.value.offset] / 2;
        const distance = offset - thumbHalf;
        state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
        emit("scroll", distance, totalSteps.value);
      };
      vue.watch(() => props.scrollFrom, (v) => {
        if (state.isDragging)
          return;
        state.traveled = Math.ceil(v * totalSteps.value);
      });
      vue.onBeforeUnmount(() => {
        detachEvents();
      });
      return () => {
        return vue.h("div", {
          role: "presentation",
          ref: trackRef,
          class: [
            nsVirtualScrollbar.b(),
            props.class,
            (props.alwaysOn || state.isDragging) && "always-on"
          ],
          style: trackStyle.value,
          onMousedown: vue.withModifiers(clickTrackHandler, ["stop", "prevent"]),
          onTouchstartPrevent: onThumbMouseDown
        }, vue.h("div", {
          ref: thumbRef,
          class: nsScrollbar.e("thumb"),
          style: thumbStyle.value,
          onMousedown: onThumbMouseDown
        }, []));
      };
    }
  });
  var Scrollbar = ScrollBar;

  const createList = ({
    name,
    getOffset,
    getItemSize,
    getItemOffset,
    getEstimatedTotalSize,
    getStartIndexForOffset,
    getStopIndexForStartIndex,
    initCache,
    clearCache,
    validateProps
  }) => {
    return vue.defineComponent({
      name: name != null ? name : "ElVirtualList",
      props: virtualizedListProps,
      emits: [ITEM_RENDER_EVT, SCROLL_EVT],
      setup(props, { emit, expose }) {
        validateProps(props);
        const instance = vue.getCurrentInstance();
        const ns = useNamespace("vl");
        const dynamicSizeCache = vue.ref(initCache(props, instance));
        const getItemStyleCache = useCache();
        const windowRef = vue.ref();
        const innerRef = vue.ref();
        const scrollbarRef = vue.ref();
        const states = vue.ref({
          isScrolling: false,
          scrollDir: "forward",
          scrollOffset: isNumber(props.initScrollOffset) ? props.initScrollOffset : 0,
          updateRequested: false,
          isScrollbarDragging: false,
          scrollbarAlwaysOn: props.scrollbarAlwaysOn
        });
        const itemsToRender = vue.computed(() => {
          const { total, cache } = props;
          const { isScrolling, scrollDir, scrollOffset } = vue.unref(states);
          if (total === 0) {
            return [0, 0, 0, 0];
          }
          const startIndex = getStartIndexForOffset(props, scrollOffset, vue.unref(dynamicSizeCache));
          const stopIndex = getStopIndexForStartIndex(props, startIndex, scrollOffset, vue.unref(dynamicSizeCache));
          const cacheBackward = !isScrolling || scrollDir === BACKWARD ? Math.max(1, cache) : 1;
          const cacheForward = !isScrolling || scrollDir === FORWARD ? Math.max(1, cache) : 1;
          return [
            Math.max(0, startIndex - cacheBackward),
            Math.max(0, Math.min(total - 1, stopIndex + cacheForward)),
            startIndex,
            stopIndex
          ];
        });
        const estimatedTotalSize = vue.computed(() => getEstimatedTotalSize(props, vue.unref(dynamicSizeCache)));
        const _isHorizontal = vue.computed(() => isHorizontal(props.layout));
        const windowStyle = vue.computed(() => [
          {
            position: "relative",
            [`overflow-${_isHorizontal.value ? "x" : "y"}`]: "scroll",
            WebkitOverflowScrolling: "touch",
            willChange: "transform"
          },
          {
            direction: props.direction,
            height: isNumber(props.height) ? `${props.height}px` : props.height,
            width: isNumber(props.width) ? `${props.width}px` : props.width
          },
          props.style
        ]);
        const innerStyle = vue.computed(() => {
          const size = vue.unref(estimatedTotalSize);
          const horizontal = vue.unref(_isHorizontal);
          return {
            height: horizontal ? "100%" : `${size}px`,
            pointerEvents: vue.unref(states).isScrolling ? "none" : void 0,
            width: horizontal ? `${size}px` : "100%"
          };
        });
        const clientSize = vue.computed(() => _isHorizontal.value ? props.width : props.height);
        const { onWheel } = useWheel$1({
          atStartEdge: vue.computed(() => states.value.scrollOffset <= 0),
          atEndEdge: vue.computed(() => states.value.scrollOffset >= estimatedTotalSize.value),
          layout: vue.computed(() => props.layout)
        }, (offset) => {
          var _a, _b;
          (_b = (_a = scrollbarRef.value).onMouseUp) == null ? void 0 : _b.call(_a);
          scrollTo(Math.min(states.value.scrollOffset + offset, estimatedTotalSize.value - clientSize.value));
        });
        useEventListener(windowRef, "wheel", onWheel, {
          passive: false
        });
        const emitEvents = () => {
          const { total } = props;
          if (total > 0) {
            const [cacheStart, cacheEnd, visibleStart, visibleEnd] = vue.unref(itemsToRender);
            emit(ITEM_RENDER_EVT, cacheStart, cacheEnd, visibleStart, visibleEnd);
          }
          const { scrollDir, scrollOffset, updateRequested } = vue.unref(states);
          emit(SCROLL_EVT, scrollDir, scrollOffset, updateRequested);
        };
        const scrollVertically = (e) => {
          const { clientHeight, scrollHeight, scrollTop } = e.currentTarget;
          const _states = vue.unref(states);
          if (_states.scrollOffset === scrollTop) {
            return;
          }
          const scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
          states.value = {
            ..._states,
            isScrolling: true,
            scrollDir: getScrollDir(_states.scrollOffset, scrollOffset),
            scrollOffset,
            updateRequested: false
          };
          vue.nextTick(resetIsScrolling);
        };
        const scrollHorizontally = (e) => {
          const { clientWidth, scrollLeft, scrollWidth } = e.currentTarget;
          const _states = vue.unref(states);
          if (_states.scrollOffset === scrollLeft) {
            return;
          }
          const { direction } = props;
          let scrollOffset = scrollLeft;
          if (direction === RTL) {
            switch (getRTLOffsetType()) {
              case RTL_OFFSET_NAG: {
                scrollOffset = -scrollLeft;
                break;
              }
              case RTL_OFFSET_POS_DESC: {
                scrollOffset = scrollWidth - clientWidth - scrollLeft;
                break;
              }
            }
          }
          scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));
          states.value = {
            ..._states,
            isScrolling: true,
            scrollDir: getScrollDir(_states.scrollOffset, scrollOffset),
            scrollOffset,
            updateRequested: false
          };
          vue.nextTick(resetIsScrolling);
        };
        const onScroll = (e) => {
          vue.unref(_isHorizontal) ? scrollHorizontally(e) : scrollVertically(e);
          emitEvents();
        };
        const onScrollbarScroll = (distanceToGo, totalSteps) => {
          const offset = (estimatedTotalSize.value - clientSize.value) / totalSteps * distanceToGo;
          scrollTo(Math.min(estimatedTotalSize.value - clientSize.value, offset));
        };
        const scrollTo = (offset) => {
          offset = Math.max(offset, 0);
          if (offset === vue.unref(states).scrollOffset) {
            return;
          }
          states.value = {
            ...vue.unref(states),
            scrollOffset: offset,
            scrollDir: getScrollDir(vue.unref(states).scrollOffset, offset),
            updateRequested: true
          };
          vue.nextTick(resetIsScrolling);
        };
        const scrollToItem = (idx, alignment = AUTO_ALIGNMENT) => {
          const { scrollOffset } = vue.unref(states);
          idx = Math.max(0, Math.min(idx, props.total - 1));
          scrollTo(getOffset(props, idx, alignment, scrollOffset, vue.unref(dynamicSizeCache)));
        };
        const getItemStyle = (idx) => {
          const { direction, itemSize, layout } = props;
          const itemStyleCache = getItemStyleCache.value(clearCache && itemSize, clearCache && layout, clearCache && direction);
          let style;
          if (hasOwn(itemStyleCache, String(idx))) {
            style = itemStyleCache[idx];
          } else {
            const offset = getItemOffset(props, idx, vue.unref(dynamicSizeCache));
            const size = getItemSize(props, idx, vue.unref(dynamicSizeCache));
            const horizontal = vue.unref(_isHorizontal);
            const isRtl = direction === RTL;
            const offsetHorizontal = horizontal ? offset : 0;
            itemStyleCache[idx] = style = {
              position: "absolute",
              left: isRtl ? void 0 : `${offsetHorizontal}px`,
              right: isRtl ? `${offsetHorizontal}px` : void 0,
              top: !horizontal ? `${offset}px` : 0,
              height: !horizontal ? `${size}px` : "100%",
              width: horizontal ? `${size}px` : "100%"
            };
          }
          return style;
        };
        const resetIsScrolling = () => {
          states.value.isScrolling = false;
          vue.nextTick(() => {
            getItemStyleCache.value(-1, null, null);
          });
        };
        const resetScrollTop = () => {
          const window = windowRef.value;
          if (window) {
            window.scrollTop = 0;
          }
        };
        vue.onMounted(() => {
          if (!isClient)
            return;
          const { initScrollOffset } = props;
          const windowElement = vue.unref(windowRef);
          if (isNumber(initScrollOffset) && windowElement) {
            if (vue.unref(_isHorizontal)) {
              windowElement.scrollLeft = initScrollOffset;
            } else {
              windowElement.scrollTop = initScrollOffset;
            }
          }
          emitEvents();
        });
        vue.onUpdated(() => {
          const { direction, layout } = props;
          const { scrollOffset, updateRequested } = vue.unref(states);
          const windowElement = vue.unref(windowRef);
          if (updateRequested && windowElement) {
            if (layout === HORIZONTAL) {
              if (direction === RTL) {
                switch (getRTLOffsetType()) {
                  case RTL_OFFSET_NAG: {
                    windowElement.scrollLeft = -scrollOffset;
                    break;
                  }
                  case RTL_OFFSET_POS_ASC: {
                    windowElement.scrollLeft = scrollOffset;
                    break;
                  }
                  default: {
                    const { clientWidth, scrollWidth } = windowElement;
                    windowElement.scrollLeft = scrollWidth - clientWidth - scrollOffset;
                    break;
                  }
                }
              } else {
                windowElement.scrollLeft = scrollOffset;
              }
            } else {
              windowElement.scrollTop = scrollOffset;
            }
          }
        });
        vue.onActivated(() => {
          vue.unref(windowRef).scrollTop = vue.unref(states).scrollOffset;
        });
        const api = {
          ns,
          clientSize,
          estimatedTotalSize,
          windowStyle,
          windowRef,
          innerRef,
          innerStyle,
          itemsToRender,
          scrollbarRef,
          states,
          getItemStyle,
          onScroll,
          onScrollbarScroll,
          onWheel,
          scrollTo,
          scrollToItem,
          resetScrollTop
        };
        expose({
          windowRef,
          innerRef,
          getItemStyleCache,
          scrollTo,
          scrollToItem,
          resetScrollTop,
          states
        });
        return api;
      },
      render(ctx) {
        var _a;
        const {
          $slots,
          className,
          clientSize,
          containerElement,
          data,
          getItemStyle,
          innerElement,
          itemsToRender,
          innerStyle,
          layout,
          total,
          onScroll,
          onScrollbarScroll,
          states,
          useIsScrolling,
          windowStyle,
          ns
        } = ctx;
        const [start, end] = itemsToRender;
        const Container = vue.resolveDynamicComponent(containerElement);
        const Inner = vue.resolveDynamicComponent(innerElement);
        const children = [];
        if (total > 0) {
          for (let i = start; i <= end; i++) {
            children.push(vue.h(vue.Fragment, { key: i }, (_a = $slots.default) == null ? void 0 : _a.call($slots, {
              data,
              index: i,
              isScrolling: useIsScrolling ? states.isScrolling : void 0,
              style: getItemStyle(i)
            })));
          }
        }
        const InnerNode = [
          vue.h(Inner, vue.mergeProps(ctx.innerProps, {
            style: innerStyle,
            ref: "innerRef"
          }), !isString$1(Inner) ? {
            default: () => children
          } : children)
        ];
        const scrollbar = vue.h(Scrollbar, {
          ref: "scrollbarRef",
          clientSize,
          layout,
          onScroll: onScrollbarScroll,
          ratio: clientSize * 100 / this.estimatedTotalSize,
          scrollFrom: states.scrollOffset / (this.estimatedTotalSize - clientSize),
          total,
          alwaysOn: states.scrollbarAlwaysOn
        });
        const listContainer = vue.h(Container, {
          class: [ns.e("window"), className],
          style: windowStyle,
          onScroll,
          ref: "windowRef",
          key: 0
        }, !isString$1(Container) ? { default: () => [InnerNode] } : [InnerNode]);
        return vue.h("div", {
          key: 0,
          class: [ns.e("wrapper"), states.scrollbarAlwaysOn ? "always-on" : ""]
        }, [listContainer, scrollbar]);
      }
    });
  };
  var createList$1 = createList;

  const FixedSizeList = createList$1({
    name: "ElFixedSizeList",
    getItemOffset: ({ itemSize }, index) => index * itemSize,
    getItemSize: ({ itemSize }) => itemSize,
    getEstimatedTotalSize: ({ total, itemSize }) => itemSize * total,
    getOffset: ({ height, total, itemSize, layout, width }, index, alignment, scrollOffset) => {
      const size = isHorizontal(layout) ? width : height;
      const lastItemOffset = Math.max(0, total * itemSize - size);
      const maxOffset = Math.min(lastItemOffset, index * itemSize);
      const minOffset = Math.max(0, (index + 1) * itemSize - size);
      if (alignment === SMART_ALIGNMENT) {
        if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
          alignment = AUTO_ALIGNMENT;
        } else {
          alignment = CENTERED_ALIGNMENT;
        }
      }
      switch (alignment) {
        case START_ALIGNMENT: {
          return maxOffset;
        }
        case END_ALIGNMENT: {
          return minOffset;
        }
        case CENTERED_ALIGNMENT: {
          const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
          if (middleOffset < Math.ceil(size / 2)) {
            return 0;
          } else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {
            return lastItemOffset;
          } else {
            return middleOffset;
          }
        }
        case AUTO_ALIGNMENT:
        default: {
          if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
            return scrollOffset;
          } else if (scrollOffset < minOffset) {
            return minOffset;
          } else {
            return maxOffset;
          }
        }
      }
    },
    getStartIndexForOffset: ({ total, itemSize }, offset) => Math.max(0, Math.min(total - 1, Math.floor(offset / itemSize))),
    getStopIndexForStartIndex: ({ height, total, itemSize, layout, width }, startIndex, scrollOffset) => {
      const offset = startIndex * itemSize;
      const size = isHorizontal(layout) ? width : height;
      const numVisibleItems = Math.ceil((size + scrollOffset - offset) / itemSize);
      return Math.max(0, Math.min(total - 1, startIndex + numVisibleItems - 1));
    },
    initCache() {
      return void 0;
    },
    clearCache: true,
    validateProps() {
    }
  });
  var FixedSizeList$1 = FixedSizeList;

  const getItemFromCache$1 = (props, index, listCache) => {
    const { itemSize } = props;
    const { items, lastVisitedIndex } = listCache;
    if (index > lastVisitedIndex) {
      let offset = 0;
      if (lastVisitedIndex >= 0) {
        const item = items[lastVisitedIndex];
        offset = item.offset + item.size;
      }
      for (let i = lastVisitedIndex + 1; i <= index; i++) {
        const size = itemSize(i);
        items[i] = {
          offset,
          size
        };
        offset += size;
      }
      listCache.lastVisitedIndex = index;
    }
    return items[index];
  };
  const findItem$1 = (props, listCache, offset) => {
    const { items, lastVisitedIndex } = listCache;
    const lastVisitedOffset = lastVisitedIndex > 0 ? items[lastVisitedIndex].offset : 0;
    if (lastVisitedOffset >= offset) {
      return bs$1(props, listCache, 0, lastVisitedIndex, offset);
    }
    return es$1(props, listCache, Math.max(0, lastVisitedIndex), offset);
  };
  const bs$1 = (props, listCache, low, high, offset) => {
    while (low <= high) {
      const mid = low + Math.floor((high - low) / 2);
      const currentOffset = getItemFromCache$1(props, mid, listCache).offset;
      if (currentOffset === offset) {
        return mid;
      } else if (currentOffset < offset) {
        low = mid + 1;
      } else if (currentOffset > offset) {
        high = mid - 1;
      }
    }
    return Math.max(0, low - 1);
  };
  const es$1 = (props, listCache, index, offset) => {
    const { total } = props;
    let exponent = 1;
    while (index < total && getItemFromCache$1(props, index, listCache).offset < offset) {
      index += exponent;
      exponent *= 2;
    }
    return bs$1(props, listCache, Math.floor(index / 2), Math.min(index, total - 1), offset);
  };
  const getEstimatedTotalSize = ({ total }, { items, estimatedItemSize, lastVisitedIndex }) => {
    let totalSizeOfMeasuredItems = 0;
    if (lastVisitedIndex >= total) {
      lastVisitedIndex = total - 1;
    }
    if (lastVisitedIndex >= 0) {
      const item = items[lastVisitedIndex];
      totalSizeOfMeasuredItems = item.offset + item.size;
    }
    const numUnmeasuredItems = total - lastVisitedIndex - 1;
    const totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;
    return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
  };
  const DynamicSizeList = createList$1({
    name: "ElDynamicSizeList",
    getItemOffset: (props, index, listCache) => getItemFromCache$1(props, index, listCache).offset,
    getItemSize: (_, index, { items }) => items[index].size,
    getEstimatedTotalSize,
    getOffset: (props, index, alignment, scrollOffset, listCache) => {
      const { height, layout, width } = props;
      const size = isHorizontal(layout) ? width : height;
      const item = getItemFromCache$1(props, index, listCache);
      const estimatedTotalSize = getEstimatedTotalSize(props, listCache);
      const maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, item.offset));
      const minOffset = Math.max(0, item.offset - size + item.size);
      if (alignment === SMART_ALIGNMENT) {
        if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
          alignment = AUTO_ALIGNMENT;
        } else {
          alignment = CENTERED_ALIGNMENT;
        }
      }
      switch (alignment) {
        case START_ALIGNMENT: {
          return maxOffset;
        }
        case END_ALIGNMENT: {
          return minOffset;
        }
        case CENTERED_ALIGNMENT: {
          return Math.round(minOffset + (maxOffset - minOffset) / 2);
        }
        case AUTO_ALIGNMENT:
        default: {
          if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
            return scrollOffset;
          } else if (scrollOffset < minOffset) {
            return minOffset;
          } else {
            return maxOffset;
          }
        }
      }
    },
    getStartIndexForOffset: (props, offset, listCache) => findItem$1(props, listCache, offset),
    getStopIndexForStartIndex: (props, startIndex, scrollOffset, listCache) => {
      const { height, total, layout, width } = props;
      const size = isHorizontal(layout) ? width : height;
      const item = getItemFromCache$1(props, startIndex, listCache);
      const maxOffset = scrollOffset + size;
      let offset = item.offset + item.size;
      let stopIndex = startIndex;
      while (stopIndex < total - 1 && offset < maxOffset) {
        stopIndex++;
        offset += getItemFromCache$1(props, stopIndex, listCache).size;
      }
      return stopIndex;
    },
    initCache({ estimatedItemSize = DEFAULT_DYNAMIC_LIST_ITEM_SIZE }, instance) {
      const cache = {
        items: {},
        estimatedItemSize,
        lastVisitedIndex: -1
      };
      cache.clearCacheAfterIndex = (index, forceUpdate = true) => {
        var _a, _b;
        cache.lastVisitedIndex = Math.min(cache.lastVisitedIndex, index - 1);
        (_a = instance.exposed) == null ? void 0 : _a.getItemStyleCache(-1);
        if (forceUpdate) {
          (_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
        }
      };
      return cache;
    },
    clearCache: false,
    validateProps: ({ itemSize }) => {
    }
  });
  var DynamicSizeList$1 = DynamicSizeList;

  const useGridWheel = ({ atXEndEdge, atXStartEdge, atYEndEdge, atYStartEdge }, onWheelDelta) => {
    let frameHandle = null;
    let xOffset = 0;
    let yOffset = 0;
    const hasReachedEdge = (x, y) => {
      const xEdgeReached = x <= 0 && atXStartEdge.value || x >= 0 && atXEndEdge.value;
      const yEdgeReached = y <= 0 && atYStartEdge.value || y >= 0 && atYEndEdge.value;
      return xEdgeReached && yEdgeReached;
    };
    const onWheel = (e) => {
      cAF(frameHandle);
      let x = e.deltaX;
      let y = e.deltaY;
      if (Math.abs(x) > Math.abs(y)) {
        y = 0;
      } else {
        x = 0;
      }
      if (e.shiftKey && y !== 0) {
        x = y;
        y = 0;
      }
      if (hasReachedEdge(xOffset, yOffset) && hasReachedEdge(xOffset + x, yOffset + y))
        return;
      xOffset += x;
      yOffset += y;
      e.preventDefault();
      frameHandle = rAF(() => {
        onWheelDelta(xOffset, yOffset);
        xOffset = 0;
        yOffset = 0;
      });
    };
    return {
      hasReachedEdge,
      onWheel
    };
  };

  const createGrid = ({
    name,
    clearCache,
    getColumnPosition,
    getColumnStartIndexForOffset,
    getColumnStopIndexForStartIndex,
    getEstimatedTotalHeight,
    getEstimatedTotalWidth,
    getColumnOffset,
    getRowOffset,
    getRowPosition,
    getRowStartIndexForOffset,
    getRowStopIndexForStartIndex,
    initCache,
    injectToInstance,
    validateProps
  }) => {
    return vue.defineComponent({
      name: name != null ? name : "ElVirtualList",
      props: virtualizedGridProps,
      emits: [ITEM_RENDER_EVT, SCROLL_EVT],
      setup(props, { emit, expose, slots }) {
        const ns = useNamespace("vl");
        validateProps(props);
        const instance = vue.getCurrentInstance();
        const cache = vue.ref(initCache(props, instance));
        injectToInstance == null ? void 0 : injectToInstance(instance, cache);
        const windowRef = vue.ref();
        const hScrollbar = vue.ref();
        const vScrollbar = vue.ref();
        const innerRef = vue.ref(null);
        const states = vue.ref({
          isScrolling: false,
          scrollLeft: isNumber(props.initScrollLeft) ? props.initScrollLeft : 0,
          scrollTop: isNumber(props.initScrollTop) ? props.initScrollTop : 0,
          updateRequested: false,
          xAxisScrollDir: FORWARD,
          yAxisScrollDir: FORWARD
        });
        const getItemStyleCache = useCache();
        const parsedHeight = vue.computed(() => Number.parseInt(`${props.height}`, 10));
        const parsedWidth = vue.computed(() => Number.parseInt(`${props.width}`, 10));
        const columnsToRender = vue.computed(() => {
          const { totalColumn, totalRow, columnCache } = props;
          const { isScrolling, xAxisScrollDir, scrollLeft } = vue.unref(states);
          if (totalColumn === 0 || totalRow === 0) {
            return [0, 0, 0, 0];
          }
          const startIndex = getColumnStartIndexForOffset(props, scrollLeft, vue.unref(cache));
          const stopIndex = getColumnStopIndexForStartIndex(props, startIndex, scrollLeft, vue.unref(cache));
          const cacheBackward = !isScrolling || xAxisScrollDir === BACKWARD ? Math.max(1, columnCache) : 1;
          const cacheForward = !isScrolling || xAxisScrollDir === FORWARD ? Math.max(1, columnCache) : 1;
          return [
            Math.max(0, startIndex - cacheBackward),
            Math.max(0, Math.min(totalColumn - 1, stopIndex + cacheForward)),
            startIndex,
            stopIndex
          ];
        });
        const rowsToRender = vue.computed(() => {
          const { totalColumn, totalRow, rowCache } = props;
          const { isScrolling, yAxisScrollDir, scrollTop } = vue.unref(states);
          if (totalColumn === 0 || totalRow === 0) {
            return [0, 0, 0, 0];
          }
          const startIndex = getRowStartIndexForOffset(props, scrollTop, vue.unref(cache));
          const stopIndex = getRowStopIndexForStartIndex(props, startIndex, scrollTop, vue.unref(cache));
          const cacheBackward = !isScrolling || yAxisScrollDir === BACKWARD ? Math.max(1, rowCache) : 1;
          const cacheForward = !isScrolling || yAxisScrollDir === FORWARD ? Math.max(1, rowCache) : 1;
          return [
            Math.max(0, startIndex - cacheBackward),
            Math.max(0, Math.min(totalRow - 1, stopIndex + cacheForward)),
            startIndex,
            stopIndex
          ];
        });
        const estimatedTotalHeight = vue.computed(() => getEstimatedTotalHeight(props, vue.unref(cache)));
        const estimatedTotalWidth = vue.computed(() => getEstimatedTotalWidth(props, vue.unref(cache)));
        const windowStyle = vue.computed(() => {
          var _a;
          return [
            {
              position: "relative",
              overflow: "hidden",
              WebkitOverflowScrolling: "touch",
              willChange: "transform"
            },
            {
              direction: props.direction,
              height: isNumber(props.height) ? `${props.height}px` : props.height,
              width: isNumber(props.width) ? `${props.width}px` : props.width
            },
            (_a = props.style) != null ? _a : {}
          ];
        });
        const innerStyle = vue.computed(() => {
          const width = `${vue.unref(estimatedTotalWidth)}px`;
          const height = `${vue.unref(estimatedTotalHeight)}px`;
          return {
            height,
            pointerEvents: vue.unref(states).isScrolling ? "none" : void 0,
            width
          };
        });
        const emitEvents = () => {
          const { totalColumn, totalRow } = props;
          if (totalColumn > 0 && totalRow > 0) {
            const [
              columnCacheStart,
              columnCacheEnd,
              columnVisibleStart,
              columnVisibleEnd
            ] = vue.unref(columnsToRender);
            const [rowCacheStart, rowCacheEnd, rowVisibleStart, rowVisibleEnd] = vue.unref(rowsToRender);
            emit(ITEM_RENDER_EVT, {
              columnCacheStart,
              columnCacheEnd,
              rowCacheStart,
              rowCacheEnd,
              columnVisibleStart,
              columnVisibleEnd,
              rowVisibleStart,
              rowVisibleEnd
            });
          }
          const {
            scrollLeft,
            scrollTop,
            updateRequested,
            xAxisScrollDir,
            yAxisScrollDir
          } = vue.unref(states);
          emit(SCROLL_EVT, {
            xAxisScrollDir,
            scrollLeft,
            yAxisScrollDir,
            scrollTop,
            updateRequested
          });
        };
        const onScroll = (e) => {
          const {
            clientHeight,
            clientWidth,
            scrollHeight,
            scrollLeft,
            scrollTop,
            scrollWidth
          } = e.currentTarget;
          const _states = vue.unref(states);
          if (_states.scrollTop === scrollTop && _states.scrollLeft === scrollLeft) {
            return;
          }
          let _scrollLeft = scrollLeft;
          if (isRTL(props.direction)) {
            switch (getRTLOffsetType()) {
              case RTL_OFFSET_NAG:
                _scrollLeft = -scrollLeft;
                break;
              case RTL_OFFSET_POS_DESC:
                _scrollLeft = scrollWidth - clientWidth - scrollLeft;
                break;
            }
          }
          states.value = {
            ..._states,
            isScrolling: true,
            scrollLeft: _scrollLeft,
            scrollTop: Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight)),
            updateRequested: true,
            xAxisScrollDir: getScrollDir(_states.scrollLeft, _scrollLeft),
            yAxisScrollDir: getScrollDir(_states.scrollTop, scrollTop)
          };
          vue.nextTick(() => resetIsScrolling());
          onUpdated();
          emitEvents();
        };
        const onVerticalScroll = (distance, totalSteps) => {
          const height = vue.unref(parsedHeight);
          const offset = (estimatedTotalHeight.value - height) / totalSteps * distance;
          scrollTo({
            scrollTop: Math.min(estimatedTotalHeight.value - height, offset)
          });
        };
        const onHorizontalScroll = (distance, totalSteps) => {
          const width = vue.unref(parsedWidth);
          const offset = (estimatedTotalWidth.value - width) / totalSteps * distance;
          scrollTo({
            scrollLeft: Math.min(estimatedTotalWidth.value - width, offset)
          });
        };
        const { onWheel } = useGridWheel({
          atXStartEdge: vue.computed(() => states.value.scrollLeft <= 0),
          atXEndEdge: vue.computed(() => states.value.scrollLeft >= estimatedTotalWidth.value - vue.unref(parsedWidth)),
          atYStartEdge: vue.computed(() => states.value.scrollTop <= 0),
          atYEndEdge: vue.computed(() => states.value.scrollTop >= estimatedTotalHeight.value - vue.unref(parsedHeight))
        }, (x, y) => {
          var _a, _b, _c, _d;
          (_b = (_a = hScrollbar.value) == null ? void 0 : _a.onMouseUp) == null ? void 0 : _b.call(_a);
          (_d = (_c = vScrollbar.value) == null ? void 0 : _c.onMouseUp) == null ? void 0 : _d.call(_c);
          const width = vue.unref(parsedWidth);
          const height = vue.unref(parsedHeight);
          scrollTo({
            scrollLeft: Math.min(states.value.scrollLeft + x, estimatedTotalWidth.value - width),
            scrollTop: Math.min(states.value.scrollTop + y, estimatedTotalHeight.value - height)
          });
        });
        useEventListener(windowRef, "wheel", onWheel, {
          passive: false
        });
        const scrollTo = ({
          scrollLeft = states.value.scrollLeft,
          scrollTop = states.value.scrollTop
        }) => {
          scrollLeft = Math.max(scrollLeft, 0);
          scrollTop = Math.max(scrollTop, 0);
          const _states = vue.unref(states);
          if (scrollTop === _states.scrollTop && scrollLeft === _states.scrollLeft) {
            return;
          }
          states.value = {
            ..._states,
            xAxisScrollDir: getScrollDir(_states.scrollLeft, scrollLeft),
            yAxisScrollDir: getScrollDir(_states.scrollTop, scrollTop),
            scrollLeft,
            scrollTop,
            updateRequested: true
          };
          vue.nextTick(() => resetIsScrolling());
          onUpdated();
          emitEvents();
        };
        const scrollToItem = (rowIndex = 0, columnIdx = 0, alignment = AUTO_ALIGNMENT) => {
          const _states = vue.unref(states);
          columnIdx = Math.max(0, Math.min(columnIdx, props.totalColumn - 1));
          rowIndex = Math.max(0, Math.min(rowIndex, props.totalRow - 1));
          const scrollBarWidth = getScrollBarWidth(ns.namespace.value);
          const _cache = vue.unref(cache);
          const estimatedHeight = getEstimatedTotalHeight(props, _cache);
          const estimatedWidth = getEstimatedTotalWidth(props, _cache);
          scrollTo({
            scrollLeft: getColumnOffset(props, columnIdx, alignment, _states.scrollLeft, _cache, estimatedWidth > props.width ? scrollBarWidth : 0),
            scrollTop: getRowOffset(props, rowIndex, alignment, _states.scrollTop, _cache, estimatedHeight > props.height ? scrollBarWidth : 0)
          });
        };
        const getItemStyle = (rowIndex, columnIndex) => {
          const { columnWidth, direction, rowHeight } = props;
          const itemStyleCache = getItemStyleCache.value(clearCache && columnWidth, clearCache && rowHeight, clearCache && direction);
          const key = `${rowIndex},${columnIndex}`;
          if (hasOwn(itemStyleCache, key)) {
            return itemStyleCache[key];
          } else {
            const [, left] = getColumnPosition(props, columnIndex, vue.unref(cache));
            const _cache = vue.unref(cache);
            const rtl = isRTL(direction);
            const [height, top] = getRowPosition(props, rowIndex, _cache);
            const [width] = getColumnPosition(props, columnIndex, _cache);
            itemStyleCache[key] = {
              position: "absolute",
              left: rtl ? void 0 : `${left}px`,
              right: rtl ? `${left}px` : void 0,
              top: `${top}px`,
              height: `${height}px`,
              width: `${width}px`
            };
            return itemStyleCache[key];
          }
        };
        const resetIsScrolling = () => {
          states.value.isScrolling = false;
          vue.nextTick(() => {
            getItemStyleCache.value(-1, null, null);
          });
        };
        vue.onMounted(() => {
          if (!isClient)
            return;
          const { initScrollLeft, initScrollTop } = props;
          const windowElement = vue.unref(windowRef);
          if (windowElement) {
            if (isNumber(initScrollLeft)) {
              windowElement.scrollLeft = initScrollLeft;
            }
            if (isNumber(initScrollTop)) {
              windowElement.scrollTop = initScrollTop;
            }
          }
          emitEvents();
        });
        const onUpdated = () => {
          const { direction } = props;
          const { scrollLeft, scrollTop, updateRequested } = vue.unref(states);
          const windowElement = vue.unref(windowRef);
          if (updateRequested && windowElement) {
            if (direction === RTL) {
              switch (getRTLOffsetType()) {
                case RTL_OFFSET_NAG: {
                  windowElement.scrollLeft = -scrollLeft;
                  break;
                }
                case RTL_OFFSET_POS_ASC: {
                  windowElement.scrollLeft = scrollLeft;
                  break;
                }
                default: {
                  const { clientWidth, scrollWidth } = windowElement;
                  windowElement.scrollLeft = scrollWidth - clientWidth - scrollLeft;
                  break;
                }
              }
            } else {
              windowElement.scrollLeft = Math.max(0, scrollLeft);
            }
            windowElement.scrollTop = Math.max(0, scrollTop);
          }
        };
        const { resetAfterColumnIndex, resetAfterRowIndex, resetAfter } = instance.proxy;
        expose({
          windowRef,
          innerRef,
          getItemStyleCache,
          scrollTo,
          scrollToItem,
          states,
          resetAfterColumnIndex,
          resetAfterRowIndex,
          resetAfter
        });
        const renderScrollbars = () => {
          const {
            scrollbarAlwaysOn,
            scrollbarStartGap,
            scrollbarEndGap,
            totalColumn,
            totalRow
          } = props;
          const width = vue.unref(parsedWidth);
          const height = vue.unref(parsedHeight);
          const estimatedWidth = vue.unref(estimatedTotalWidth);
          const estimatedHeight = vue.unref(estimatedTotalHeight);
          const { scrollLeft, scrollTop } = vue.unref(states);
          const horizontalScrollbar = vue.h(Scrollbar, {
            ref: hScrollbar,
            alwaysOn: scrollbarAlwaysOn,
            startGap: scrollbarStartGap,
            endGap: scrollbarEndGap,
            class: ns.e("horizontal"),
            clientSize: width,
            layout: "horizontal",
            onScroll: onHorizontalScroll,
            ratio: width * 100 / estimatedWidth,
            scrollFrom: scrollLeft / (estimatedWidth - width),
            total: totalRow,
            visible: true
          });
          const verticalScrollbar = vue.h(Scrollbar, {
            ref: vScrollbar,
            alwaysOn: scrollbarAlwaysOn,
            startGap: scrollbarStartGap,
            endGap: scrollbarEndGap,
            class: ns.e("vertical"),
            clientSize: height,
            layout: "vertical",
            onScroll: onVerticalScroll,
            ratio: height * 100 / estimatedHeight,
            scrollFrom: scrollTop / (estimatedHeight - height),
            total: totalColumn,
            visible: true
          });
          return {
            horizontalScrollbar,
            verticalScrollbar
          };
        };
        const renderItems = () => {
          var _a;
          const [columnStart, columnEnd] = vue.unref(columnsToRender);
          const [rowStart, rowEnd] = vue.unref(rowsToRender);
          const { data, totalColumn, totalRow, useIsScrolling, itemKey } = props;
          const children = [];
          if (totalRow > 0 && totalColumn > 0) {
            for (let row = rowStart; row <= rowEnd; row++) {
              for (let column = columnStart; column <= columnEnd; column++) {
                const key = itemKey({ columnIndex: column, data, rowIndex: row });
                children.push(vue.h(vue.Fragment, { key }, (_a = slots.default) == null ? void 0 : _a.call(slots, {
                  columnIndex: column,
                  data,
                  isScrolling: useIsScrolling ? vue.unref(states).isScrolling : void 0,
                  style: getItemStyle(row, column),
                  rowIndex: row
                })));
              }
            }
          }
          return children;
        };
        const renderInner = () => {
          const Inner = vue.resolveDynamicComponent(props.innerElement);
          const children = renderItems();
          return [
            vue.h(Inner, vue.mergeProps(props.innerProps, {
              style: vue.unref(innerStyle),
              ref: innerRef
            }), !isString$1(Inner) ? {
              default: () => children
            } : children)
          ];
        };
        const renderWindow = () => {
          const Container = vue.resolveDynamicComponent(props.containerElement);
          const { horizontalScrollbar, verticalScrollbar } = renderScrollbars();
          const Inner = renderInner();
          return vue.h("div", {
            key: 0,
            class: ns.e("wrapper"),
            role: props.role
          }, [
            vue.h(Container, {
              class: props.className,
              style: vue.unref(windowStyle),
              onScroll,
              ref: windowRef
            }, !isString$1(Container) ? { default: () => Inner } : Inner),
            horizontalScrollbar,
            verticalScrollbar
          ]);
        };
        return renderWindow;
      }
    });
  };
  var createGrid$1 = createGrid;

  const FixedSizeGrid = createGrid$1({
    name: "ElFixedSizeGrid",
    getColumnPosition: ({ columnWidth }, index) => [
      columnWidth,
      index * columnWidth
    ],
    getRowPosition: ({ rowHeight }, index) => [
      rowHeight,
      index * rowHeight
    ],
    getEstimatedTotalHeight: ({ totalRow, rowHeight }) => rowHeight * totalRow,
    getEstimatedTotalWidth: ({ totalColumn, columnWidth }) => columnWidth * totalColumn,
    getColumnOffset: ({ totalColumn, columnWidth, width }, columnIndex, alignment, scrollLeft, _, scrollBarWidth) => {
      width = Number(width);
      const lastColumnOffset = Math.max(0, totalColumn * columnWidth - width);
      const maxOffset = Math.min(lastColumnOffset, columnIndex * columnWidth);
      const minOffset = Math.max(0, columnIndex * columnWidth - width + scrollBarWidth + columnWidth);
      if (alignment === "smart") {
        if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
          alignment = AUTO_ALIGNMENT;
        } else {
          alignment = CENTERED_ALIGNMENT;
        }
      }
      switch (alignment) {
        case START_ALIGNMENT:
          return maxOffset;
        case END_ALIGNMENT:
          return minOffset;
        case CENTERED_ALIGNMENT: {
          const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
          if (middleOffset < Math.ceil(width / 2)) {
            return 0;
          } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
            return lastColumnOffset;
          } else {
            return middleOffset;
          }
        }
        case AUTO_ALIGNMENT:
        default:
          if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
            return scrollLeft;
          } else if (minOffset > maxOffset) {
            return minOffset;
          } else if (scrollLeft < minOffset) {
            return minOffset;
          } else {
            return maxOffset;
          }
      }
    },
    getRowOffset: ({ rowHeight, height, totalRow }, rowIndex, align, scrollTop, _, scrollBarWidth) => {
      height = Number(height);
      const lastRowOffset = Math.max(0, totalRow * rowHeight - height);
      const maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);
      const minOffset = Math.max(0, rowIndex * rowHeight - height + scrollBarWidth + rowHeight);
      if (align === SMART_ALIGNMENT) {
        if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
          align = AUTO_ALIGNMENT;
        } else {
          align = CENTERED_ALIGNMENT;
        }
      }
      switch (align) {
        case START_ALIGNMENT:
          return maxOffset;
        case END_ALIGNMENT:
          return minOffset;
        case CENTERED_ALIGNMENT: {
          const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
          if (middleOffset < Math.ceil(height / 2)) {
            return 0;
          } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
            return lastRowOffset;
          } else {
            return middleOffset;
          }
        }
        case AUTO_ALIGNMENT:
        default:
          if (scrollTop >= minOffset && scrollTop <= maxOffset) {
            return scrollTop;
          } else if (minOffset > maxOffset) {
            return minOffset;
          } else if (scrollTop < minOffset) {
            return minOffset;
          } else {
            return maxOffset;
          }
      }
    },
    getColumnStartIndexForOffset: ({ columnWidth, totalColumn }, scrollLeft) => Math.max(0, Math.min(totalColumn - 1, Math.floor(scrollLeft / columnWidth))),
    getColumnStopIndexForStartIndex: ({ columnWidth, totalColumn, width }, startIndex, scrollLeft) => {
      const left = startIndex * columnWidth;
      const visibleColumnsCount = Math.ceil((width + scrollLeft - left) / columnWidth);
      return Math.max(0, Math.min(totalColumn - 1, startIndex + visibleColumnsCount - 1));
    },
    getRowStartIndexForOffset: ({ rowHeight, totalRow }, scrollTop) => Math.max(0, Math.min(totalRow - 1, Math.floor(scrollTop / rowHeight))),
    getRowStopIndexForStartIndex: ({ rowHeight, totalRow, height }, startIndex, scrollTop) => {
      const top = startIndex * rowHeight;
      const numVisibleRows = Math.ceil((height + scrollTop - top) / rowHeight);
      return Math.max(0, Math.min(totalRow - 1, startIndex + numVisibleRows - 1));
    },
    initCache: () => void 0,
    clearCache: true,
    validateProps: ({ columnWidth, rowHeight }) => {
    }
  });
  var FixedSizeGrid$1 = FixedSizeGrid;

  const { max: max$2, min: min$2, floor } = Math;
  const ACCESS_SIZER_KEY_MAP = {
    column: "columnWidth",
    row: "rowHeight"
  };
  const ACCESS_LAST_VISITED_KEY_MAP = {
    column: "lastVisitedColumnIndex",
    row: "lastVisitedRowIndex"
  };
  const getItemFromCache = (props, index, gridCache, type) => {
    const [cachedItems, sizer, lastVisited] = [
      gridCache[type],
      props[ACCESS_SIZER_KEY_MAP[type]],
      gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]]
    ];
    if (index > lastVisited) {
      let offset = 0;
      if (lastVisited >= 0) {
        const item = cachedItems[lastVisited];
        offset = item.offset + item.size;
      }
      for (let i = lastVisited + 1; i <= index; i++) {
        const size = sizer(i);
        cachedItems[i] = {
          offset,
          size
        };
        offset += size;
      }
      gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]] = index;
    }
    return cachedItems[index];
  };
  const bs = (props, gridCache, low, high, offset, type) => {
    while (low <= high) {
      const mid = low + floor((high - low) / 2);
      const currentOffset = getItemFromCache(props, mid, gridCache, type).offset;
      if (currentOffset === offset) {
        return mid;
      } else if (currentOffset < offset) {
        low = mid + 1;
      } else {
        high = mid - 1;
      }
    }
    return max$2(0, low - 1);
  };
  const es = (props, gridCache, idx, offset, type) => {
    const total = type === "column" ? props.totalColumn : props.totalRow;
    let exponent = 1;
    while (idx < total && getItemFromCache(props, idx, gridCache, type).offset < offset) {
      idx += exponent;
      exponent *= 2;
    }
    return bs(props, gridCache, floor(idx / 2), min$2(idx, total - 1), offset, type);
  };
  const findItem = (props, gridCache, offset, type) => {
    const [cache, lastVisitedIndex] = [
      gridCache[type],
      gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]]
    ];
    const lastVisitedItemOffset = lastVisitedIndex > 0 ? cache[lastVisitedIndex].offset : 0;
    if (lastVisitedItemOffset >= offset) {
      return bs(props, gridCache, 0, lastVisitedIndex, offset, type);
    }
    return es(props, gridCache, max$2(0, lastVisitedIndex), offset, type);
  };
  const getEstimatedTotalHeight = ({ totalRow }, { estimatedRowHeight, lastVisitedRowIndex, row }) => {
    let sizeOfVisitedRows = 0;
    if (lastVisitedRowIndex >= totalRow) {
      lastVisitedRowIndex = totalRow - 1;
    }
    if (lastVisitedRowIndex >= 0) {
      const item = row[lastVisitedRowIndex];
      sizeOfVisitedRows = item.offset + item.size;
    }
    const unvisitedItems = totalRow - lastVisitedRowIndex - 1;
    const sizeOfUnvisitedItems = unvisitedItems * estimatedRowHeight;
    return sizeOfVisitedRows + sizeOfUnvisitedItems;
  };
  const getEstimatedTotalWidth = ({ totalColumn }, { column, estimatedColumnWidth, lastVisitedColumnIndex }) => {
    let sizeOfVisitedColumns = 0;
    if (lastVisitedColumnIndex > totalColumn) {
      lastVisitedColumnIndex = totalColumn - 1;
    }
    if (lastVisitedColumnIndex >= 0) {
      const item = column[lastVisitedColumnIndex];
      sizeOfVisitedColumns = item.offset + item.size;
    }
    const unvisitedItems = totalColumn - lastVisitedColumnIndex - 1;
    const sizeOfUnvisitedItems = unvisitedItems * estimatedColumnWidth;
    return sizeOfVisitedColumns + sizeOfUnvisitedItems;
  };
  const ACCESS_ESTIMATED_SIZE_KEY_MAP = {
    column: getEstimatedTotalWidth,
    row: getEstimatedTotalHeight
  };
  const getOffset$1 = (props, index, alignment, scrollOffset, cache, type, scrollBarWidth) => {
    const [size, estimatedSizeAssociates] = [
      type === "row" ? props.height : props.width,
      ACCESS_ESTIMATED_SIZE_KEY_MAP[type]
    ];
    const item = getItemFromCache(props, index, cache, type);
    const estimatedSize = estimatedSizeAssociates(props, cache);
    const maxOffset = max$2(0, min$2(estimatedSize - size, item.offset));
    const minOffset = max$2(0, item.offset - size + scrollBarWidth + item.size);
    if (alignment === SMART_ALIGNMENT) {
      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
        alignment = AUTO_ALIGNMENT;
      } else {
        alignment = CENTERED_ALIGNMENT;
      }
    }
    switch (alignment) {
      case START_ALIGNMENT: {
        return maxOffset;
      }
      case END_ALIGNMENT: {
        return minOffset;
      }
      case CENTERED_ALIGNMENT: {
        return Math.round(minOffset + (maxOffset - minOffset) / 2);
      }
      case AUTO_ALIGNMENT:
      default: {
        if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
          return scrollOffset;
        } else if (minOffset > maxOffset) {
          return minOffset;
        } else if (scrollOffset < minOffset) {
          return minOffset;
        } else {
          return maxOffset;
        }
      }
    }
  };
  const DynamicSizeGrid = createGrid$1({
    name: "ElDynamicSizeGrid",
    getColumnPosition: (props, idx, cache) => {
      const item = getItemFromCache(props, idx, cache, "column");
      return [item.size, item.offset];
    },
    getRowPosition: (props, idx, cache) => {
      const item = getItemFromCache(props, idx, cache, "row");
      return [item.size, item.offset];
    },
    getColumnOffset: (props, columnIndex, alignment, scrollLeft, cache, scrollBarWidth) => getOffset$1(props, columnIndex, alignment, scrollLeft, cache, "column", scrollBarWidth),
    getRowOffset: (props, rowIndex, alignment, scrollTop, cache, scrollBarWidth) => getOffset$1(props, rowIndex, alignment, scrollTop, cache, "row", scrollBarWidth),
    getColumnStartIndexForOffset: (props, scrollLeft, cache) => findItem(props, cache, scrollLeft, "column"),
    getColumnStopIndexForStartIndex: (props, startIndex, scrollLeft, cache) => {
      const item = getItemFromCache(props, startIndex, cache, "column");
      const maxOffset = scrollLeft + props.width;
      let offset = item.offset + item.size;
      let stopIndex = startIndex;
      while (stopIndex < props.totalColumn - 1 && offset < maxOffset) {
        stopIndex++;
        offset += getItemFromCache(props, startIndex, cache, "column").size;
      }
      return stopIndex;
    },
    getEstimatedTotalHeight,
    getEstimatedTotalWidth,
    getRowStartIndexForOffset: (props, scrollTop, cache) => findItem(props, cache, scrollTop, "row"),
    getRowStopIndexForStartIndex: (props, startIndex, scrollTop, cache) => {
      const { totalRow, height } = props;
      const item = getItemFromCache(props, startIndex, cache, "row");
      const maxOffset = scrollTop + height;
      let offset = item.size + item.offset;
      let stopIndex = startIndex;
      while (stopIndex < totalRow - 1 && offset < maxOffset) {
        stopIndex++;
        offset += getItemFromCache(props, stopIndex, cache, "row").size;
      }
      return stopIndex;
    },
    injectToInstance: (instance, cache) => {
      const resetAfter = ({ columnIndex, rowIndex }, forceUpdate) => {
        var _a, _b;
        forceUpdate = isUndefined(forceUpdate) ? true : forceUpdate;
        if (isNumber(columnIndex)) {
          cache.value.lastVisitedColumnIndex = Math.min(cache.value.lastVisitedColumnIndex, columnIndex - 1);
        }
        if (isNumber(rowIndex)) {
          cache.value.lastVisitedRowIndex = Math.min(cache.value.lastVisitedRowIndex, rowIndex - 1);
        }
        (_a = instance.exposed) == null ? void 0 : _a.getItemStyleCache.value(-1, null, null);
        if (forceUpdate)
          (_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
      };
      const resetAfterColumnIndex = (columnIndex, forceUpdate) => {
        resetAfter({
          columnIndex
        }, forceUpdate);
      };
      const resetAfterRowIndex = (rowIndex, forceUpdate) => {
        resetAfter({
          rowIndex
        }, forceUpdate);
      };
      Object.assign(instance.proxy, {
        resetAfterColumnIndex,
        resetAfterRowIndex,
        resetAfter
      });
    },
    initCache: ({
      estimatedColumnWidth = DEFAULT_DYNAMIC_LIST_ITEM_SIZE,
      estimatedRowHeight = DEFAULT_DYNAMIC_LIST_ITEM_SIZE
    }) => {
      const cache = {
        column: {},
        estimatedColumnWidth,
        estimatedRowHeight,
        lastVisitedColumnIndex: -1,
        lastVisitedRowIndex: -1,
        row: {}
      };
      return cache;
    },
    clearCache: false,
    validateProps: ({ columnWidth, rowHeight }) => {
    }
  });
  var DynamicSizeGrid$1 = DynamicSizeGrid;

  const _sfc_main$L = vue.defineComponent({
    props: {
      item: {
        type: Object,
        required: true
      },
      style: {
        type: Object
      },
      height: Number
    },
    setup() {
      const ns = useNamespace("select");
      return {
        ns
      };
    }
  });
  function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("div", {
      class: vue.normalizeClass(_ctx.ns.be("group", "title")),
      style: vue.normalizeStyle({ ..._ctx.style, lineHeight: `${_ctx.height}px` })
    }, vue.toDisplayString(_ctx.item.label), 7);
  }
  var GroupItem = /* @__PURE__ */ _export_sfc(_sfc_main$L, [["render", _sfc_render$7], ["__file", "group-item.vue"]]);

  function useOption(props, { emit }) {
    return {
      hoverItem: () => {
        if (!props.disabled) {
          emit("hover", props.index);
        }
      },
      selectOptionClick: () => {
        if (!props.disabled) {
          emit("select", props.item, props.index);
        }
      }
    };
  }

  const selectV2Props = buildProps({
    allowCreate: Boolean,
    autocomplete: {
      type: definePropType(String),
      default: "none"
    },
    automaticDropdown: Boolean,
    clearable: Boolean,
    clearIcon: {
      type: iconPropType,
      default: circle_close_default
    },
    effect: {
      type: definePropType(String),
      default: "light"
    },
    collapseTags: Boolean,
    collapseTagsTooltip: Boolean,
    maxCollapseTags: {
      type: Number,
      default: 1
    },
    defaultFirstOption: Boolean,
    disabled: Boolean,
    estimatedOptionHeight: {
      type: Number,
      default: void 0
    },
    filterable: Boolean,
    filterMethod: {
      type: definePropType(Function)
    },
    height: {
      type: Number,
      default: 274
    },
    itemHeight: {
      type: Number,
      default: 34
    },
    id: String,
    loading: Boolean,
    loadingText: String,
    modelValue: {
      type: definePropType([Array, String, Number, Boolean, Object]),
      default: void 0
    },
    multiple: Boolean,
    multipleLimit: {
      type: Number,
      default: 0
    },
    name: String,
    noDataText: String,
    noMatchText: String,
    remoteMethod: {
      type: definePropType(Function)
    },
    reserveKeyword: {
      type: Boolean,
      default: true
    },
    options: {
      type: definePropType(Array),
      required: true
    },
    placeholder: {
      type: String
    },
    teleported: useTooltipContentProps.teleported,
    persistent: {
      type: Boolean,
      default: true
    },
    popperClass: useTooltipContentProps.popperClass,
    popperStyle: useTooltipContentProps.popperStyle,
    popperOptions: {
      type: definePropType(Object),
      default: () => ({})
    },
    remote: Boolean,
    debounce: {
      type: Number,
      default: 300
    },
    size: useSizeProp,
    props: {
      type: definePropType(Object),
      default: () => defaultProps$5
    },
    valueKey: {
      type: String,
      default: "value"
    },
    scrollbarAlwaysOn: Boolean,
    validateEvent: {
      type: Boolean,
      default: true
    },
    offset: {
      type: Number,
      default: 12
    },
    showArrow: {
      type: Boolean,
      default: true
    },
    placement: {
      type: definePropType(String),
      values: Ee,
      default: "bottom-start"
    },
    fallbackPlacements: {
      type: definePropType(Array),
      default: ["bottom-start", "top-start", "right", "left"]
    },
    tagType: { ...tagProps.type, default: "info" },
    tagEffect: { ...tagProps.effect, default: "light" },
    tabindex: {
      type: [String, Number],
      default: 0
    },
    appendTo: useTooltipContentProps.appendTo,
    fitInputWidth: {
      type: [Boolean, Number],
      default: true,
      validator(val) {
        return isBoolean(val) || isNumber(val);
      }
    },
    suffixIcon: {
      type: iconPropType,
      default: arrow_down_default
    },
    ...useEmptyValuesProps,
    ...useAriaProps(["ariaLabel"])
  });
  const optionV2Props = buildProps({
    data: Array,
    disabled: Boolean,
    hovering: Boolean,
    item: {
      type: definePropType(Object),
      required: true
    },
    index: Number,
    style: Object,
    selected: Boolean,
    created: Boolean
  });
  const selectV2Emits = {
    [UPDATE_MODEL_EVENT]: (val) => true,
    [CHANGE_EVENT]: (val) => true,
    "remove-tag": (val) => true,
    "visible-change": (visible) => true,
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent,
    clear: () => true
  };
  const optionV2Emits = {
    hover: (index) => isNumber(index),
    select: (val, index) => true
  };

  const selectV2InjectionKey = Symbol("ElSelectV2Injection");

  const _sfc_main$K = vue.defineComponent({
    props: optionV2Props,
    emits: optionV2Emits,
    setup(props, { emit }) {
      const select = vue.inject(selectV2InjectionKey);
      const ns = useNamespace("select");
      const { hoverItem, selectOptionClick } = useOption(props, { emit });
      const { getLabel } = useProps(select.props);
      const contentId = select.contentId;
      return {
        ns,
        contentId,
        hoverItem,
        selectOptionClick,
        getLabel
      };
    }
  });
  function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("li", {
      id: `${_ctx.contentId}-${_ctx.index}`,
      role: "option",
      "aria-selected": _ctx.selected,
      "aria-disabled": _ctx.disabled || void 0,
      style: vue.normalizeStyle(_ctx.style),
      class: vue.normalizeClass([
        _ctx.ns.be("dropdown", "item"),
        _ctx.ns.is("selected", _ctx.selected),
        _ctx.ns.is("disabled", _ctx.disabled),
        _ctx.ns.is("created", _ctx.created),
        _ctx.ns.is("hovering", _ctx.hovering)
      ]),
      onMousemove: _ctx.hoverItem,
      onClick: vue.withModifiers(_ctx.selectOptionClick, ["stop"])
    }, [
      vue.renderSlot(_ctx.$slots, "default", {
        item: _ctx.item,
        index: _ctx.index,
        disabled: _ctx.disabled
      }, () => [
        vue.createElementVNode("span", null, vue.toDisplayString(_ctx.getLabel(_ctx.item)), 1)
      ])
    ], 46, ["id", "aria-selected", "aria-disabled", "onMousemove", "onClick"]);
  }
  var OptionItem = /* @__PURE__ */ _export_sfc(_sfc_main$K, [["render", _sfc_render$6], ["__file", "option-item.vue"]]);

  const props = {
    loading: Boolean,
    data: {
      type: Array,
      required: true
    },
    hoveringIndex: Number,
    width: Number,
    id: String,
    ariaLabel: String
  };
  var ElSelectMenu = vue.defineComponent({
    name: "ElSelectDropdown",
    props,
    setup(props2, {
      slots,
      expose
    }) {
      const select = vue.inject(selectV2InjectionKey);
      const ns = useNamespace("select");
      const {
        getLabel,
        getValue,
        getDisabled
      } = useProps(select.props);
      const cachedHeights = vue.ref([]);
      const listRef = vue.ref();
      const size = vue.computed(() => props2.data.length);
      vue.watch(() => size.value, () => {
        var _a, _b;
        (_b = (_a = select.tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
      });
      const isSized = vue.computed(() => isUndefined(select.props.estimatedOptionHeight));
      const listProps = vue.computed(() => {
        if (isSized.value) {
          return {
            itemSize: select.props.itemHeight
          };
        }
        return {
          estimatedSize: select.props.estimatedOptionHeight,
          itemSize: (idx) => cachedHeights.value[idx]
        };
      });
      const contains = (arr = [], target) => {
        const {
          props: {
            valueKey
          }
        } = select;
        if (!isObject$1(target)) {
          return arr.includes(target);
        }
        return arr && arr.some((item) => {
          return vue.toRaw(get(item, valueKey)) === get(target, valueKey);
        });
      };
      const isEqual = (selected, target) => {
        if (!isObject$1(target)) {
          return selected === target;
        } else {
          const {
            valueKey
          } = select.props;
          return get(selected, valueKey) === get(target, valueKey);
        }
      };
      const isItemSelected = (modelValue, target) => {
        if (select.props.multiple) {
          return contains(modelValue, getValue(target));
        }
        return isEqual(modelValue, getValue(target));
      };
      const isItemDisabled = (modelValue, selected) => {
        const {
          disabled,
          multiple,
          multipleLimit
        } = select.props;
        return disabled || !selected && (multiple ? multipleLimit > 0 && modelValue.length >= multipleLimit : false);
      };
      const isItemHovering = (target) => props2.hoveringIndex === target;
      const scrollToItem = (index) => {
        const list = listRef.value;
        if (list) {
          list.scrollToItem(index);
        }
      };
      const resetScrollTop = () => {
        const list = listRef.value;
        if (list) {
          list.resetScrollTop();
        }
      };
      const exposed = {
        listRef,
        isSized,
        isItemDisabled,
        isItemHovering,
        isItemSelected,
        scrollToItem,
        resetScrollTop
      };
      expose(exposed);
      const Item = (itemProps) => {
        const {
          index,
          data,
          style
        } = itemProps;
        const sized = vue.unref(isSized);
        const {
          itemSize,
          estimatedSize
        } = vue.unref(listProps);
        const {
          modelValue
        } = select.props;
        const {
          onSelect,
          onHover
        } = select;
        const item = data[index];
        if (item.type === "Group") {
          return vue.createVNode(GroupItem, {
            "item": item,
            "style": style,
            "height": sized ? itemSize : estimatedSize
          }, null);
        }
        const isSelected = isItemSelected(modelValue, item);
        const isDisabled = isItemDisabled(modelValue, isSelected);
        const isHovering = isItemHovering(index);
        return vue.createVNode(OptionItem, vue.mergeProps(itemProps, {
          "selected": isSelected,
          "disabled": getDisabled(item) || isDisabled,
          "created": !!item.created,
          "hovering": isHovering,
          "item": item,
          "onSelect": onSelect,
          "onHover": onHover
        }), {
          default: (props3) => {
            var _a;
            return ((_a = slots.default) == null ? void 0 : _a.call(slots, props3)) || vue.createVNode("span", null, [getLabel(item)]);
          }
        });
      };
      const {
        onKeyboardNavigate,
        onKeyboardSelect
      } = select;
      const onForward = () => {
        onKeyboardNavigate("forward");
      };
      const onBackward = () => {
        onKeyboardNavigate("backward");
      };
      const onKeydown = (e) => {
        const code = getEventCode(e);
        const {
          tab,
          esc,
          down,
          up,
          enter,
          numpadEnter
        } = EVENT_CODE;
        if ([esc, down, up, enter, numpadEnter].includes(code)) {
          e.preventDefault();
          e.stopPropagation();
        }
        switch (code) {
          case tab:
          case esc:
            break;
          case down:
            onForward();
            break;
          case up:
            onBackward();
            break;
          case enter:
          case numpadEnter:
            onKeyboardSelect();
            break;
        }
      };
      return () => {
        var _a, _b, _c, _d;
        const {
          data,
          width
        } = props2;
        const {
          height,
          multiple,
          scrollbarAlwaysOn
        } = select.props;
        const isScrollbarAlwaysOn = vue.computed(() => {
          return isIOS ? true : scrollbarAlwaysOn;
        });
        const List = vue.unref(isSized) ? FixedSizeList$1 : DynamicSizeList$1;
        return vue.createVNode("div", {
          "class": [ns.b("dropdown"), ns.is("multiple", multiple)],
          "style": {
            width: `${width}px`
          }
        }, [(_a = slots.header) == null ? void 0 : _a.call(slots), ((_b = slots.loading) == null ? void 0 : _b.call(slots)) || ((_c = slots.empty) == null ? void 0 : _c.call(slots)) || vue.createVNode(List, vue.mergeProps({
          "ref": listRef
        }, vue.unref(listProps), {
          "className": ns.be("dropdown", "list"),
          "scrollbarAlwaysOn": isScrollbarAlwaysOn.value,
          "data": data,
          "height": height,
          "width": width,
          "total": data.length,
          "innerElement": "ul",
          "innerProps": {
            id: props2.id,
            role: "listbox",
            "aria-label": props2.ariaLabel,
            "aria-orientation": "vertical"
          },
          "onKeydown": onKeydown
        }), {
          default: (props3) => vue.createVNode(Item, props3, null)
        }), (_d = slots.footer) == null ? void 0 : _d.call(slots)]);
      };
    }
  });

  function useAllowCreate(props, states) {
    const { aliasProps, getLabel, getValue } = useProps(props);
    const createOptionCount = vue.ref(0);
    const cachedSelectedOption = vue.ref();
    const enableAllowCreateMode = vue.computed(() => {
      return props.allowCreate && props.filterable;
    });
    vue.watch(() => props.options, (options) => {
      const optionLabelsSet = new Set(options.map((option) => getLabel(option)));
      states.createdOptions = states.createdOptions.filter((createdOption) => !optionLabelsSet.has(getLabel(createdOption)));
    });
    function hasExistingOption(query) {
      const hasOption = (option) => getLabel(option) === query;
      return props.options && props.options.some(hasOption) || states.createdOptions.some(hasOption);
    }
    function selectNewOption(option) {
      if (!enableAllowCreateMode.value) {
        return;
      }
      if (props.multiple && option.created) {
        createOptionCount.value++;
      } else {
        cachedSelectedOption.value = option;
      }
    }
    function createNewOption(query) {
      if (enableAllowCreateMode.value) {
        if (query && query.length > 0) {
          if (hasExistingOption(query)) {
            states.createdOptions = states.createdOptions.filter((createdOption) => getLabel(createdOption) !== states.previousQuery);
            return;
          }
          const newOption = {
            [aliasProps.value.value]: query,
            [aliasProps.value.label]: query,
            created: true,
            [aliasProps.value.disabled]: false
          };
          if (states.createdOptions.length >= createOptionCount.value) {
            states.createdOptions[createOptionCount.value] = newOption;
          } else {
            states.createdOptions.push(newOption);
          }
        } else {
          if (props.multiple) {
            states.createdOptions.length = createOptionCount.value;
          } else {
            const selectedOption = cachedSelectedOption.value;
            states.createdOptions.length = 0;
            if (selectedOption && selectedOption.created) {
              states.createdOptions.push(selectedOption);
            }
          }
        }
      }
    }
    function removeNewOption(option) {
      if (!enableAllowCreateMode.value || !option || !option.created || option.created && props.reserveKeyword && states.inputValue === getLabel(option)) {
        return;
      }
      const idx = states.createdOptions.findIndex((it) => getValue(it) === getValue(option));
      if (~idx) {
        states.createdOptions.splice(idx, 1);
        createOptionCount.value--;
      }
    }
    function clearAllNewOption() {
      if (enableAllowCreateMode.value) {
        states.createdOptions.length = 0;
        createOptionCount.value = 0;
      }
    }
    return {
      createNewOption,
      removeNewOption,
      selectNewOption,
      clearAllNewOption
    };
  }

  const useSelect$1 = (props, emit) => {
    const { t } = useLocale();
    const nsSelect = useNamespace("select");
    const nsInput = useNamespace("input");
    const { form: elForm, formItem: elFormItem } = useFormItem();
    const { inputId } = useFormItemInputId(props, {
      formItemContext: elFormItem
    });
    const { aliasProps, getLabel, getValue, getDisabled, getOptions } = useProps(props);
    const { valueOnClear, isEmptyValue } = useEmptyValues(props);
    const states = vue.reactive({
      inputValue: "",
      cachedOptions: [],
      createdOptions: [],
      hoveringIndex: -1,
      inputHovering: false,
      selectionWidth: 0,
      collapseItemWidth: 0,
      previousQuery: null,
      previousValue: void 0,
      selectedLabel: "",
      menuVisibleOnFocus: false,
      isBeforeHide: false
    });
    const popperSize = vue.ref(-1);
    const debouncing = vue.ref(false);
    const selectRef = vue.ref();
    const selectionRef = vue.ref();
    const tooltipRef = vue.ref();
    const tagTooltipRef = vue.ref();
    const inputRef = vue.ref();
    const prefixRef = vue.ref();
    const suffixRef = vue.ref();
    const menuRef = vue.ref();
    const tagMenuRef = vue.ref();
    const collapseItemRef = vue.ref();
    const {
      isComposing,
      handleCompositionStart,
      handleCompositionEnd,
      handleCompositionUpdate
    } = useComposition({
      afterComposition: (e) => onInput(e)
    });
    const selectDisabled = vue.computed(() => props.disabled || !!(elForm == null ? void 0 : elForm.disabled));
    const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
      disabled: selectDisabled,
      afterFocus() {
        if (props.automaticDropdown && !expanded.value) {
          expanded.value = true;
          states.menuVisibleOnFocus = true;
        }
      },
      beforeBlur(event) {
        var _a, _b;
        return ((_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
      },
      afterBlur() {
        var _a;
        expanded.value = false;
        states.menuVisibleOnFocus = false;
        if (props.validateEvent) {
          (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "blur").catch((err) => debugWarn(err));
        }
      }
    });
    const allOptions = vue.computed(() => filterOptions(""));
    const hasOptions = vue.computed(() => {
      if (props.loading)
        return false;
      return props.options.length > 0 || states.createdOptions.length > 0;
    });
    const filteredOptions = vue.ref([]);
    const expanded = vue.ref(false);
    const needStatusIcon = vue.computed(() => {
      var _a;
      return (_a = elForm == null ? void 0 : elForm.statusIcon) != null ? _a : false;
    });
    const popupHeight = vue.computed(() => {
      const totalHeight = filteredOptions.value.length * props.itemHeight;
      return totalHeight > props.height ? props.height : totalHeight;
    });
    const hasModelValue = vue.computed(() => {
      return props.multiple ? isArray$1(props.modelValue) && props.modelValue.length > 0 : !isEmptyValue(props.modelValue);
    });
    const showClearBtn = vue.computed(() => {
      return props.clearable && !selectDisabled.value && hasModelValue.value && (isFocused.value || states.inputHovering);
    });
    const iconComponent = vue.computed(() => props.remote && props.filterable ? "" : props.suffixIcon);
    const iconReverse = vue.computed(() => iconComponent.value && nsSelect.is("reverse", expanded.value));
    const validateState = vue.computed(() => (elFormItem == null ? void 0 : elFormItem.validateState) || "");
    const validateIcon = vue.computed(() => {
      if (!validateState.value)
        return;
      return ValidateComponentsMap[validateState.value];
    });
    const debounce = vue.computed(() => props.remote ? props.debounce : 0);
    const isRemoteSearchEmpty = vue.computed(() => props.remote && !states.inputValue && !hasOptions.value);
    const emptyText = vue.computed(() => {
      if (props.loading) {
        return props.loadingText || t("el.select.loading");
      } else {
        if (props.filterable && states.inputValue && hasOptions.value && filteredOptions.value.length === 0) {
          return props.noMatchText || t("el.select.noMatch");
        }
        if (!hasOptions.value) {
          return props.noDataText || t("el.select.noData");
        }
      }
      return null;
    });
    const isFilterMethodValid = vue.computed(() => props.filterable && isFunction$1(props.filterMethod));
    const isRemoteMethodValid = vue.computed(() => props.filterable && props.remote && isFunction$1(props.remoteMethod));
    const filterOptions = (query) => {
      const regexp = new RegExp(escapeStringRegexp(query), "i");
      const isValidOption = (o) => {
        if (isFilterMethodValid.value || isRemoteMethodValid.value)
          return true;
        return query ? regexp.test(getLabel(o) || "") : true;
      };
      if (props.loading) {
        return [];
      }
      return [...states.createdOptions, ...props.options].reduce((all, item) => {
        const options = getOptions(item);
        if (isArray$1(options)) {
          const filtered = options.filter(isValidOption);
          if (filtered.length > 0) {
            all.push({
              label: getLabel(item),
              type: "Group"
            }, ...filtered);
          }
        } else if (props.remote || isValidOption(item)) {
          all.push(item);
        }
        return all;
      }, []);
    };
    const updateOptions = () => {
      filteredOptions.value = filterOptions(states.inputValue);
    };
    const allOptionsValueMap = vue.computed(() => {
      const valueMap = /* @__PURE__ */ new Map();
      allOptions.value.forEach((option, index) => {
        valueMap.set(getValueKey(getValue(option)), { option, index });
      });
      return valueMap;
    });
    const filteredOptionsValueMap = vue.computed(() => {
      const valueMap = /* @__PURE__ */ new Map();
      filteredOptions.value.forEach((option, index) => {
        valueMap.set(getValueKey(getValue(option)), { option, index });
      });
      return valueMap;
    });
    const optionsAllDisabled = vue.computed(() => filteredOptions.value.every((option) => getDisabled(option)));
    const selectSize = useFormSize();
    const collapseTagSize = vue.computed(() => selectSize.value === "small" ? "small" : "default");
    const calculatePopperSize = () => {
      var _a;
      if (isNumber(props.fitInputWidth)) {
        popperSize.value = props.fitInputWidth;
        return;
      }
      const width = ((_a = selectRef.value) == null ? void 0 : _a.offsetWidth) || 200;
      if (!props.fitInputWidth && hasOptions.value) {
        vue.nextTick(() => {
          popperSize.value = Math.max(width, calculateLabelMaxWidth());
        });
      } else {
        popperSize.value = width;
      }
    };
    const calculateLabelMaxWidth = () => {
      var _a, _b;
      const canvas = document.createElement("canvas");
      const ctx = canvas.getContext("2d");
      const selector = nsSelect.be("dropdown", "item");
      const dom = ((_b = (_a = menuRef.value) == null ? void 0 : _a.listRef) == null ? void 0 : _b.innerRef) || document;
      const dropdownItemEl = dom.querySelector(`.${selector}`);
      if (dropdownItemEl === null || ctx === null)
        return 0;
      const style = getComputedStyle(dropdownItemEl);
      const padding = Number.parseFloat(style.paddingLeft) + Number.parseFloat(style.paddingRight);
      ctx.font = `bold ${style.font.replace(new RegExp(`\\b${style.fontWeight}\\b`), "")}`;
      const maxWidth = filteredOptions.value.reduce((max, option) => {
        const metrics = ctx.measureText(getLabel(option));
        return Math.max(metrics.width, max);
      }, 0);
      return maxWidth + padding;
    };
    const getGapWidth = () => {
      if (!selectionRef.value)
        return 0;
      const style = window.getComputedStyle(selectionRef.value);
      return Number.parseFloat(style.gap || "6px");
    };
    const tagStyle = vue.computed(() => {
      const gapWidth = getGapWidth();
      const inputSlotWidth = props.filterable ? gapWidth + MINIMUM_INPUT_WIDTH : 0;
      const maxWidth = collapseItemRef.value && props.maxCollapseTags === 1 ? states.selectionWidth - states.collapseItemWidth - gapWidth - inputSlotWidth : states.selectionWidth - inputSlotWidth;
      return { maxWidth: `${maxWidth}px` };
    });
    const collapseTagStyle = vue.computed(() => {
      return { maxWidth: `${states.selectionWidth}px` };
    });
    const shouldShowPlaceholder = vue.computed(() => {
      if (isArray$1(props.modelValue)) {
        return props.modelValue.length === 0 && !states.inputValue;
      }
      return props.filterable ? !states.inputValue : true;
    });
    const currentPlaceholder = vue.computed(() => {
      var _a;
      const _placeholder = (_a = props.placeholder) != null ? _a : t("el.select.placeholder");
      return props.multiple || !hasModelValue.value ? _placeholder : states.selectedLabel;
    });
    const popperRef = vue.computed(() => {
      var _a, _b;
      return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
    });
    const indexRef = vue.computed(() => {
      if (props.multiple) {
        const len = props.modelValue.length;
        if (props.modelValue.length > 0 && filteredOptionsValueMap.value.has(props.modelValue[len - 1])) {
          const { index } = filteredOptionsValueMap.value.get(props.modelValue[len - 1]);
          return index;
        }
      } else {
        if (!isEmptyValue(props.modelValue) && filteredOptionsValueMap.value.has(props.modelValue)) {
          const { index } = filteredOptionsValueMap.value.get(props.modelValue);
          return index;
        }
      }
      return -1;
    });
    const dropdownMenuVisible = vue.computed({
      get() {
        return expanded.value && (props.loading || !isRemoteSearchEmpty.value) && (!debouncing.value || !isEmpty(states.previousQuery));
      },
      set(val) {
        expanded.value = val;
      }
    });
    const showTagList = vue.computed(() => {
      if (!props.multiple) {
        return [];
      }
      return props.collapseTags ? states.cachedOptions.slice(0, props.maxCollapseTags) : states.cachedOptions;
    });
    const collapseTagList = vue.computed(() => {
      if (!props.multiple) {
        return [];
      }
      return props.collapseTags ? states.cachedOptions.slice(props.maxCollapseTags) : [];
    });
    const {
      createNewOption,
      removeNewOption,
      selectNewOption,
      clearAllNewOption
    } = useAllowCreate(props, states);
    const toggleMenu = () => {
      if (selectDisabled.value)
        return;
      if (states.menuVisibleOnFocus) {
        states.menuVisibleOnFocus = false;
      } else {
        expanded.value = !expanded.value;
      }
    };
    const onInputChange = () => {
      if (states.inputValue.length > 0 && !expanded.value) {
        expanded.value = true;
      }
      createNewOption(states.inputValue);
      vue.nextTick(() => {
        handleQueryChange(states.inputValue);
      });
    };
    const debouncedOnInputChange = useDebounceFn(() => {
      onInputChange();
      debouncing.value = false;
    }, debounce);
    const handleQueryChange = (val) => {
      if (states.previousQuery === val || isComposing.value) {
        return;
      }
      states.previousQuery = val;
      if (props.filterable && isFunction$1(props.filterMethod)) {
        props.filterMethod(val);
      } else if (props.filterable && props.remote && isFunction$1(props.remoteMethod)) {
        props.remoteMethod(val);
      }
      if (props.defaultFirstOption && (props.filterable || props.remote) && filteredOptions.value.length) {
        vue.nextTick(checkDefaultFirstOption);
      } else {
        vue.nextTick(updateHoveringIndex);
      }
    };
    const checkDefaultFirstOption = () => {
      const optionsInDropdown = filteredOptions.value.filter((n) => !n.disabled && n.type !== "Group");
      const userCreatedOption = optionsInDropdown.find((n) => n.created);
      const firstOriginOption = optionsInDropdown[0];
      states.hoveringIndex = getValueIndex(filteredOptions.value, userCreatedOption || firstOriginOption);
    };
    const emitChange = (val) => {
      if (!isEqual$1(props.modelValue, val)) {
        emit(CHANGE_EVENT, val);
      }
    };
    const update = (val) => {
      emit(UPDATE_MODEL_EVENT, val);
      emitChange(val);
      states.previousValue = props.multiple ? String(val) : val;
      vue.nextTick(() => {
        if (props.multiple && isArray$1(props.modelValue)) {
          const cachedOptions = states.cachedOptions.slice();
          const selectedOptions = props.modelValue.map((value) => getOption(value, cachedOptions));
          if (!isEqual$1(states.cachedOptions, selectedOptions)) {
            states.cachedOptions = selectedOptions;
          }
        } else {
          initStates(true);
        }
      });
    };
    const getValueIndex = (arr = [], value) => {
      if (!isObject$1(value)) {
        return arr.indexOf(value);
      }
      const valueKey = props.valueKey;
      let index = -1;
      arr.some((item, i) => {
        if (get(item, valueKey) === get(value, valueKey)) {
          index = i;
          return true;
        }
        return false;
      });
      return index;
    };
    const getValueKey = (item) => {
      return isObject$1(item) ? get(item, props.valueKey) : item;
    };
    const handleResize = () => {
      calculatePopperSize();
    };
    const resetSelectionWidth = () => {
      states.selectionWidth = Number.parseFloat(window.getComputedStyle(selectionRef.value).width);
    };
    const resetCollapseItemWidth = () => {
      states.collapseItemWidth = collapseItemRef.value.getBoundingClientRect().width;
    };
    const updateTooltip = () => {
      var _a, _b;
      (_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
    };
    const updateTagTooltip = () => {
      var _a, _b;
      (_b = (_a = tagTooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
    };
    const onSelect = (option) => {
      const optionValue = getValue(option);
      if (props.multiple) {
        let selectedOptions = props.modelValue.slice();
        const index = getValueIndex(selectedOptions, optionValue);
        if (index > -1) {
          selectedOptions = [
            ...selectedOptions.slice(0, index),
            ...selectedOptions.slice(index + 1)
          ];
          states.cachedOptions.splice(index, 1);
          removeNewOption(option);
        } else if (props.multipleLimit <= 0 || selectedOptions.length < props.multipleLimit) {
          selectedOptions = [...selectedOptions, optionValue];
          states.cachedOptions.push(option);
          selectNewOption(option);
        }
        update(selectedOptions);
        if (option.created) {
          handleQueryChange("");
        }
        if (props.filterable && !props.reserveKeyword) {
          states.inputValue = "";
        }
      } else {
        states.selectedLabel = getLabel(option);
        !isEqual$1(props.modelValue, optionValue) && update(optionValue);
        expanded.value = false;
        selectNewOption(option);
        if (!option.created) {
          clearAllNewOption();
        }
      }
      focus();
    };
    const deleteTag = (event, option) => {
      let selectedOptions = props.modelValue.slice();
      const index = getValueIndex(selectedOptions, getValue(option));
      if (index > -1 && !selectDisabled.value) {
        selectedOptions = [
          ...props.modelValue.slice(0, index),
          ...props.modelValue.slice(index + 1)
        ];
        states.cachedOptions.splice(index, 1);
        update(selectedOptions);
        emit("remove-tag", getValue(option));
        removeNewOption(option);
      }
      event.stopPropagation();
      focus();
    };
    const focus = () => {
      var _a;
      (_a = inputRef.value) == null ? void 0 : _a.focus();
    };
    const blur = () => {
      var _a;
      if (expanded.value) {
        expanded.value = false;
        vue.nextTick(() => {
          var _a2;
          return (_a2 = inputRef.value) == null ? void 0 : _a2.blur();
        });
        return;
      }
      (_a = inputRef.value) == null ? void 0 : _a.blur();
    };
    const handleEsc = () => {
      if (states.inputValue.length > 0) {
        states.inputValue = "";
      } else {
        expanded.value = false;
      }
    };
    const getLastNotDisabledIndex = (value) => findLastIndex(value, (it) => !states.cachedOptions.some((option) => getValue(option) === it && getDisabled(option)));
    const handleDel = (e) => {
      const code = getEventCode(e);
      if (!props.multiple)
        return;
      if (code === EVENT_CODE.delete)
        return;
      if (states.inputValue.length === 0) {
        e.preventDefault();
        const selected = props.modelValue.slice();
        const lastNotDisabledIndex = getLastNotDisabledIndex(selected);
        if (lastNotDisabledIndex < 0)
          return;
        const removeTagValue = selected[lastNotDisabledIndex];
        selected.splice(lastNotDisabledIndex, 1);
        const option = states.cachedOptions[lastNotDisabledIndex];
        states.cachedOptions.splice(lastNotDisabledIndex, 1);
        removeNewOption(option);
        update(selected);
        emit("remove-tag", removeTagValue);
      }
    };
    const handleClear = () => {
      let emptyValue;
      if (isArray$1(props.modelValue)) {
        emptyValue = [];
      } else {
        emptyValue = valueOnClear.value;
      }
      states.selectedLabel = "";
      expanded.value = false;
      update(emptyValue);
      emit("clear");
      clearAllNewOption();
      focus();
    };
    const onKeyboardNavigate = (direction, hoveringIndex = void 0) => {
      const options = filteredOptions.value;
      if (!["forward", "backward"].includes(direction) || selectDisabled.value || options.length <= 0 || optionsAllDisabled.value || isComposing.value) {
        return;
      }
      if (!expanded.value) {
        return toggleMenu();
      }
      if (isUndefined(hoveringIndex)) {
        hoveringIndex = states.hoveringIndex;
      }
      let newIndex = -1;
      if (direction === "forward") {
        newIndex = hoveringIndex + 1;
        if (newIndex >= options.length) {
          newIndex = 0;
        }
      } else if (direction === "backward") {
        newIndex = hoveringIndex - 1;
        if (newIndex < 0 || newIndex >= options.length) {
          newIndex = options.length - 1;
        }
      }
      const option = options[newIndex];
      if (getDisabled(option) || option.type === "Group") {
        return onKeyboardNavigate(direction, newIndex);
      } else {
        states.hoveringIndex = newIndex;
        scrollToItem(newIndex);
      }
    };
    const onKeyboardSelect = () => {
      if (!expanded.value) {
        return toggleMenu();
      } else if (~states.hoveringIndex && filteredOptions.value[states.hoveringIndex]) {
        onSelect(filteredOptions.value[states.hoveringIndex]);
      }
    };
    const onHoverOption = (idx) => {
      states.hoveringIndex = idx != null ? idx : -1;
    };
    const updateHoveringIndex = () => {
      if (!props.multiple) {
        states.hoveringIndex = filteredOptions.value.findIndex((item) => {
          return getValueKey(getValue(item)) === getValueKey(props.modelValue);
        });
      } else {
        states.hoveringIndex = filteredOptions.value.findIndex((item) => props.modelValue.some((modelValue) => getValueKey(modelValue) === getValueKey(getValue(item))));
      }
    };
    const onInput = (event) => {
      states.inputValue = event.target.value;
      if (props.remote) {
        debouncing.value = true;
        debouncedOnInputChange();
      } else {
        return onInputChange();
      }
    };
    const handleClickOutside = (event) => {
      expanded.value = false;
      if (isFocused.value) {
        const _event = new FocusEvent("blur", event);
        handleBlur(_event);
      }
    };
    const handleMenuEnter = () => {
      states.isBeforeHide = false;
      return vue.nextTick(() => {
        if (~indexRef.value) {
          scrollToItem(states.hoveringIndex);
        }
      });
    };
    const scrollToItem = (index) => {
      menuRef.value.scrollToItem(index);
    };
    const getOption = (value, cachedOptions) => {
      const selectValue = getValueKey(value);
      if (allOptionsValueMap.value.has(selectValue)) {
        const { option } = allOptionsValueMap.value.get(selectValue);
        return option;
      }
      if (cachedOptions && cachedOptions.length) {
        const option = cachedOptions.find((option2) => getValueKey(getValue(option2)) === selectValue);
        if (option) {
          return option;
        }
      }
      return {
        [aliasProps.value.value]: value,
        [aliasProps.value.label]: value
      };
    };
    const getIndex = (option) => {
      var _a, _b;
      return (_b = (_a = allOptionsValueMap.value.get(getValue(option))) == null ? void 0 : _a.index) != null ? _b : -1;
    };
    const initStates = (needUpdateSelectedLabel = false) => {
      if (props.multiple) {
        if (props.modelValue.length > 0) {
          const cachedOptions = states.cachedOptions.slice();
          states.cachedOptions.length = 0;
          states.previousValue = props.modelValue.toString();
          for (const value of props.modelValue) {
            const option = getOption(value, cachedOptions);
            states.cachedOptions.push(option);
          }
        } else {
          states.cachedOptions = [];
          states.previousValue = void 0;
        }
      } else {
        if (hasModelValue.value) {
          states.previousValue = props.modelValue;
          const options = filteredOptions.value;
          const selectedItemIndex = options.findIndex((option) => getValueKey(getValue(option)) === getValueKey(props.modelValue));
          if (~selectedItemIndex) {
            states.selectedLabel = getLabel(options[selectedItemIndex]);
          } else {
            if (!states.selectedLabel || needUpdateSelectedLabel) {
              states.selectedLabel = getValueKey(props.modelValue);
            }
          }
        } else {
          states.selectedLabel = "";
          states.previousValue = void 0;
        }
      }
      clearAllNewOption();
      calculatePopperSize();
    };
    vue.watch(() => props.fitInputWidth, () => {
      calculatePopperSize();
    });
    vue.watch(expanded, (val) => {
      if (val) {
        if (!props.persistent) {
          calculatePopperSize();
        }
        handleQueryChange("");
      } else {
        states.inputValue = "";
        states.previousQuery = null;
        states.isBeforeHide = true;
        createNewOption("");
      }
      emit("visible-change", val);
    });
    vue.watch(() => props.modelValue, (val, oldVal) => {
      var _a;
      const isValEmpty = !val || isArray$1(val) && val.length === 0;
      if (isValEmpty || props.multiple && !isEqual$1(val.toString(), states.previousValue) || !props.multiple && getValueKey(val) !== getValueKey(states.previousValue)) {
        initStates(true);
      }
      if (!isEqual$1(val, oldVal) && props.validateEvent) {
        (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => debugWarn(err));
      }
    }, {
      deep: true
    });
    vue.watch(() => props.options, () => {
      const input = inputRef.value;
      if (!input || input && document.activeElement !== input) {
        initStates();
      }
    }, {
      deep: true,
      flush: "post"
    });
    vue.watch(() => filteredOptions.value, () => {
      calculatePopperSize();
      return menuRef.value && vue.nextTick(menuRef.value.resetScrollTop);
    });
    vue.watchEffect(() => {
      if (states.isBeforeHide)
        return;
      updateOptions();
    });
    vue.watchEffect(() => {
      const { valueKey, options } = props;
      const duplicateValue = /* @__PURE__ */ new Map();
      for (const item of options) {
        const optionValue = getValue(item);
        let v = optionValue;
        if (isObject$1(v)) {
          v = get(optionValue, valueKey);
        }
        if (duplicateValue.get(v)) {
          debugWarn("ElSelectV2", `The option values you provided seem to be duplicated, which may cause some problems, please check.`);
          break;
        } else {
          duplicateValue.set(v, true);
        }
      }
    });
    vue.onMounted(() => {
      initStates();
    });
    useResizeObserver(selectRef, handleResize);
    useResizeObserver(selectionRef, resetSelectionWidth);
    useResizeObserver(menuRef, updateTooltip);
    useResizeObserver(wrapperRef, updateTooltip);
    useResizeObserver(tagMenuRef, updateTagTooltip);
    useResizeObserver(collapseItemRef, resetCollapseItemWidth);
    return {
      inputId,
      collapseTagSize,
      currentPlaceholder,
      expanded,
      emptyText,
      popupHeight,
      debounce,
      allOptions,
      allOptionsValueMap,
      filteredOptions,
      iconComponent,
      iconReverse,
      tagStyle,
      collapseTagStyle,
      popperSize,
      dropdownMenuVisible,
      hasModelValue,
      shouldShowPlaceholder,
      selectDisabled,
      selectSize,
      needStatusIcon,
      showClearBtn,
      states,
      isFocused,
      nsSelect,
      nsInput,
      inputRef,
      menuRef,
      tagMenuRef,
      tooltipRef,
      tagTooltipRef,
      selectRef,
      wrapperRef,
      selectionRef,
      prefixRef,
      suffixRef,
      collapseItemRef,
      popperRef,
      validateState,
      validateIcon,
      showTagList,
      collapseTagList,
      debouncedOnInputChange,
      deleteTag,
      getLabel,
      getValue,
      getDisabled,
      getValueKey,
      getIndex,
      handleClear,
      handleClickOutside,
      handleDel,
      handleEsc,
      focus,
      blur,
      handleMenuEnter,
      handleResize,
      resetSelectionWidth,
      updateTooltip,
      updateTagTooltip,
      updateOptions,
      toggleMenu,
      scrollTo: scrollToItem,
      onInput,
      onKeyboardNavigate,
      onKeyboardSelect,
      onSelect,
      onHover: onHoverOption,
      handleCompositionStart,
      handleCompositionEnd,
      handleCompositionUpdate
    };
  };
  var useSelect$2 = useSelect$1;

  const _sfc_main$J = vue.defineComponent({
    name: "ElSelectV2",
    components: {
      ElSelectMenu,
      ElTag,
      ElTooltip,
      ElIcon
    },
    directives: { ClickOutside },
    props: selectV2Props,
    emits: selectV2Emits,
    setup(props, { emit }) {
      const modelValue = vue.computed(() => {
        const { modelValue: rawModelValue, multiple } = props;
        const fallback = multiple ? [] : void 0;
        if (isArray$1(rawModelValue)) {
          return multiple ? rawModelValue : fallback;
        }
        return multiple ? fallback : rawModelValue;
      });
      const API = useSelect$2(vue.reactive({
        ...vue.toRefs(props),
        modelValue
      }), emit);
      const { calculatorRef, inputStyle } = useCalcInputWidth();
      const contentId = useId();
      vue.provide(selectV2InjectionKey, {
        props: vue.reactive({
          ...vue.toRefs(props),
          height: API.popupHeight,
          modelValue
        }),
        expanded: API.expanded,
        tooltipRef: API.tooltipRef,
        contentId,
        onSelect: API.onSelect,
        onHover: API.onHover,
        onKeyboardNavigate: API.onKeyboardNavigate,
        onKeyboardSelect: API.onKeyboardSelect
      });
      const selectedLabel = vue.computed(() => {
        if (!props.multiple) {
          return API.states.selectedLabel;
        }
        return API.states.cachedOptions.map((i) => API.getLabel(i));
      });
      return {
        ...API,
        modelValue,
        selectedLabel,
        calculatorRef,
        inputStyle,
        contentId,
        BORDER_HORIZONTAL_WIDTH
      };
    }
  });
  function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_tag = vue.resolveComponent("el-tag");
    const _component_el_tooltip = vue.resolveComponent("el-tooltip");
    const _component_el_icon = vue.resolveComponent("el-icon");
    const _component_el_select_menu = vue.resolveComponent("el-select-menu");
    const _directive_click_outside = vue.resolveDirective("click-outside");
    return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
      ref: "selectRef",
      class: vue.normalizeClass([_ctx.nsSelect.b(), _ctx.nsSelect.m(_ctx.selectSize)]),
      onMouseenter: ($event) => _ctx.states.inputHovering = true,
      onMouseleave: ($event) => _ctx.states.inputHovering = false
    }, [
      vue.createVNode(_component_el_tooltip, {
        ref: "tooltipRef",
        visible: _ctx.dropdownMenuVisible,
        teleported: _ctx.teleported,
        "popper-class": [_ctx.nsSelect.e("popper"), _ctx.popperClass],
        "popper-style": _ctx.popperStyle,
        "gpu-acceleration": false,
        "stop-popper-mouse-event": false,
        "popper-options": _ctx.popperOptions,
        "fallback-placements": _ctx.fallbackPlacements,
        effect: _ctx.effect,
        placement: _ctx.placement,
        pure: "",
        transition: `${_ctx.nsSelect.namespace.value}-zoom-in-top`,
        trigger: "click",
        persistent: _ctx.persistent,
        "append-to": _ctx.appendTo,
        "show-arrow": _ctx.showArrow,
        offset: _ctx.offset,
        onBeforeShow: _ctx.handleMenuEnter,
        onHide: ($event) => _ctx.states.isBeforeHide = false
      }, {
        default: vue.withCtx(() => {
          var _a, _b;
          return [
            vue.createElementVNode("div", {
              ref: "wrapperRef",
              class: vue.normalizeClass([
                _ctx.nsSelect.e("wrapper"),
                _ctx.nsSelect.is("focused", _ctx.isFocused),
                _ctx.nsSelect.is("hovering", _ctx.states.inputHovering),
                _ctx.nsSelect.is("filterable", _ctx.filterable),
                _ctx.nsSelect.is("disabled", _ctx.selectDisabled)
              ]),
              onClick: vue.withModifiers(_ctx.toggleMenu, ["prevent"])
            }, [
              _ctx.$slots.prefix ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                ref: "prefixRef",
                class: vue.normalizeClass(_ctx.nsSelect.e("prefix"))
              }, [
                vue.renderSlot(_ctx.$slots, "prefix")
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                ref: "selectionRef",
                class: vue.normalizeClass([
                  _ctx.nsSelect.e("selection"),
                  _ctx.nsSelect.is("near", _ctx.multiple && !_ctx.$slots.prefix && !!_ctx.modelValue.length)
                ])
              }, [
                _ctx.multiple ? vue.renderSlot(_ctx.$slots, "tag", {
                  key: 0,
                  data: _ctx.states.cachedOptions,
                  deleteTag: _ctx.deleteTag,
                  selectDisabled: _ctx.selectDisabled
                }, () => [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.showTagList, (item) => {
                    return vue.openBlock(), vue.createElementBlock("div", {
                      key: _ctx.getValueKey(_ctx.getValue(item)),
                      class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
                    }, [
                      vue.createVNode(_component_el_tag, {
                        closable: !_ctx.selectDisabled && !_ctx.getDisabled(item),
                        size: _ctx.collapseTagSize,
                        type: _ctx.tagType,
                        effect: _ctx.tagEffect,
                        "disable-transitions": "",
                        style: vue.normalizeStyle(_ctx.tagStyle),
                        onClose: ($event) => _ctx.deleteTag($event, item)
                      }, {
                        default: vue.withCtx(() => [
                          vue.createElementVNode("span", {
                            class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                          }, [
                            vue.renderSlot(_ctx.$slots, "label", {
                              index: _ctx.getIndex(item),
                              label: _ctx.getLabel(item),
                              value: _ctx.getValue(item)
                            }, () => [
                              vue.createTextVNode(vue.toDisplayString(_ctx.getLabel(item)), 1)
                            ])
                          ], 2)
                        ]),
                        _: 2
                      }, 1032, ["closable", "size", "type", "effect", "style", "onClose"])
                    ], 2);
                  }), 128)),
                  _ctx.collapseTags && _ctx.modelValue.length > _ctx.maxCollapseTags ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
                    key: 0,
                    ref: "tagTooltipRef",
                    disabled: _ctx.dropdownMenuVisible || !_ctx.collapseTagsTooltip,
                    "fallback-placements": ["bottom", "top", "right", "left"],
                    effect: _ctx.effect,
                    placement: "bottom",
                    "popper-class": _ctx.popperClass,
                    "popper-style": _ctx.popperStyle,
                    teleported: _ctx.teleported
                  }, {
                    default: vue.withCtx(() => [
                      vue.createElementVNode("div", {
                        ref: "collapseItemRef",
                        class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
                      }, [
                        vue.createVNode(_component_el_tag, {
                          closable: false,
                          size: _ctx.collapseTagSize,
                          type: _ctx.tagType,
                          effect: _ctx.tagEffect,
                          style: vue.normalizeStyle(_ctx.collapseTagStyle),
                          "disable-transitions": ""
                        }, {
                          default: vue.withCtx(() => [
                            vue.createElementVNode("span", {
                              class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                            }, " + " + vue.toDisplayString(_ctx.modelValue.length - _ctx.maxCollapseTags), 3)
                          ]),
                          _: 1
                        }, 8, ["size", "type", "effect", "style"])
                      ], 2)
                    ]),
                    content: vue.withCtx(() => [
                      vue.createElementVNode("div", {
                        ref: "tagMenuRef",
                        class: vue.normalizeClass(_ctx.nsSelect.e("selection"))
                      }, [
                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.collapseTagList, (selected) => {
                          return vue.openBlock(), vue.createElementBlock("div", {
                            key: _ctx.getValueKey(_ctx.getValue(selected)),
                            class: vue.normalizeClass(_ctx.nsSelect.e("selected-item"))
                          }, [
                            vue.createVNode(_component_el_tag, {
                              class: "in-tooltip",
                              closable: !_ctx.selectDisabled && !_ctx.getDisabled(selected),
                              size: _ctx.collapseTagSize,
                              type: _ctx.tagType,
                              effect: _ctx.tagEffect,
                              "disable-transitions": "",
                              onClose: ($event) => _ctx.deleteTag($event, selected)
                            }, {
                              default: vue.withCtx(() => [
                                vue.createElementVNode("span", {
                                  class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                                }, [
                                  vue.renderSlot(_ctx.$slots, "label", {
                                    index: _ctx.getIndex(selected),
                                    label: _ctx.getLabel(selected),
                                    value: _ctx.getValue(selected)
                                  }, () => [
                                    vue.createTextVNode(vue.toDisplayString(_ctx.getLabel(selected)), 1)
                                  ])
                                ], 2)
                              ]),
                              _: 2
                            }, 1032, ["closable", "size", "type", "effect", "onClose"])
                          ], 2);
                        }), 128))
                      ], 2)
                    ]),
                    _: 3
                  }, 8, ["disabled", "effect", "popper-class", "popper-style", "teleported"])) : vue.createCommentVNode("v-if", true)
                ]) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([
                    _ctx.nsSelect.e("selected-item"),
                    _ctx.nsSelect.e("input-wrapper"),
                    _ctx.nsSelect.is("hidden", !_ctx.filterable)
                  ])
                }, [
                  vue.withDirectives(vue.createElementVNode("input", {
                    id: _ctx.inputId,
                    ref: "inputRef",
                    "onUpdate:modelValue": ($event) => _ctx.states.inputValue = $event,
                    style: vue.normalizeStyle(_ctx.inputStyle),
                    autocomplete: _ctx.autocomplete,
                    tabindex: _ctx.tabindex,
                    "aria-autocomplete": "none",
                    "aria-haspopup": "listbox",
                    autocapitalize: "off",
                    "aria-expanded": _ctx.expanded,
                    "aria-label": _ctx.ariaLabel,
                    class: vue.normalizeClass([_ctx.nsSelect.e("input"), _ctx.nsSelect.is(_ctx.selectSize)]),
                    disabled: _ctx.selectDisabled,
                    role: "combobox",
                    "aria-controls": _ctx.contentId,
                    "aria-activedescendant": _ctx.states.hoveringIndex >= 0 ? `${_ctx.contentId}-${_ctx.states.hoveringIndex}` : "",
                    readonly: !_ctx.filterable,
                    spellcheck: "false",
                    type: "text",
                    name: _ctx.name,
                    onInput: _ctx.onInput,
                    onCompositionstart: _ctx.handleCompositionStart,
                    onCompositionupdate: _ctx.handleCompositionUpdate,
                    onCompositionend: _ctx.handleCompositionEnd,
                    onKeydown: [
                      vue.withKeys(vue.withModifiers(($event) => _ctx.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"]),
                      vue.withKeys(vue.withModifiers(($event) => _ctx.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"]),
                      vue.withKeys(vue.withModifiers(_ctx.onKeyboardSelect, ["stop", "prevent"]), ["enter"]),
                      vue.withKeys(vue.withModifiers(_ctx.handleEsc, ["stop", "prevent"]), ["esc"]),
                      vue.withKeys(vue.withModifiers(_ctx.handleDel, ["stop"]), ["delete"])
                    ],
                    onClick: vue.withModifiers(_ctx.toggleMenu, ["stop"])
                  }, null, 46, ["id", "onUpdate:modelValue", "autocomplete", "tabindex", "aria-expanded", "aria-label", "disabled", "aria-controls", "aria-activedescendant", "readonly", "name", "onInput", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onKeydown", "onClick"]), [
                    [vue.vModelText, _ctx.states.inputValue]
                  ]),
                  _ctx.filterable ? (vue.openBlock(), vue.createElementBlock("span", {
                    key: 0,
                    ref: "calculatorRef",
                    "aria-hidden": "true",
                    class: vue.normalizeClass(_ctx.nsSelect.e("input-calculator")),
                    textContent: vue.toDisplayString(_ctx.states.inputValue)
                  }, null, 10, ["textContent"])) : vue.createCommentVNode("v-if", true)
                ], 2),
                _ctx.shouldShowPlaceholder ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 1,
                  class: vue.normalizeClass([
                    _ctx.nsSelect.e("selected-item"),
                    _ctx.nsSelect.e("placeholder"),
                    _ctx.nsSelect.is("transparent", !_ctx.hasModelValue || _ctx.expanded && !_ctx.states.inputValue)
                  ])
                }, [
                  _ctx.hasModelValue ? vue.renderSlot(_ctx.$slots, "label", {
                    key: 0,
                    index: (_b = (_a = _ctx.allOptionsValueMap.get(_ctx.modelValue)) == null ? void 0 : _a.index) != null ? _b : -1,
                    label: _ctx.currentPlaceholder,
                    value: _ctx.modelValue
                  }, () => [
                    vue.createElementVNode("span", null, vue.toDisplayString(_ctx.currentPlaceholder), 1)
                  ]) : (vue.openBlock(), vue.createElementBlock("span", { key: 1 }, vue.toDisplayString(_ctx.currentPlaceholder), 1))
                ], 2)) : vue.createCommentVNode("v-if", true)
              ], 2),
              vue.createElementVNode("div", {
                ref: "suffixRef",
                class: vue.normalizeClass(_ctx.nsSelect.e("suffix"))
              }, [
                _ctx.iconComponent ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: 0,
                  class: vue.normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsInput.e("icon"), _ctx.iconReverse])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                  ]),
                  _: 1
                }, 8, ["class"])), [
                  [vue.vShow, !_ctx.showClearBtn]
                ]) : vue.createCommentVNode("v-if", true),
                _ctx.showClearBtn && _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: 1,
                  class: vue.normalizeClass([
                    _ctx.nsSelect.e("caret"),
                    _ctx.nsInput.e("icon"),
                    _ctx.nsSelect.e("clear")
                  ]),
                  onClick: vue.withModifiers(_ctx.handleClear, ["prevent", "stop"])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
                _ctx.validateState && _ctx.validateIcon && _ctx.needStatusIcon ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: 2,
                  class: vue.normalizeClass([
                    _ctx.nsInput.e("icon"),
                    _ctx.nsInput.e("validateIcon"),
                    _ctx.nsInput.is("loading", _ctx.validateState === "validating")
                  ])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.validateIcon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
              ], 2)
            ], 10, ["onClick"])
          ];
        }),
        content: vue.withCtx(() => [
          vue.createVNode(_component_el_select_menu, {
            id: _ctx.contentId,
            ref: "menuRef",
            data: _ctx.filteredOptions,
            width: _ctx.popperSize - _ctx.BORDER_HORIZONTAL_WIDTH,
            "hovering-index": _ctx.states.hoveringIndex,
            "scrollbar-always-on": _ctx.scrollbarAlwaysOn,
            "aria-label": _ctx.ariaLabel
          }, vue.createSlots({
            default: vue.withCtx((scope) => [
              vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps(scope)))
            ]),
            _: 2
          }, [
            _ctx.$slots.header ? {
              name: "header",
              fn: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "header")),
                  onClick: vue.withModifiers(() => {
                  }, ["stop"])
                }, [
                  vue.renderSlot(_ctx.$slots, "header")
                ], 10, ["onClick"])
              ])
            } : void 0,
            _ctx.$slots.loading && _ctx.loading ? {
              name: "loading",
              fn: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "loading"))
                }, [
                  vue.renderSlot(_ctx.$slots, "loading")
                ], 2)
              ])
            } : _ctx.loading || _ctx.filteredOptions.length === 0 ? {
              name: "empty",
              fn: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "empty"))
                }, [
                  vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                    vue.createElementVNode("span", null, vue.toDisplayString(_ctx.emptyText), 1)
                  ])
                ], 2)
              ])
            } : void 0,
            _ctx.$slots.footer ? {
              name: "footer",
              fn: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "footer")),
                  onClick: vue.withModifiers(() => {
                  }, ["stop"])
                }, [
                  vue.renderSlot(_ctx.$slots, "footer")
                ], 10, ["onClick"])
              ])
            } : void 0
          ]), 1032, ["id", "data", "width", "hovering-index", "scrollbar-always-on", "aria-label"])
        ]),
        _: 3
      }, 8, ["visible", "teleported", "popper-class", "popper-style", "popper-options", "fallback-placements", "effect", "placement", "transition", "persistent", "append-to", "show-arrow", "offset", "onBeforeShow", "onHide"])
    ], 42, ["onMouseenter", "onMouseleave"])), [
      [_directive_click_outside, _ctx.handleClickOutside, _ctx.popperRef]
    ]);
  }
  var Select = /* @__PURE__ */ _export_sfc(_sfc_main$J, [["render", _sfc_render$5], ["__file", "select.vue"]]);

  const ElSelectV2 = withInstall(Select);

  const skeletonProps = buildProps({
    animated: Boolean,
    count: {
      type: Number,
      default: 1
    },
    rows: {
      type: Number,
      default: 3
    },
    loading: {
      type: Boolean,
      default: true
    },
    throttle: {
      type: definePropType([Number, Object])
    }
  });

  const skeletonItemProps = buildProps({
    variant: {
      type: String,
      values: [
        "circle",
        "rect",
        "h1",
        "h3",
        "text",
        "caption",
        "p",
        "image",
        "button"
      ],
      default: "text"
    }
  });

  const __default__$B = vue.defineComponent({
    name: "ElSkeletonItem"
  });
  const _sfc_main$I = /* @__PURE__ */ vue.defineComponent({
    ...__default__$B,
    props: skeletonItemProps,
    setup(__props) {
      const ns = useNamespace("skeleton");
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).e("item"), vue.unref(ns).e(_ctx.variant)])
        }, [
          _ctx.variant === "image" ? (vue.openBlock(), vue.createBlock(vue.unref(picture_filled_default), { key: 0 })) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var SkeletonItem = /* @__PURE__ */ _export_sfc(_sfc_main$I, [["__file", "skeleton-item.vue"]]);

  const __default__$A = vue.defineComponent({
    name: "ElSkeleton"
  });
  const _sfc_main$H = /* @__PURE__ */ vue.defineComponent({
    ...__default__$A,
    props: skeletonProps,
    setup(__props, { expose }) {
      const props = __props;
      const ns = useNamespace("skeleton");
      const uiLoading = useThrottleRender(vue.toRef(props, "loading"), props.throttle);
      expose({
        uiLoading
      });
      return (_ctx, _cache) => {
        return vue.unref(uiLoading) ? (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
          key: 0,
          class: [vue.unref(ns).b(), vue.unref(ns).is("animated", _ctx.animated)]
        }, _ctx.$attrs), [
          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.count, (i) => {
            return vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: i }, [
              vue.unref(uiLoading) ? vue.renderSlot(_ctx.$slots, "template", { key: i }, () => [
                vue.createVNode(SkeletonItem, {
                  class: vue.normalizeClass(vue.unref(ns).is("first")),
                  variant: "p"
                }, null, 8, ["class"]),
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.rows, (item) => {
                  return vue.openBlock(), vue.createBlock(SkeletonItem, {
                    key: item,
                    class: vue.normalizeClass([
                      vue.unref(ns).e("paragraph"),
                      vue.unref(ns).is("last", item === _ctx.rows && _ctx.rows > 1)
                    ]),
                    variant: "p"
                  }, null, 8, ["class"]);
                }), 128))
              ]) : vue.createCommentVNode("v-if", true)
            ], 64);
          }), 128))
        ], 16)) : vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.mergeProps({ key: 1 }, _ctx.$attrs)));
      };
    }
  });
  var Skeleton = /* @__PURE__ */ _export_sfc(_sfc_main$H, [["__file", "skeleton.vue"]]);

  const ElSkeleton = withInstall(Skeleton, {
    SkeletonItem
  });
  const ElSkeletonItem = withNoopInstall(SkeletonItem);

  const sliderContextKey = Symbol("sliderContextKey");

  const sliderProps = buildProps({
    modelValue: {
      type: definePropType([Number, Array]),
      default: 0
    },
    id: {
      type: String,
      default: void 0
    },
    min: {
      type: Number,
      default: 0
    },
    max: {
      type: Number,
      default: 100
    },
    step: {
      type: Number,
      default: 1
    },
    showInput: Boolean,
    showInputControls: {
      type: Boolean,
      default: true
    },
    size: useSizeProp,
    inputSize: useSizeProp,
    showStops: Boolean,
    showTooltip: {
      type: Boolean,
      default: true
    },
    formatTooltip: {
      type: definePropType(Function),
      default: void 0
    },
    disabled: Boolean,
    range: Boolean,
    vertical: Boolean,
    height: String,
    rangeStartLabel: {
      type: String,
      default: void 0
    },
    rangeEndLabel: {
      type: String,
      default: void 0
    },
    formatValueText: {
      type: definePropType(Function),
      default: void 0
    },
    tooltipClass: {
      type: String,
      default: void 0
    },
    placement: {
      type: String,
      values: Ee,
      default: "top"
    },
    marks: {
      type: definePropType(Object)
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    persistent: {
      type: Boolean,
      default: true
    },
    ...useAriaProps(["ariaLabel"])
  });
  const isValidValue$1 = (value) => isNumber(value) || isArray$1(value) && value.every(isNumber);
  const sliderEmits = {
    [UPDATE_MODEL_EVENT]: isValidValue$1,
    [INPUT_EVENT]: isValidValue$1,
    [CHANGE_EVENT]: isValidValue$1
  };

  const useLifecycle = (props, initData, resetSize) => {
    const sliderWrapper = vue.ref();
    vue.onMounted(async () => {
      if (props.range) {
        if (isArray$1(props.modelValue)) {
          initData.firstValue = Math.max(props.min, props.modelValue[0]);
          initData.secondValue = Math.min(props.max, props.modelValue[1]);
        } else {
          initData.firstValue = props.min;
          initData.secondValue = props.max;
        }
        initData.oldValue = [initData.firstValue, initData.secondValue];
      } else {
        if (!isNumber(props.modelValue) || Number.isNaN(props.modelValue)) {
          initData.firstValue = props.min;
        } else {
          initData.firstValue = Math.min(props.max, Math.max(props.min, props.modelValue));
        }
        initData.oldValue = initData.firstValue;
      }
      useEventListener(window, "resize", resetSize);
      await vue.nextTick();
      resetSize();
    });
    return {
      sliderWrapper
    };
  };

  const useMarks = (props) => {
    return vue.computed(() => {
      if (!props.marks) {
        return [];
      }
      const marksKeys = Object.keys(props.marks);
      return marksKeys.map(Number.parseFloat).sort((a, b) => a - b).filter((point) => point <= props.max && point >= props.min).map((point) => ({
        point,
        position: (point - props.min) * 100 / (props.max - props.min),
        mark: props.marks[point]
      }));
    });
  };

  const useSlide = (props, initData, emit) => {
    const { form: elForm, formItem: elFormItem } = useFormItem();
    const slider = vue.shallowRef();
    const firstButton = vue.ref();
    const secondButton = vue.ref();
    const buttonRefs = {
      firstButton,
      secondButton
    };
    const sliderDisabled = vue.computed(() => {
      return props.disabled || (elForm == null ? void 0 : elForm.disabled) || false;
    });
    const minValue = vue.computed(() => {
      return Math.min(initData.firstValue, initData.secondValue);
    });
    const maxValue = vue.computed(() => {
      return Math.max(initData.firstValue, initData.secondValue);
    });
    const barSize = vue.computed(() => {
      return props.range ? `${100 * (maxValue.value - minValue.value) / (props.max - props.min)}%` : `${100 * (initData.firstValue - props.min) / (props.max - props.min)}%`;
    });
    const barStart = vue.computed(() => {
      return props.range ? `${100 * (minValue.value - props.min) / (props.max - props.min)}%` : "0%";
    });
    const runwayStyle = vue.computed(() => {
      return props.vertical ? { height: props.height } : {};
    });
    const barStyle = vue.computed(() => {
      return props.vertical ? {
        height: barSize.value,
        bottom: barStart.value
      } : {
        width: barSize.value,
        left: barStart.value
      };
    });
    const resetSize = () => {
      if (slider.value) {
        const rect = slider.value.getBoundingClientRect();
        initData.sliderSize = rect[props.vertical ? "height" : "width"];
      }
    };
    const getButtonRefByPercent = (percent) => {
      const targetValue = props.min + percent * (props.max - props.min) / 100;
      if (!props.range) {
        return firstButton;
      }
      let buttonRefName;
      if (Math.abs(minValue.value - targetValue) < Math.abs(maxValue.value - targetValue)) {
        buttonRefName = initData.firstValue < initData.secondValue ? "firstButton" : "secondButton";
      } else {
        buttonRefName = initData.firstValue > initData.secondValue ? "firstButton" : "secondButton";
      }
      return buttonRefs[buttonRefName];
    };
    const setPosition = (percent) => {
      const buttonRef = getButtonRefByPercent(percent);
      buttonRef.value.setPosition(percent);
      return buttonRef;
    };
    const setFirstValue = (firstValue) => {
      initData.firstValue = firstValue != null ? firstValue : props.min;
      _emit(props.range ? [minValue.value, maxValue.value] : firstValue != null ? firstValue : props.min);
    };
    const setSecondValue = (secondValue) => {
      initData.secondValue = secondValue;
      if (props.range) {
        _emit([minValue.value, maxValue.value]);
      }
    };
    const _emit = (val) => {
      emit(UPDATE_MODEL_EVENT, val);
      emit(INPUT_EVENT, val);
    };
    const emitChange = async () => {
      await vue.nextTick();
      emit(CHANGE_EVENT, props.range ? [minValue.value, maxValue.value] : props.modelValue);
    };
    const handleSliderPointerEvent = (event) => {
      var _a, _b, _c, _d, _e, _f;
      if (sliderDisabled.value || initData.dragging)
        return;
      resetSize();
      let newPercent = 0;
      if (props.vertical) {
        const clientY = (_c = (_b = (_a = event.touches) == null ? void 0 : _a.item(0)) == null ? void 0 : _b.clientY) != null ? _c : event.clientY;
        const sliderOffsetBottom = slider.value.getBoundingClientRect().bottom;
        newPercent = (sliderOffsetBottom - clientY) / initData.sliderSize * 100;
      } else {
        const clientX = (_f = (_e = (_d = event.touches) == null ? void 0 : _d.item(0)) == null ? void 0 : _e.clientX) != null ? _f : event.clientX;
        const sliderOffsetLeft = slider.value.getBoundingClientRect().left;
        newPercent = (clientX - sliderOffsetLeft) / initData.sliderSize * 100;
      }
      if (newPercent < 0 || newPercent > 100)
        return;
      return setPosition(newPercent);
    };
    const onSliderWrapperPrevent = (event) => {
      var _a, _b;
      if (((_a = buttonRefs["firstButton"].value) == null ? void 0 : _a.dragging) || ((_b = buttonRefs["secondButton"].value) == null ? void 0 : _b.dragging)) {
        event.preventDefault();
      }
    };
    const onSliderDown = async (event) => {
      const buttonRef = handleSliderPointerEvent(event);
      if (buttonRef) {
        await vue.nextTick();
        buttonRef.value.onButtonDown(event);
      }
    };
    const onSliderClick = (event) => {
      const buttonRef = handleSliderPointerEvent(event);
      if (buttonRef) {
        emitChange();
      }
    };
    const onSliderMarkerDown = (position) => {
      if (sliderDisabled.value || initData.dragging)
        return;
      const buttonRef = setPosition(position);
      if (buttonRef) {
        emitChange();
      }
    };
    return {
      elFormItem,
      slider,
      firstButton,
      secondButton,
      sliderDisabled,
      minValue,
      maxValue,
      runwayStyle,
      barStyle,
      resetSize,
      setPosition,
      emitChange,
      onSliderWrapperPrevent,
      onSliderClick,
      onSliderDown,
      onSliderMarkerDown,
      setFirstValue,
      setSecondValue
    };
  };

  const useTooltip = (props, formatTooltip, showTooltip) => {
    const tooltip = vue.ref();
    const tooltipVisible = vue.ref(false);
    const enableFormat = vue.computed(() => {
      return formatTooltip.value instanceof Function;
    });
    const formatValue = vue.computed(() => {
      return enableFormat.value && formatTooltip.value(props.modelValue) || props.modelValue;
    });
    const displayTooltip = debounce(() => {
      showTooltip.value && (tooltipVisible.value = true);
    }, 50);
    const hideTooltip = debounce(() => {
      showTooltip.value && (tooltipVisible.value = false);
    }, 50);
    return {
      tooltip,
      tooltipVisible,
      formatValue,
      displayTooltip,
      hideTooltip
    };
  };
  const useSliderButton = (props, initData, emit) => {
    const {
      disabled,
      min,
      max,
      step,
      showTooltip,
      persistent,
      precision,
      sliderSize,
      formatTooltip,
      emitChange,
      resetSize,
      updateDragging
    } = vue.inject(sliderContextKey);
    const { tooltip, tooltipVisible, formatValue, displayTooltip, hideTooltip } = useTooltip(props, formatTooltip, showTooltip);
    const button = vue.ref();
    const currentPosition = vue.computed(() => {
      return `${(props.modelValue - min.value) / (max.value - min.value) * 100}%`;
    });
    const wrapperStyle = vue.computed(() => {
      return props.vertical ? { bottom: currentPosition.value } : { left: currentPosition.value };
    });
    const handleMouseEnter = () => {
      initData.hovering = true;
      displayTooltip();
    };
    const handleMouseLeave = () => {
      initData.hovering = false;
      if (!initData.dragging) {
        hideTooltip();
      }
    };
    const onButtonDown = (event) => {
      if (disabled.value)
        return;
      event.preventDefault();
      onDragStart(event);
      window.addEventListener("mousemove", onDragging);
      window.addEventListener("touchmove", onDragging);
      window.addEventListener("mouseup", onDragEnd);
      window.addEventListener("touchend", onDragEnd);
      window.addEventListener("contextmenu", onDragEnd);
      button.value.focus();
    };
    const incrementPosition = (amount) => {
      if (disabled.value)
        return;
      initData.newPosition = Number.parseFloat(currentPosition.value) + amount / (max.value - min.value) * 100;
      setPosition(initData.newPosition);
      emitChange();
    };
    const onLeftKeyDown = () => {
      incrementPosition(-step.value);
    };
    const onRightKeyDown = () => {
      incrementPosition(step.value);
    };
    const onPageDownKeyDown = () => {
      incrementPosition(-step.value * 4);
    };
    const onPageUpKeyDown = () => {
      incrementPosition(step.value * 4);
    };
    const onHomeKeyDown = () => {
      if (disabled.value)
        return;
      setPosition(0);
      emitChange();
    };
    const onEndKeyDown = () => {
      if (disabled.value)
        return;
      setPosition(100);
      emitChange();
    };
    const onKeyDown = (event) => {
      const code = getEventCode(event);
      let isPreventDefault = true;
      switch (code) {
        case EVENT_CODE.left:
        case EVENT_CODE.down:
          onLeftKeyDown();
          break;
        case EVENT_CODE.right:
        case EVENT_CODE.up:
          onRightKeyDown();
          break;
        case EVENT_CODE.home:
          onHomeKeyDown();
          break;
        case EVENT_CODE.end:
          onEndKeyDown();
          break;
        case EVENT_CODE.pageDown:
          onPageDownKeyDown();
          break;
        case EVENT_CODE.pageUp:
          onPageUpKeyDown();
          break;
        default:
          isPreventDefault = false;
          break;
      }
      isPreventDefault && event.preventDefault();
    };
    const getClientXY = (event) => {
      let clientX;
      let clientY;
      if (event.type.startsWith("touch")) {
        clientY = event.touches[0].clientY;
        clientX = event.touches[0].clientX;
      } else {
        clientY = event.clientY;
        clientX = event.clientX;
      }
      return {
        clientX,
        clientY
      };
    };
    const onDragStart = (event) => {
      initData.dragging = true;
      initData.isClick = true;
      const { clientX, clientY } = getClientXY(event);
      if (props.vertical) {
        initData.startY = clientY;
      } else {
        initData.startX = clientX;
      }
      initData.startPosition = Number.parseFloat(currentPosition.value);
      initData.newPosition = initData.startPosition;
    };
    const onDragging = (event) => {
      if (initData.dragging) {
        initData.isClick = false;
        displayTooltip();
        resetSize();
        let diff;
        const { clientX, clientY } = getClientXY(event);
        if (props.vertical) {
          initData.currentY = clientY;
          diff = (initData.startY - initData.currentY) / sliderSize.value * 100;
        } else {
          initData.currentX = clientX;
          diff = (initData.currentX - initData.startX) / sliderSize.value * 100;
        }
        initData.newPosition = initData.startPosition + diff;
        setPosition(initData.newPosition);
      }
    };
    const onDragEnd = () => {
      if (initData.dragging) {
        setTimeout(() => {
          initData.dragging = false;
          if (!initData.hovering) {
            hideTooltip();
          }
          if (!initData.isClick) {
            setPosition(initData.newPosition);
          }
          emitChange();
        }, 0);
        window.removeEventListener("mousemove", onDragging);
        window.removeEventListener("touchmove", onDragging);
        window.removeEventListener("mouseup", onDragEnd);
        window.removeEventListener("touchend", onDragEnd);
        window.removeEventListener("contextmenu", onDragEnd);
      }
    };
    const setPosition = async (newPosition) => {
      if (newPosition === null || Number.isNaN(+newPosition))
        return;
      newPosition = clamp$1(newPosition, 0, 100);
      const fullSteps = Math.floor((max.value - min.value) / step.value);
      const fullRangePercentage = fullSteps * step.value / (max.value - min.value) * 100;
      const threshold = fullRangePercentage + (100 - fullRangePercentage) / 2;
      let value;
      if (newPosition < fullRangePercentage) {
        const valueBetween = fullRangePercentage / fullSteps;
        const steps = Math.round(newPosition / valueBetween);
        value = min.value + steps * step.value;
      } else if (newPosition < threshold) {
        value = min.value + fullSteps * step.value;
      } else {
        value = max.value;
      }
      value = Number.parseFloat(value.toFixed(precision.value));
      if (value !== props.modelValue) {
        emit(UPDATE_MODEL_EVENT, value);
      }
      if (!initData.dragging && props.modelValue !== initData.oldValue) {
        initData.oldValue = props.modelValue;
      }
      await vue.nextTick();
      initData.dragging && displayTooltip();
      tooltip.value.updatePopper();
    };
    vue.watch(() => initData.dragging, (val) => {
      updateDragging(val);
    });
    useEventListener(button, "touchstart", onButtonDown, { passive: false });
    return {
      disabled,
      button,
      tooltip,
      tooltipVisible,
      showTooltip,
      persistent,
      wrapperStyle,
      formatValue,
      handleMouseEnter,
      handleMouseLeave,
      onButtonDown,
      onKeyDown,
      setPosition
    };
  };

  const useStops = (props, initData, minValue, maxValue) => {
    const stops = vue.computed(() => {
      if (!props.showStops || props.min > props.max)
        return [];
      if (props.step === 0) {
        debugWarn("ElSlider", "step should not be 0.");
        return [];
      }
      const stopCount = Math.ceil((props.max - props.min) / props.step);
      const stepWidth = 100 * props.step / (props.max - props.min);
      const result = Array.from({ length: stopCount - 1 }).map((_, index) => (index + 1) * stepWidth);
      if (props.range) {
        return result.filter((step) => {
          return step < 100 * (minValue.value - props.min) / (props.max - props.min) || step > 100 * (maxValue.value - props.min) / (props.max - props.min);
        });
      } else {
        return result.filter((step) => step > 100 * (initData.firstValue - props.min) / (props.max - props.min));
      }
    });
    const getStopStyle = (position) => {
      return props.vertical ? { bottom: `${position}%` } : { left: `${position}%` };
    };
    return {
      stops,
      getStopStyle
    };
  };

  const useWatch = (props, initData, minValue, maxValue, emit, elFormItem) => {
    const _emit = (val) => {
      emit(UPDATE_MODEL_EVENT, val);
      emit(INPUT_EVENT, val);
    };
    const valueChanged = () => {
      if (props.range) {
        return ![minValue.value, maxValue.value].every((item, index) => item === initData.oldValue[index]);
      } else {
        return props.modelValue !== initData.oldValue;
      }
    };
    const setValues = () => {
      var _a, _b;
      if (props.min > props.max) {
        throwError("Slider", "min should not be greater than max.");
      }
      const val = props.modelValue;
      if (props.range && isArray$1(val)) {
        if (val[1] < props.min) {
          _emit([props.min, props.min]);
        } else if (val[0] > props.max) {
          _emit([props.max, props.max]);
        } else if (val[0] < props.min) {
          _emit([props.min, val[1]]);
        } else if (val[1] > props.max) {
          _emit([val[0], props.max]);
        } else {
          initData.firstValue = val[0];
          initData.secondValue = val[1];
          if (valueChanged()) {
            if (props.validateEvent) {
              (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => debugWarn(err));
            }
            initData.oldValue = val.slice();
          }
        }
      } else if (!props.range && isNumber(val) && !Number.isNaN(val)) {
        if (val < props.min) {
          _emit(props.min);
        } else if (val > props.max) {
          _emit(props.max);
        } else {
          initData.firstValue = val;
          if (valueChanged()) {
            if (props.validateEvent) {
              (_b = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _b.call(elFormItem, "change").catch((err) => debugWarn(err));
            }
            initData.oldValue = val;
          }
        }
      }
    };
    setValues();
    vue.watch(() => initData.dragging, (val) => {
      if (!val) {
        setValues();
      }
    });
    vue.watch(() => props.modelValue, (val, oldVal) => {
      if (initData.dragging || isArray$1(val) && isArray$1(oldVal) && val.every((item, index) => item === oldVal[index]) && initData.firstValue === val[0] && initData.secondValue === val[1]) {
        return;
      }
      setValues();
    }, {
      deep: true
    });
    vue.watch(() => [props.min, props.max], () => {
      setValues();
    });
  };

  const sliderButtonProps = buildProps({
    modelValue: {
      type: Number,
      default: 0
    },
    vertical: Boolean,
    tooltipClass: String,
    placement: {
      type: String,
      values: Ee,
      default: "top"
    }
  });
  const sliderButtonEmits = {
    [UPDATE_MODEL_EVENT]: (value) => isNumber(value)
  };

  const __default__$z = vue.defineComponent({
    name: "ElSliderButton"
  });
  const _sfc_main$G = /* @__PURE__ */ vue.defineComponent({
    ...__default__$z,
    props: sliderButtonProps,
    emits: sliderButtonEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("slider");
      const initData = vue.reactive({
        hovering: false,
        dragging: false,
        isClick: false,
        startX: 0,
        currentX: 0,
        startY: 0,
        currentY: 0,
        startPosition: 0,
        newPosition: 0,
        oldValue: props.modelValue
      });
      const tooltipPersistent = vue.computed(() => !showTooltip.value ? false : persistent.value);
      const {
        disabled,
        button,
        tooltip,
        showTooltip,
        persistent,
        tooltipVisible,
        wrapperStyle,
        formatValue,
        handleMouseEnter,
        handleMouseLeave,
        onButtonDown,
        onKeyDown,
        setPosition
      } = useSliderButton(props, initData, emit);
      const { hovering, dragging } = vue.toRefs(initData);
      expose({
        onButtonDown,
        onKeyDown,
        setPosition,
        hovering,
        dragging
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "button",
          ref: button,
          class: vue.normalizeClass([vue.unref(ns).e("button-wrapper"), { hover: vue.unref(hovering), dragging: vue.unref(dragging) }]),
          style: vue.normalizeStyle(vue.unref(wrapperStyle)),
          tabindex: vue.unref(disabled) ? void 0 : 0,
          onMouseenter: vue.unref(handleMouseEnter),
          onMouseleave: vue.unref(handleMouseLeave),
          onMousedown: vue.unref(onButtonDown),
          onFocus: vue.unref(handleMouseEnter),
          onBlur: vue.unref(handleMouseLeave),
          onKeydown: vue.unref(onKeyDown)
        }, [
          vue.createVNode(vue.unref(ElTooltip), {
            ref_key: "tooltip",
            ref: tooltip,
            visible: vue.unref(tooltipVisible),
            placement: _ctx.placement,
            "fallback-placements": ["top", "bottom", "right", "left"],
            "stop-popper-mouse-event": false,
            "popper-class": _ctx.tooltipClass,
            disabled: !vue.unref(showTooltip),
            persistent: vue.unref(tooltipPersistent)
          }, {
            content: vue.withCtx(() => [
              vue.createElementVNode("span", null, vue.toDisplayString(vue.unref(formatValue)), 1)
            ]),
            default: vue.withCtx(() => [
              vue.createElementVNode("div", {
                class: vue.normalizeClass([vue.unref(ns).e("button"), { hover: vue.unref(hovering), dragging: vue.unref(dragging) }])
              }, null, 2)
            ]),
            _: 1
          }, 8, ["visible", "placement", "popper-class", "disabled", "persistent"])
        ], 46, ["tabindex", "onMouseenter", "onMouseleave", "onMousedown", "onFocus", "onBlur", "onKeydown"]);
      };
    }
  });
  var SliderButton = /* @__PURE__ */ _export_sfc(_sfc_main$G, [["__file", "button.vue"]]);

  const sliderMarkerProps = buildProps({
    mark: {
      type: definePropType([String, Object]),
      default: void 0
    }
  });
  var SliderMarker = vue.defineComponent({
    name: "ElSliderMarker",
    props: sliderMarkerProps,
    setup(props) {
      const ns = useNamespace("slider");
      const label = vue.computed(() => {
        return isString$1(props.mark) ? props.mark : props.mark.label;
      });
      const style = vue.computed(() => isString$1(props.mark) ? void 0 : props.mark.style);
      return () => vue.h("div", {
        class: ns.e("marks-text"),
        style: style.value
      }, label.value);
    }
  });

  const __default__$y = vue.defineComponent({
    name: "ElSlider"
  });
  const _sfc_main$F = /* @__PURE__ */ vue.defineComponent({
    ...__default__$y,
    props: sliderProps,
    emits: sliderEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("slider");
      const { t } = useLocale();
      const initData = vue.reactive({
        firstValue: 0,
        secondValue: 0,
        oldValue: 0,
        dragging: false,
        sliderSize: 1
      });
      const {
        elFormItem,
        slider,
        firstButton,
        secondButton,
        sliderDisabled,
        minValue,
        maxValue,
        runwayStyle,
        barStyle,
        resetSize,
        emitChange,
        onSliderWrapperPrevent,
        onSliderClick,
        onSliderDown,
        onSliderMarkerDown,
        setFirstValue,
        setSecondValue
      } = useSlide(props, initData, emit);
      const { stops, getStopStyle } = useStops(props, initData, minValue, maxValue);
      const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
        formItemContext: elFormItem
      });
      const sliderWrapperSize = useFormSize();
      const sliderInputSize = vue.computed(() => props.inputSize || sliderWrapperSize.value);
      const groupLabel = vue.computed(() => {
        return props.ariaLabel || t("el.slider.defaultLabel", {
          min: props.min,
          max: props.max
        });
      });
      const firstButtonLabel = vue.computed(() => {
        if (props.range) {
          return props.rangeStartLabel || t("el.slider.defaultRangeStartLabel");
        } else {
          return groupLabel.value;
        }
      });
      const firstValueText = vue.computed(() => {
        return props.formatValueText ? props.formatValueText(firstValue.value) : `${firstValue.value}`;
      });
      const secondButtonLabel = vue.computed(() => {
        return props.rangeEndLabel || t("el.slider.defaultRangeEndLabel");
      });
      const secondValueText = vue.computed(() => {
        return props.formatValueText ? props.formatValueText(secondValue.value) : `${secondValue.value}`;
      });
      const sliderKls = vue.computed(() => [
        ns.b(),
        ns.m(sliderWrapperSize.value),
        ns.is("vertical", props.vertical),
        { [ns.m("with-input")]: props.showInput }
      ]);
      const markList = useMarks(props);
      useWatch(props, initData, minValue, maxValue, emit, elFormItem);
      const precision = vue.computed(() => {
        const precisions = [props.min, props.max, props.step].map((item) => {
          const decimal = `${item}`.split(".")[1];
          return decimal ? decimal.length : 0;
        });
        return Math.max.apply(null, precisions);
      });
      const { sliderWrapper } = useLifecycle(props, initData, resetSize);
      const { firstValue, secondValue, sliderSize } = vue.toRefs(initData);
      const updateDragging = (val) => {
        initData.dragging = val;
      };
      useEventListener(sliderWrapper, "touchstart", onSliderWrapperPrevent, {
        passive: false
      });
      useEventListener(sliderWrapper, "touchmove", onSliderWrapperPrevent, {
        passive: false
      });
      vue.provide(sliderContextKey, {
        ...vue.toRefs(props),
        sliderSize,
        disabled: sliderDisabled,
        precision,
        emitChange,
        resetSize,
        updateDragging
      });
      expose({
        onSliderClick
      });
      return (_ctx, _cache) => {
        var _a, _b;
        return vue.openBlock(), vue.createElementBlock("div", {
          id: _ctx.range ? vue.unref(inputId) : void 0,
          ref_key: "sliderWrapper",
          ref: sliderWrapper,
          class: vue.normalizeClass(vue.unref(sliderKls)),
          role: _ctx.range ? "group" : void 0,
          "aria-label": _ctx.range && !vue.unref(isLabeledByFormItem) ? vue.unref(groupLabel) : void 0,
          "aria-labelledby": _ctx.range && vue.unref(isLabeledByFormItem) ? (_a = vue.unref(elFormItem)) == null ? void 0 : _a.labelId : void 0
        }, [
          vue.createElementVNode("div", {
            ref_key: "slider",
            ref: slider,
            class: vue.normalizeClass([
              vue.unref(ns).e("runway"),
              { "show-input": _ctx.showInput && !_ctx.range },
              vue.unref(ns).is("disabled", vue.unref(sliderDisabled))
            ]),
            style: vue.normalizeStyle(vue.unref(runwayStyle)),
            onMousedown: vue.unref(onSliderDown),
            onTouchstartPassive: vue.unref(onSliderDown)
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("bar")),
              style: vue.normalizeStyle(vue.unref(barStyle))
            }, null, 6),
            vue.createVNode(SliderButton, {
              id: !_ctx.range ? vue.unref(inputId) : void 0,
              ref_key: "firstButton",
              ref: firstButton,
              "model-value": vue.unref(firstValue),
              vertical: _ctx.vertical,
              "tooltip-class": _ctx.tooltipClass,
              placement: _ctx.placement,
              role: "slider",
              "aria-label": _ctx.range || !vue.unref(isLabeledByFormItem) ? vue.unref(firstButtonLabel) : void 0,
              "aria-labelledby": !_ctx.range && vue.unref(isLabeledByFormItem) ? (_b = vue.unref(elFormItem)) == null ? void 0 : _b.labelId : void 0,
              "aria-valuemin": _ctx.min,
              "aria-valuemax": _ctx.range ? vue.unref(secondValue) : _ctx.max,
              "aria-valuenow": vue.unref(firstValue),
              "aria-valuetext": vue.unref(firstValueText),
              "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
              "aria-disabled": vue.unref(sliderDisabled),
              "onUpdate:modelValue": vue.unref(setFirstValue)
            }, null, 8, ["id", "model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"]),
            _ctx.range ? (vue.openBlock(), vue.createBlock(SliderButton, {
              key: 0,
              ref_key: "secondButton",
              ref: secondButton,
              "model-value": vue.unref(secondValue),
              vertical: _ctx.vertical,
              "tooltip-class": _ctx.tooltipClass,
              placement: _ctx.placement,
              role: "slider",
              "aria-label": vue.unref(secondButtonLabel),
              "aria-valuemin": vue.unref(firstValue),
              "aria-valuemax": _ctx.max,
              "aria-valuenow": vue.unref(secondValue),
              "aria-valuetext": vue.unref(secondValueText),
              "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
              "aria-disabled": vue.unref(sliderDisabled),
              "onUpdate:modelValue": vue.unref(setSecondValue)
            }, null, 8, ["model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"])) : vue.createCommentVNode("v-if", true),
            _ctx.showStops ? (vue.openBlock(), vue.createElementBlock("div", { key: 1 }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(stops), (item, key) => {
                return vue.openBlock(), vue.createElementBlock("div", {
                  key,
                  class: vue.normalizeClass(vue.unref(ns).e("stop")),
                  style: vue.normalizeStyle(vue.unref(getStopStyle)(item))
                }, null, 6);
              }), 128))
            ])) : vue.createCommentVNode("v-if", true),
            vue.unref(markList).length > 0 ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
              vue.createElementVNode("div", null, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(markList), (item, key) => {
                  return vue.openBlock(), vue.createElementBlock("div", {
                    key,
                    style: vue.normalizeStyle(vue.unref(getStopStyle)(item.position)),
                    class: vue.normalizeClass([vue.unref(ns).e("stop"), vue.unref(ns).e("marks-stop")])
                  }, null, 6);
                }), 128))
              ]),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("marks"))
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(markList), (item, key) => {
                  return vue.openBlock(), vue.createBlock(vue.unref(SliderMarker), {
                    key,
                    mark: item.mark,
                    style: vue.normalizeStyle(vue.unref(getStopStyle)(item.position)),
                    onMousedown: vue.withModifiers(($event) => vue.unref(onSliderMarkerDown)(item.position), ["stop"])
                  }, null, 8, ["mark", "style", "onMousedown"]);
                }), 128))
              ], 2)
            ], 64)) : vue.createCommentVNode("v-if", true)
          ], 46, ["onMousedown", "onTouchstartPassive"]),
          _ctx.showInput && !_ctx.range ? (vue.openBlock(), vue.createBlock(vue.unref(ElInputNumber), {
            key: 0,
            ref: "input",
            "model-value": vue.unref(firstValue),
            class: vue.normalizeClass(vue.unref(ns).e("input")),
            step: _ctx.step,
            disabled: vue.unref(sliderDisabled),
            controls: _ctx.showInputControls,
            min: _ctx.min,
            max: _ctx.max,
            precision: vue.unref(precision),
            size: vue.unref(sliderInputSize),
            "onUpdate:modelValue": vue.unref(setFirstValue),
            onChange: vue.unref(emitChange)
          }, null, 8, ["model-value", "class", "step", "disabled", "controls", "min", "max", "precision", "size", "onUpdate:modelValue", "onChange"])) : vue.createCommentVNode("v-if", true)
        ], 10, ["id", "role", "aria-label", "aria-labelledby"]);
      };
    }
  });
  var Slider = /* @__PURE__ */ _export_sfc(_sfc_main$F, [["__file", "slider.vue"]]);

  const ElSlider = withInstall(Slider);

  const spaceItemProps = buildProps({
    prefixCls: {
      type: String
    }
  });
  const SpaceItem = vue.defineComponent({
    name: "ElSpaceItem",
    props: spaceItemProps,
    setup(props, { slots }) {
      const ns = useNamespace("space");
      const classes = vue.computed(() => `${props.prefixCls || ns.b()}__item`);
      return () => vue.h("div", { class: classes.value }, vue.renderSlot(slots, "default"));
    }
  });

  const SIZE_MAP = {
    small: 8,
    default: 12,
    large: 16
  };
  function useSpace(props) {
    const ns = useNamespace("space");
    const classes = vue.computed(() => [ns.b(), ns.m(props.direction), props.class]);
    const horizontalSize = vue.ref(0);
    const verticalSize = vue.ref(0);
    const containerStyle = vue.computed(() => {
      const wrapKls = props.wrap || props.fill ? { flexWrap: "wrap" } : {};
      const alignment = {
        alignItems: props.alignment
      };
      const gap = {
        rowGap: `${verticalSize.value}px`,
        columnGap: `${horizontalSize.value}px`
      };
      return [wrapKls, alignment, gap, props.style];
    });
    const itemStyle = vue.computed(() => {
      return props.fill ? { flexGrow: 1, minWidth: `${props.fillRatio}%` } : {};
    });
    vue.watchEffect(() => {
      const { size = "small", wrap, direction: dir, fill } = props;
      if (isArray$1(size)) {
        const [h = 0, v = 0] = size;
        horizontalSize.value = h;
        verticalSize.value = v;
      } else {
        let val;
        if (isNumber(size)) {
          val = size;
        } else {
          val = SIZE_MAP[size || "small"] || SIZE_MAP.small;
        }
        if ((wrap || fill) && dir === "horizontal") {
          horizontalSize.value = verticalSize.value = val;
        } else {
          if (dir === "horizontal") {
            horizontalSize.value = val;
            verticalSize.value = 0;
          } else {
            verticalSize.value = val;
            horizontalSize.value = 0;
          }
        }
      }
    });
    return {
      classes,
      containerStyle,
      itemStyle
    };
  }

  const spaceProps = buildProps({
    direction: {
      type: String,
      values: ["horizontal", "vertical"],
      default: "horizontal"
    },
    class: {
      type: definePropType([
        String,
        Object,
        Array
      ]),
      default: ""
    },
    style: {
      type: definePropType([String, Array, Object]),
      default: ""
    },
    alignment: {
      type: definePropType(String),
      default: "center"
    },
    prefixCls: {
      type: String
    },
    spacer: {
      type: definePropType([Object, String, Number, Array]),
      default: null,
      validator: (val) => vue.isVNode(val) || isNumber(val) || isString$1(val)
    },
    wrap: Boolean,
    fill: Boolean,
    fillRatio: {
      type: Number,
      default: 100
    },
    size: {
      type: [String, Array, Number],
      values: componentSizes,
      validator: (val) => {
        return isNumber(val) || isArray$1(val) && val.length === 2 && val.every(isNumber);
      }
    }
  });
  const Space = vue.defineComponent({
    name: "ElSpace",
    props: spaceProps,
    setup(props, { slots }) {
      const { classes, containerStyle, itemStyle } = useSpace(props);
      function extractChildren(children, parentKey = "", extractedChildren = []) {
        const { prefixCls } = props;
        children.forEach((child, loopKey) => {
          if (isFragment(child)) {
            if (isArray$1(child.children)) {
              child.children.forEach((nested, key) => {
                if (isFragment(nested) && isArray$1(nested.children)) {
                  extractChildren(nested.children, `${parentKey + key}-`, extractedChildren);
                } else {
                  if (vue.isVNode(nested) && (nested == null ? void 0 : nested.type) === vue.Comment) {
                    extractedChildren.push(nested);
                  } else {
                    extractedChildren.push(vue.createVNode(SpaceItem, {
                      style: itemStyle.value,
                      prefixCls,
                      key: `nested-${parentKey + key}`
                    }, {
                      default: () => [nested]
                    }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
                  }
                }
              });
            }
          } else if (isValidElementNode(child)) {
            extractedChildren.push(vue.createVNode(SpaceItem, {
              style: itemStyle.value,
              prefixCls,
              key: `LoopKey${parentKey + loopKey}`
            }, {
              default: () => [child]
            }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
          }
        });
        return extractedChildren;
      }
      return () => {
        var _a;
        const { spacer, direction } = props;
        const children = vue.renderSlot(slots, "default", { key: 0 }, () => []);
        if (((_a = children.children) != null ? _a : []).length === 0)
          return null;
        if (isArray$1(children.children)) {
          let extractedChildren = extractChildren(children.children);
          if (spacer) {
            const len = extractedChildren.length - 1;
            extractedChildren = extractedChildren.reduce((acc, child, idx) => {
              const children2 = [...acc, child];
              if (idx !== len) {
                children2.push(vue.createVNode("span", {
                  style: [
                    itemStyle.value,
                    direction === "vertical" ? "width: 100%" : null
                  ],
                  key: idx
                }, [
                  vue.isVNode(spacer) ? spacer : vue.createTextVNode(spacer, PatchFlags.TEXT)
                ], PatchFlags.STYLE));
              }
              return children2;
            }, []);
          }
          return vue.createVNode("div", {
            class: classes.value,
            style: containerStyle.value
          }, extractedChildren, PatchFlags.STYLE | PatchFlags.CLASS);
        }
        return children.children;
      };
    }
  });

  const ElSpace = withInstall(Space);

  const statisticProps = buildProps({
    decimalSeparator: {
      type: String,
      default: "."
    },
    groupSeparator: {
      type: String,
      default: ","
    },
    precision: {
      type: Number,
      default: 0
    },
    formatter: Function,
    value: {
      type: definePropType([Number, Object]),
      default: 0
    },
    prefix: String,
    suffix: String,
    title: String,
    valueStyle: {
      type: definePropType([String, Object, Array])
    }
  });

  const __default__$x = vue.defineComponent({
    name: "ElStatistic"
  });
  const _sfc_main$E = /* @__PURE__ */ vue.defineComponent({
    ...__default__$x,
    props: statisticProps,
    setup(__props, { expose }) {
      const props = __props;
      const ns = useNamespace("statistic");
      const displayValue = vue.computed(() => {
        const { value, formatter, precision, decimalSeparator, groupSeparator } = props;
        if (isFunction$1(formatter))
          return formatter(value);
        if (!isNumber(value) || Number.isNaN(value))
          return value;
        let [integer, decimal = ""] = String(value).split(".");
        decimal = decimal.padEnd(precision, "0").slice(0, precision > 0 ? precision : 0);
        integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
        return [integer, decimal].join(decimal ? decimalSeparator : "");
      });
      expose({
        displayValue
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          _ctx.$slots.title || _ctx.title ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("head"))
          }, [
            vue.renderSlot(_ctx.$slots, "title", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
            ])
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("content"))
          }, [
            _ctx.$slots.prefix || _ctx.prefix ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("prefix"))
            }, [
              vue.renderSlot(_ctx.$slots, "prefix", {}, () => [
                vue.createElementVNode("span", null, vue.toDisplayString(_ctx.prefix), 1)
              ])
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(ns).e("number")),
              style: vue.normalizeStyle(_ctx.valueStyle)
            }, vue.toDisplayString(vue.unref(displayValue)), 7),
            _ctx.$slots.suffix || _ctx.suffix ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("suffix"))
            }, [
              vue.renderSlot(_ctx.$slots, "suffix", {}, () => [
                vue.createElementVNode("span", null, vue.toDisplayString(_ctx.suffix), 1)
              ])
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 2)
        ], 2);
      };
    }
  });
  var Statistic = /* @__PURE__ */ _export_sfc(_sfc_main$E, [["__file", "statistic.vue"]]);

  const ElStatistic = withInstall(Statistic);

  const countdownProps = buildProps({
    format: {
      type: String,
      default: "HH:mm:ss"
    },
    prefix: String,
    suffix: String,
    title: String,
    value: {
      type: definePropType([Number, Object]),
      default: 0
    },
    valueStyle: {
      type: definePropType([String, Object, Array])
    }
  });
  const countdownEmits = {
    finish: () => true,
    [CHANGE_EVENT]: (value) => isNumber(value)
  };

  const timeUnits = [
    ["Y", 1e3 * 60 * 60 * 24 * 365],
    ["M", 1e3 * 60 * 60 * 24 * 30],
    ["D", 1e3 * 60 * 60 * 24],
    ["H", 1e3 * 60 * 60],
    ["m", 1e3 * 60],
    ["s", 1e3],
    ["S", 1]
  ];
  const getTime = (value) => {
    return isNumber(value) ? new Date(value).getTime() : value.valueOf();
  };
  const formatTime$1 = (timestamp, format) => {
    let timeLeft = timestamp;
    const escapeRegex = /\[([^\]]*)]/g;
    const replacedText = timeUnits.reduce((current, [name, unit]) => {
      const replaceRegex = new RegExp(`${name}+(?![^\\[\\]]*\\])`, "g");
      if (replaceRegex.test(current)) {
        const value = Math.floor(timeLeft / unit);
        timeLeft -= value * unit;
        return current.replace(replaceRegex, (match) => String(value).padStart(match.length, "0"));
      }
      return current;
    }, format);
    return replacedText.replace(escapeRegex, "$1");
  };

  const __default__$w = vue.defineComponent({
    name: "ElCountdown"
  });
  const _sfc_main$D = /* @__PURE__ */ vue.defineComponent({
    ...__default__$w,
    props: countdownProps,
    emits: countdownEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      let timer;
      const rawValue = vue.ref(0);
      const displayValue = vue.computed(() => formatTime$1(rawValue.value, props.format));
      const formatter = (val) => formatTime$1(val, props.format);
      const stopTimer = () => {
        if (timer) {
          cAF(timer);
          timer = void 0;
        }
      };
      const startTimer = () => {
        const timestamp = getTime(props.value);
        const frameFunc = () => {
          let diff = timestamp - Date.now();
          emit(CHANGE_EVENT, diff);
          if (diff <= 0) {
            diff = 0;
            stopTimer();
            emit("finish");
          } else {
            timer = rAF(frameFunc);
          }
          rawValue.value = diff;
        };
        timer = rAF(frameFunc);
      };
      vue.onMounted(() => {
        rawValue.value = getTime(props.value) - Date.now();
        vue.watch(() => [props.value, props.format], () => {
          stopTimer();
          startTimer();
        }, {
          immediate: true
        });
      });
      vue.onBeforeUnmount(() => {
        stopTimer();
      });
      expose({
        displayValue
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElStatistic), {
          value: rawValue.value,
          title: _ctx.title,
          prefix: _ctx.prefix,
          suffix: _ctx.suffix,
          "value-style": _ctx.valueStyle,
          formatter
        }, vue.createSlots({
          _: 2
        }, [
          vue.renderList(_ctx.$slots, (_, name) => {
            return {
              name,
              fn: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, name)
              ])
            };
          })
        ]), 1032, ["value", "title", "prefix", "suffix", "value-style"]);
      };
    }
  });
  var Countdown = /* @__PURE__ */ _export_sfc(_sfc_main$D, [["__file", "countdown.vue"]]);

  const ElCountdown = withInstall(Countdown);

  const stepsProps = buildProps({
    space: {
      type: [Number, String],
      default: ""
    },
    active: {
      type: Number,
      default: 0
    },
    direction: {
      type: String,
      default: "horizontal",
      values: ["horizontal", "vertical"]
    },
    alignCenter: {
      type: Boolean
    },
    simple: {
      type: Boolean
    },
    finishStatus: {
      type: String,
      values: ["wait", "process", "finish", "error", "success"],
      default: "finish"
    },
    processStatus: {
      type: String,
      values: ["wait", "process", "finish", "error", "success"],
      default: "process"
    }
  });
  const stepsEmits = {
    [CHANGE_EVENT]: (newVal, oldVal) => [newVal, oldVal].every(isNumber)
  };

  const STEPS_INJECTION_KEY = "ElSteps";

  const __default__$v = vue.defineComponent({
    name: "ElSteps"
  });
  const _sfc_main$C = /* @__PURE__ */ vue.defineComponent({
    ...__default__$v,
    props: stepsProps,
    emits: stepsEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("steps");
      const {
        children: steps,
        addChild: addStep,
        removeChild: removeStep,
        ChildrenSorter: StepsSorter
      } = useOrderedChildren(vue.getCurrentInstance(), "ElStep");
      vue.watch(steps, () => {
        steps.value.forEach((instance, index) => {
          instance.setIndex(index);
        });
      });
      vue.provide(STEPS_INJECTION_KEY, { props, steps, addStep, removeStep });
      vue.watch(() => props.active, (newVal, oldVal) => {
        emit(CHANGE_EVENT, newVal, oldVal);
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.simple ? "simple" : _ctx.direction)])
        }, [
          vue.renderSlot(_ctx.$slots, "default"),
          vue.createVNode(vue.unref(StepsSorter))
        ], 2);
      };
    }
  });
  var Steps = /* @__PURE__ */ _export_sfc(_sfc_main$C, [["__file", "steps.vue"]]);

  const stepProps = buildProps({
    title: {
      type: String,
      default: ""
    },
    icon: {
      type: iconPropType
    },
    description: {
      type: String,
      default: ""
    },
    status: {
      type: String,
      values: ["", "wait", "process", "finish", "error", "success"],
      default: ""
    }
  });

  const __default__$u = vue.defineComponent({
    name: "ElStep"
  });
  const _sfc_main$B = vue.defineComponent({
    ...__default__$u,
    props: stepProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("step");
      const index = vue.ref(-1);
      const lineStyle = vue.ref({});
      const internalStatus = vue.ref("");
      const parent = vue.inject(STEPS_INJECTION_KEY);
      const currentInstance = vue.getCurrentInstance();
      let stepDiff = 0;
      let beforeActive = 0;
      vue.onMounted(() => {
        vue.watch([
          () => parent.props.active,
          () => parent.props.processStatus,
          () => parent.props.finishStatus
        ], ([active], [oldActive]) => {
          beforeActive = oldActive || 0;
          stepDiff = active - beforeActive;
          updateStatus(active);
        }, { immediate: true });
      });
      const currentStatus = vue.computed(() => {
        return props.status || internalStatus.value;
      });
      const prevInternalStatus = vue.computed(() => {
        const prevStep = parent.steps.value[index.value - 1];
        return prevStep ? prevStep.internalStatus.value : "wait";
      });
      const isCenter = vue.computed(() => {
        return parent.props.alignCenter;
      });
      const isVertical = vue.computed(() => {
        return parent.props.direction === "vertical";
      });
      const isSimple = vue.computed(() => {
        return parent.props.simple;
      });
      const stepsCount = vue.computed(() => {
        return parent.steps.value.length;
      });
      const isLast = vue.computed(() => {
        var _a;
        return ((_a = parent.steps.value[stepsCount.value - 1]) == null ? void 0 : _a.uid) === currentInstance.uid;
      });
      const space = vue.computed(() => {
        return isSimple.value ? "" : parent.props.space;
      });
      const containerKls = vue.computed(() => {
        return [
          ns.b(),
          ns.is(isSimple.value ? "simple" : parent.props.direction),
          ns.is("flex", isLast.value && !space.value && !isCenter.value),
          ns.is("center", isCenter.value && !isVertical.value && !isSimple.value)
        ];
      });
      const style = vue.computed(() => {
        const style2 = {
          flexBasis: isNumber(space.value) ? `${space.value}px` : space.value ? space.value : `${100 / (stepsCount.value - (isCenter.value ? 0 : 1))}%`
        };
        if (isVertical.value)
          return style2;
        if (isLast.value) {
          style2.maxWidth = `${100 / stepsCount.value}%`;
        }
        return style2;
      });
      const setIndex = (val) => {
        index.value = val;
      };
      const calcProgress = (status) => {
        const isWait = status === "wait";
        const delayTimer = Math.abs(stepDiff) === 1 ? 0 : stepDiff > 0 ? (index.value + 1 - beforeActive) * 150 : -(index.value + 1 - parent.props.active) * 150;
        const style2 = {
          transitionDelay: `${delayTimer}ms`
        };
        const step = status === parent.props.processStatus || isWait ? 0 : 100;
        style2.borderWidth = step && !isSimple.value ? "1px" : 0;
        style2[parent.props.direction === "vertical" ? "height" : "width"] = `${step}%`;
        lineStyle.value = style2;
      };
      const updateStatus = (activeIndex) => {
        if (activeIndex > index.value) {
          internalStatus.value = parent.props.finishStatus;
        } else if (activeIndex === index.value && prevInternalStatus.value !== "error") {
          internalStatus.value = parent.props.processStatus;
        } else {
          internalStatus.value = "wait";
        }
        const prevChild = parent.steps.value[index.value - 1];
        if (prevChild)
          prevChild.calcProgress(internalStatus.value);
      };
      const stepItemState = {
        uid: currentInstance.uid,
        getVnode: () => currentInstance.vnode,
        currentStatus,
        internalStatus,
        setIndex,
        calcProgress
      };
      parent.addStep(stepItemState);
      vue.onBeforeUnmount(() => {
        parent.removeStep(stepItemState);
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          style: vue.normalizeStyle(vue.unref(style)),
          class: vue.normalizeClass(vue.unref(containerKls))
        }, [
          vue.createCommentVNode(" icon & line "),
          vue.createElementVNode("div", {
            class: vue.normalizeClass([vue.unref(ns).e("head"), vue.unref(ns).is(vue.unref(currentStatus))])
          }, [
            !vue.unref(isSimple) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("line"))
            }, [
              vue.createElementVNode("i", {
                class: vue.normalizeClass(vue.unref(ns).e("line-inner")),
                style: vue.normalizeStyle(lineStyle.value)
              }, null, 6)
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(ns).is(_ctx.icon || _ctx.$slots.icon ? "icon" : "text")])
            }, [
              vue.renderSlot(_ctx.$slots, "icon", {}, () => [
                _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).e("icon-inner"))
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.unref(currentStatus) === "success" ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 1,
                  class: vue.normalizeClass([vue.unref(ns).e("icon-inner"), vue.unref(ns).is("status")])
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(check_default))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.unref(currentStatus) === "error" ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 2,
                  class: vue.normalizeClass([vue.unref(ns).e("icon-inner"), vue.unref(ns).is("status")])
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(close_default))
                  ]),
                  _: 1
                }, 8, ["class"])) : !vue.unref(isSimple) ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 3,
                  class: vue.normalizeClass(vue.unref(ns).e("icon-inner"))
                }, vue.toDisplayString(index.value + 1), 3)) : vue.createCommentVNode("v-if", true)
              ])
            ], 2)
          ], 2),
          vue.createCommentVNode(" title & description "),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("main"))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass([vue.unref(ns).e("title"), vue.unref(ns).is(vue.unref(currentStatus))])
            }, [
              vue.renderSlot(_ctx.$slots, "title", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
              ])
            ], 2),
            vue.unref(isSimple) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("arrow"))
            }, null, 2)) : (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass([vue.unref(ns).e("description"), vue.unref(ns).is(vue.unref(currentStatus))])
            }, [
              vue.renderSlot(_ctx.$slots, "description", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.description), 1)
              ])
            ], 2))
          ], 2)
        ], 6);
      };
    }
  });
  var Step = /* @__PURE__ */ _export_sfc(_sfc_main$B, [["__file", "item.vue"]]);

  const ElSteps = withInstall(Steps, {
    Step
  });
  const ElStep = withNoopInstall(Step);

  const switchProps = buildProps({
    modelValue: {
      type: [Boolean, String, Number],
      default: false
    },
    disabled: Boolean,
    loading: Boolean,
    size: {
      type: String,
      validator: isValidComponentSize
    },
    width: {
      type: [String, Number],
      default: ""
    },
    inlinePrompt: Boolean,
    inactiveActionIcon: {
      type: iconPropType
    },
    activeActionIcon: {
      type: iconPropType
    },
    activeIcon: {
      type: iconPropType
    },
    inactiveIcon: {
      type: iconPropType
    },
    activeText: {
      type: String,
      default: ""
    },
    inactiveText: {
      type: String,
      default: ""
    },
    activeValue: {
      type: [Boolean, String, Number],
      default: true
    },
    inactiveValue: {
      type: [Boolean, String, Number],
      default: false
    },
    name: {
      type: String,
      default: ""
    },
    validateEvent: {
      type: Boolean,
      default: true
    },
    beforeChange: {
      type: definePropType(Function)
    },
    id: String,
    tabindex: {
      type: [String, Number]
    },
    ...useAriaProps(["ariaLabel"])
  });
  const switchEmits = {
    [UPDATE_MODEL_EVENT]: (val) => isBoolean(val) || isString$1(val) || isNumber(val),
    [CHANGE_EVENT]: (val) => isBoolean(val) || isString$1(val) || isNumber(val),
    [INPUT_EVENT]: (val) => isBoolean(val) || isString$1(val) || isNumber(val)
  };

  const COMPONENT_NAME$9 = "ElSwitch";
  const __default__$t = vue.defineComponent({
    name: COMPONENT_NAME$9
  });
  const _sfc_main$A = /* @__PURE__ */ vue.defineComponent({
    ...__default__$t,
    props: switchProps,
    emits: switchEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const { formItem } = useFormItem();
      const switchSize = useFormSize();
      const ns = useNamespace("switch");
      const { inputId } = useFormItemInputId(props, {
        formItemContext: formItem
      });
      const switchDisabled = useFormDisabled(vue.computed(() => props.loading));
      const isControlled = vue.ref(props.modelValue !== false);
      const input = vue.shallowRef();
      const switchKls = vue.computed(() => [
        ns.b(),
        ns.m(switchSize.value),
        ns.is("disabled", switchDisabled.value),
        ns.is("checked", checked.value)
      ]);
      const labelLeftKls = vue.computed(() => [
        ns.e("label"),
        ns.em("label", "left"),
        ns.is("active", !checked.value)
      ]);
      const labelRightKls = vue.computed(() => [
        ns.e("label"),
        ns.em("label", "right"),
        ns.is("active", checked.value)
      ]);
      const coreStyle = vue.computed(() => ({
        width: addUnit(props.width)
      }));
      vue.watch(() => props.modelValue, () => {
        isControlled.value = true;
      });
      const actualValue = vue.computed(() => {
        return isControlled.value ? props.modelValue : false;
      });
      const checked = vue.computed(() => actualValue.value === props.activeValue);
      if (![props.activeValue, props.inactiveValue].includes(actualValue.value)) {
        emit(UPDATE_MODEL_EVENT, props.inactiveValue);
        emit(CHANGE_EVENT, props.inactiveValue);
        emit(INPUT_EVENT, props.inactiveValue);
      }
      vue.watch(checked, (val) => {
        var _a;
        input.value.checked = val;
        if (props.validateEvent) {
          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
        }
      });
      const handleChange = () => {
        const val = checked.value ? props.inactiveValue : props.activeValue;
        emit(UPDATE_MODEL_EVENT, val);
        emit(CHANGE_EVENT, val);
        emit(INPUT_EVENT, val);
        vue.nextTick(() => {
          input.value.checked = checked.value;
        });
      };
      const switchValue = () => {
        if (switchDisabled.value)
          return;
        const { beforeChange } = props;
        if (!beforeChange) {
          handleChange();
          return;
        }
        const shouldChange = beforeChange();
        const isPromiseOrBool = [
          isPromise(shouldChange),
          isBoolean(shouldChange)
        ].includes(true);
        if (!isPromiseOrBool) {
          throwError(COMPONENT_NAME$9, "beforeChange must return type `Promise<boolean>` or `boolean`");
        }
        if (isPromise(shouldChange)) {
          shouldChange.then((result) => {
            if (result) {
              handleChange();
            }
          }).catch((e) => {
            debugWarn(COMPONENT_NAME$9, `some error occurred: ${e}`);
          });
        } else if (shouldChange) {
          handleChange();
        }
      };
      const focus = () => {
        var _a, _b;
        (_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
      };
      vue.onMounted(() => {
        input.value.checked = checked.value;
      });
      expose({
        focus,
        checked
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(switchKls)),
          onClick: vue.withModifiers(switchValue, ["prevent"])
        }, [
          vue.createElementVNode("input", {
            id: vue.unref(inputId),
            ref_key: "input",
            ref: input,
            class: vue.normalizeClass(vue.unref(ns).e("input")),
            type: "checkbox",
            role: "switch",
            "aria-checked": vue.unref(checked),
            "aria-disabled": vue.unref(switchDisabled),
            "aria-label": _ctx.ariaLabel,
            name: _ctx.name,
            "true-value": _ctx.activeValue,
            "false-value": _ctx.inactiveValue,
            disabled: vue.unref(switchDisabled),
            tabindex: _ctx.tabindex,
            onChange: handleChange,
            onKeydown: vue.withKeys(switchValue, ["enter"])
          }, null, 42, ["id", "aria-checked", "aria-disabled", "aria-label", "name", "true-value", "false-value", "disabled", "tabindex", "onKeydown"]),
          !_ctx.inlinePrompt && (_ctx.inactiveIcon || _ctx.inactiveText) ? (vue.openBlock(), vue.createElementBlock("span", {
            key: 0,
            class: vue.normalizeClass(vue.unref(labelLeftKls))
          }, [
            _ctx.inactiveIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.inactiveIcon)))
              ]),
              _: 1
            })) : vue.createCommentVNode("v-if", true),
            !_ctx.inactiveIcon && _ctx.inactiveText ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 1,
              "aria-hidden": vue.unref(checked)
            }, vue.toDisplayString(_ctx.inactiveText), 9, ["aria-hidden"])) : vue.createCommentVNode("v-if", true)
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("span", {
            class: vue.normalizeClass(vue.unref(ns).e("core")),
            style: vue.normalizeStyle(vue.unref(coreStyle))
          }, [
            _ctx.inlinePrompt ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("inner"))
            }, [
              _ctx.activeIcon || _ctx.inactiveIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).is("icon"))
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(checked) ? _ctx.activeIcon : _ctx.inactiveIcon)))
                ]),
                _: 1
              }, 8, ["class"])) : _ctx.activeText || _ctx.inactiveText ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 1,
                class: vue.normalizeClass(vue.unref(ns).is("text")),
                "aria-hidden": !vue.unref(checked)
              }, vue.toDisplayString(vue.unref(checked) ? _ctx.activeText : _ctx.inactiveText), 11, ["aria-hidden"])) : vue.createCommentVNode("v-if", true)
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("action"))
            }, [
              _ctx.loading ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).is("loading"))
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(vue.unref(loading_default))
                ]),
                _: 1
              }, 8, ["class"])) : vue.unref(checked) ? vue.renderSlot(_ctx.$slots, "active-action", { key: 1 }, () => [
                _ctx.activeActionIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.activeActionIcon)))
                  ]),
                  _: 1
                })) : vue.createCommentVNode("v-if", true)
              ]) : !vue.unref(checked) ? vue.renderSlot(_ctx.$slots, "inactive-action", { key: 2 }, () => [
                _ctx.inactiveActionIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.inactiveActionIcon)))
                  ]),
                  _: 1
                })) : vue.createCommentVNode("v-if", true)
              ]) : vue.createCommentVNode("v-if", true)
            ], 2)
          ], 6),
          !_ctx.inlinePrompt && (_ctx.activeIcon || _ctx.activeText) ? (vue.openBlock(), vue.createElementBlock("span", {
            key: 1,
            class: vue.normalizeClass(vue.unref(labelRightKls))
          }, [
            _ctx.activeIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.activeIcon)))
              ]),
              _: 1
            })) : vue.createCommentVNode("v-if", true),
            !_ctx.activeIcon && _ctx.activeText ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 1,
              "aria-hidden": !vue.unref(checked)
            }, vue.toDisplayString(_ctx.activeText), 9, ["aria-hidden"])) : vue.createCommentVNode("v-if", true)
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 10, ["onClick"]);
      };
    }
  });
  var Switch = /* @__PURE__ */ _export_sfc(_sfc_main$A, [["__file", "switch.vue"]]);

  const ElSwitch = withInstall(Switch);

  const getCell = function(event) {
    var _a;
    return (_a = event.target) == null ? void 0 : _a.closest("td");
  };
  const orderBy = function(array, sortKey, reverse, sortMethod, sortBy) {
    if (!sortKey && !sortMethod && (!sortBy || isArray$1(sortBy) && !sortBy.length)) {
      return array;
    }
    if (isString$1(reverse)) {
      reverse = reverse === "descending" ? -1 : 1;
    } else {
      reverse = reverse && reverse < 0 ? -1 : 1;
    }
    const getKey = sortMethod ? null : function(value, index) {
      if (sortBy) {
        return flatMap(castArray$1(sortBy), (by) => {
          if (isString$1(by)) {
            return get(value, by);
          } else {
            return by(value, index, array);
          }
        });
      }
      if (sortKey !== "$key") {
        if (isObject$1(value) && "$value" in value)
          value = value.$value;
      }
      return [
        isObject$1(value) ? sortKey ? get(value, sortKey) : null : value
      ];
    };
    const compare = function(a, b) {
      var _a, _b, _c, _d, _e, _f;
      if (sortMethod) {
        return sortMethod(a.value, b.value);
      }
      for (let i = 0, len = (_b = (_a = a.key) == null ? void 0 : _a.length) != null ? _b : 0; i < len; i++) {
        if (((_c = a.key) == null ? void 0 : _c[i]) < ((_d = b.key) == null ? void 0 : _d[i])) {
          return -1;
        }
        if (((_e = a.key) == null ? void 0 : _e[i]) > ((_f = b.key) == null ? void 0 : _f[i])) {
          return 1;
        }
      }
      return 0;
    };
    return array.map((value, index) => {
      return {
        value,
        index,
        key: getKey ? getKey(value, index) : null
      };
    }).sort((a, b) => {
      let order = compare(a, b);
      if (!order) {
        order = a.index - b.index;
      }
      return order * +reverse;
    }).map((item) => item.value);
  };
  const getColumnById = function(table, columnId) {
    let column = null;
    table.columns.forEach((item) => {
      if (item.id === columnId) {
        column = item;
      }
    });
    return column;
  };
  const getColumnByKey = function(table, columnKey) {
    let column = null;
    for (let i = 0; i < table.columns.length; i++) {
      const item = table.columns[i];
      if (item.columnKey === columnKey) {
        column = item;
        break;
      }
    }
    if (!column)
      throwError("ElTable", `No column matching with column-key: ${columnKey}`);
    return column;
  };
  const getColumnByCell = function(table, cell, namespace) {
    const matches = (cell.className || "").match(new RegExp(`${namespace}-table_[^\\s]+`, "gm"));
    if (matches) {
      return getColumnById(table, matches[0]);
    }
    return null;
  };
  const getRowIdentity = (row, rowKey) => {
    if (!row)
      throw new Error("Row is required when get row identity");
    if (isString$1(rowKey)) {
      if (!rowKey.includes(".")) {
        return `${row[rowKey]}`;
      }
      const key = rowKey.split(".");
      let current = row;
      for (const element of key) {
        current = current[element];
      }
      return `${current}`;
    } else if (isFunction$1(rowKey)) {
      return rowKey.call(null, row);
    }
    return "";
  };
  const getKeysMap = function(array, rowKey, flatten = false, childrenKey = "children") {
    const data = array || [];
    const arrayMap = {};
    data.forEach((row, index) => {
      arrayMap[getRowIdentity(row, rowKey)] = { row, index };
      if (flatten) {
        const children = row[childrenKey];
        if (isArray$1(children)) {
          Object.assign(arrayMap, getKeysMap(children, rowKey, true, childrenKey));
        }
      }
    });
    return arrayMap;
  };
  function mergeOptions(defaults, config) {
    const options = {};
    let key;
    for (key in defaults) {
      options[key] = defaults[key];
    }
    for (key in config) {
      if (hasOwn(config, key)) {
        const value = config[key];
        if (!isUndefined(value)) {
          options[key] = value;
        }
      }
    }
    return options;
  }
  function parseWidth(width) {
    if (width === "")
      return width;
    if (!isUndefined(width)) {
      width = Number.parseInt(width, 10);
      if (Number.isNaN(width)) {
        width = "";
      }
    }
    return width;
  }
  function parseMinWidth(minWidth) {
    if (minWidth === "")
      return minWidth;
    if (!isUndefined(minWidth)) {
      minWidth = parseWidth(minWidth);
      if (Number.isNaN(minWidth)) {
        minWidth = 80;
      }
    }
    return minWidth;
  }
  function parseHeight(height) {
    if (isNumber(height)) {
      return height;
    }
    if (isString$1(height)) {
      if (/^\d+(?:px)?$/.test(height)) {
        return Number.parseInt(height, 10);
      } else {
        return height;
      }
    }
    return null;
  }
  function compose(...funcs) {
    if (funcs.length === 0) {
      return (arg) => arg;
    }
    if (funcs.length === 1) {
      return funcs[0];
    }
    return funcs.reduce((a, b) => (...args) => a(b(...args)));
  }
  function toggleRowStatus(statusArr, row, newVal, tableTreeProps, selectable, rowIndex, rowKey) {
    let _rowIndex = rowIndex != null ? rowIndex : 0;
    let changed = false;
    const getIndex = () => {
      if (!rowKey) {
        return statusArr.indexOf(row);
      }
      const id = getRowIdentity(row, rowKey);
      return statusArr.findIndex((item) => getRowIdentity(item, rowKey) === id);
    };
    const index = getIndex();
    const included = index !== -1;
    const isRowSelectable = selectable == null ? void 0 : selectable.call(null, row, _rowIndex);
    const toggleStatus = (type) => {
      if (type === "add") {
        statusArr.push(row);
      } else {
        statusArr.splice(index, 1);
      }
      changed = true;
    };
    const getChildrenCount = (row2) => {
      let count = 0;
      const children = (tableTreeProps == null ? void 0 : tableTreeProps.children) && row2[tableTreeProps.children];
      if (children && isArray$1(children)) {
        count += children.length;
        children.forEach((item) => {
          count += getChildrenCount(item);
        });
      }
      return count;
    };
    if (!selectable || isRowSelectable) {
      if (isBoolean(newVal)) {
        if (newVal && !included) {
          toggleStatus("add");
        } else if (!newVal && included) {
          toggleStatus("remove");
        }
      } else {
        included ? toggleStatus("remove") : toggleStatus("add");
      }
    }
    if (!(tableTreeProps == null ? void 0 : tableTreeProps.checkStrictly) && (tableTreeProps == null ? void 0 : tableTreeProps.children) && isArray$1(row[tableTreeProps.children])) {
      row[tableTreeProps.children].forEach((item) => {
        const childChanged = toggleRowStatus(statusArr, item, newVal != null ? newVal : !included, tableTreeProps, selectable, _rowIndex + 1, rowKey);
        _rowIndex += getChildrenCount(item) + 1;
        if (childChanged) {
          changed = childChanged;
        }
      });
    }
    return changed;
  }
  function walkTreeNode(root, cb, childrenKey = "children", lazyKey = "hasChildren", lazy = false) {
    const isNil = (array) => !(isArray$1(array) && array.length);
    function _walker(parent, children, level) {
      cb(parent, children, level);
      children.forEach((item) => {
        if (item[lazyKey] && lazy) {
          cb(item, null, level + 1);
          return;
        }
        const children2 = item[childrenKey];
        if (!isNil(children2)) {
          _walker(item, children2, level + 1);
        }
      });
    }
    root.forEach((item) => {
      if (item[lazyKey] && lazy) {
        cb(item, null, 0);
        return;
      }
      const children = item[childrenKey];
      if (!isNil(children)) {
        _walker(item, children, 0);
      }
    });
  }
  const getTableOverflowTooltipProps = (props, innerText, row, column) => {
    const popperOptions = {
      strategy: "fixed",
      ...props.popperOptions
    };
    const tooltipFormatterContent = isFunction$1(column == null ? void 0 : column.tooltipFormatter) ? column.tooltipFormatter({
      row,
      column,
      cellValue: getProp(row, column.property).value
    }) : void 0;
    if (vue.isVNode(tooltipFormatterContent)) {
      return {
        slotContent: tooltipFormatterContent,
        content: null,
        ...props,
        popperOptions
      };
    }
    return {
      slotContent: null,
      content: tooltipFormatterContent != null ? tooltipFormatterContent : innerText,
      ...props,
      popperOptions
    };
  };
  let removePopper = null;
  function createTablePopper(props, popperContent, row, column, trigger, table) {
    var _a;
    const tableOverflowTooltipProps = getTableOverflowTooltipProps(props, popperContent, row, column);
    const mergedProps = {
      ...tableOverflowTooltipProps,
      slotContent: void 0
    };
    if ((removePopper == null ? void 0 : removePopper.trigger) === trigger) {
      const comp = (_a = removePopper.vm) == null ? void 0 : _a.component;
      merge(comp == null ? void 0 : comp.props, mergedProps);
      if (comp && tableOverflowTooltipProps.slotContent) {
        comp.slots.content = () => [tableOverflowTooltipProps.slotContent];
      }
      return;
    }
    removePopper == null ? void 0 : removePopper();
    const parentNode = table == null ? void 0 : table.refs.tableWrapper;
    const ns = parentNode == null ? void 0 : parentNode.dataset.prefix;
    const vm = vue.createVNode(ElTooltip, {
      virtualTriggering: true,
      virtualRef: trigger,
      appendTo: parentNode,
      placement: "top",
      transition: "none",
      offset: 0,
      hideAfter: 0,
      ...mergedProps
    }, tableOverflowTooltipProps.slotContent ? {
      content: () => tableOverflowTooltipProps.slotContent
    } : void 0);
    vm.appContext = { ...table.appContext, ...table };
    const container = document.createElement("div");
    vue.render(vm, container);
    vm.component.exposed.onOpen();
    const scrollContainer = parentNode == null ? void 0 : parentNode.querySelector(`.${ns}-scrollbar__wrap`);
    removePopper = () => {
      var _a2, _b;
      if ((_b = (_a2 = vm.component) == null ? void 0 : _a2.exposed) == null ? void 0 : _b.onClose) {
        vm.component.exposed.onClose();
      }
      vue.render(null, container);
      const currentRemovePopper = removePopper;
      scrollContainer == null ? void 0 : scrollContainer.removeEventListener("scroll", currentRemovePopper);
      currentRemovePopper.trigger = void 0;
      currentRemovePopper.vm = void 0;
      removePopper = null;
    };
    removePopper.trigger = trigger != null ? trigger : void 0;
    removePopper.vm = vm;
    scrollContainer == null ? void 0 : scrollContainer.addEventListener("scroll", removePopper);
  }
  function getCurrentColumns(column) {
    if (column.children) {
      return flatMap(column.children, getCurrentColumns);
    } else {
      return [column];
    }
  }
  function getColSpan(colSpan, column) {
    return colSpan + column.colSpan;
  }
  const isFixedColumn = (index, fixed, store, realColumns) => {
    let start = 0;
    let after = index;
    const columns = store.states.columns.value;
    if (realColumns) {
      const curColumns = getCurrentColumns(realColumns[index]);
      const preColumns = columns.slice(0, columns.indexOf(curColumns[0]));
      start = preColumns.reduce(getColSpan, 0);
      after = start + curColumns.reduce(getColSpan, 0) - 1;
    } else {
      start = index;
    }
    let fixedLayout;
    switch (fixed) {
      case "left":
        if (after < store.states.fixedLeafColumnsLength.value) {
          fixedLayout = "left";
        }
        break;
      case "right":
        if (start >= columns.length - store.states.rightFixedLeafColumnsLength.value) {
          fixedLayout = "right";
        }
        break;
      default:
        if (after < store.states.fixedLeafColumnsLength.value) {
          fixedLayout = "left";
        } else if (start >= columns.length - store.states.rightFixedLeafColumnsLength.value) {
          fixedLayout = "right";
        }
    }
    return fixedLayout ? {
      direction: fixedLayout,
      start,
      after
    } : {};
  };
  const getFixedColumnsClass = (namespace, index, fixed, store, realColumns, offset = 0) => {
    const classes = [];
    const { direction, start, after } = isFixedColumn(index, fixed, store, realColumns);
    if (direction) {
      const isLeft = direction === "left";
      classes.push(`${namespace}-fixed-column--${direction}`);
      if (isLeft && after + offset === store.states.fixedLeafColumnsLength.value - 1) {
        classes.push("is-last-column");
      } else if (!isLeft && start - offset === store.states.columns.value.length - store.states.rightFixedLeafColumnsLength.value) {
        classes.push("is-first-column");
      }
    }
    return classes;
  };
  function getOffset(offset, column) {
    return offset + (isNull(column.realWidth) || Number.isNaN(column.realWidth) ? Number(column.width) : column.realWidth);
  }
  const getFixedColumnOffset = (index, fixed, store, realColumns) => {
    const {
      direction,
      start = 0,
      after = 0
    } = isFixedColumn(index, fixed, store, realColumns);
    if (!direction) {
      return;
    }
    const styles = {};
    const isLeft = direction === "left";
    const columns = store.states.columns.value;
    if (isLeft) {
      styles.left = columns.slice(0, start).reduce(getOffset, 0);
    } else {
      styles.right = columns.slice(after + 1).reverse().reduce(getOffset, 0);
    }
    return styles;
  };
  const ensurePosition = (style, key) => {
    if (!style)
      return;
    if (!Number.isNaN(style[key])) {
      style[key] = `${style[key]}px`;
    }
  };

  function useExpand(watcherData) {
    const instance = vue.getCurrentInstance();
    const defaultExpandAll = vue.ref(false);
    const expandRows = vue.ref([]);
    const updateExpandRows = () => {
      const data = watcherData.data.value || [];
      const rowKey = watcherData.rowKey.value;
      if (defaultExpandAll.value) {
        expandRows.value = data.slice();
      } else if (rowKey) {
        const expandRowsMap = getKeysMap(expandRows.value, rowKey);
        expandRows.value = data.reduce((prev, row) => {
          const rowId = getRowIdentity(row, rowKey);
          const rowInfo = expandRowsMap[rowId];
          if (rowInfo) {
            prev.push(row);
          }
          return prev;
        }, []);
      } else {
        expandRows.value = [];
      }
    };
    const toggleRowExpansion = (row, expanded) => {
      const changed = toggleRowStatus(expandRows.value, row, expanded, void 0, void 0, void 0, watcherData.rowKey.value);
      if (changed) {
        instance.emit("expand-change", row, expandRows.value.slice());
      }
    };
    const setExpandRowKeys = (rowKeys) => {
      instance.store.assertRowKey();
      const data = watcherData.data.value || [];
      const rowKey = watcherData.rowKey.value;
      const keysMap = getKeysMap(data, rowKey);
      expandRows.value = rowKeys.reduce((prev, cur) => {
        const info = keysMap[cur];
        if (info) {
          prev.push(info.row);
        }
        return prev;
      }, []);
    };
    const isRowExpanded = (row) => {
      const rowKey = watcherData.rowKey.value;
      if (rowKey) {
        const expandMap = getKeysMap(expandRows.value, rowKey);
        return !!expandMap[getRowIdentity(row, rowKey)];
      }
      return expandRows.value.includes(row);
    };
    return {
      updateExpandRows,
      toggleRowExpansion,
      setExpandRowKeys,
      isRowExpanded,
      states: {
        expandRows,
        defaultExpandAll
      }
    };
  }

  function useCurrent(watcherData) {
    const instance = vue.getCurrentInstance();
    const _currentRowKey = vue.ref(null);
    const currentRow = vue.ref(null);
    const setCurrentRowKey = (key) => {
      instance.store.assertRowKey();
      _currentRowKey.value = key;
      setCurrentRowByKey(key);
    };
    const restoreCurrentRowKey = () => {
      _currentRowKey.value = null;
    };
    const setCurrentRowByKey = (key) => {
      var _a;
      const { data, rowKey } = watcherData;
      let _currentRow = null;
      if (rowKey.value) {
        _currentRow = (_a = (vue.unref(data) || []).find((item) => getRowIdentity(item, rowKey.value) === key)) != null ? _a : null;
      }
      currentRow.value = _currentRow != null ? _currentRow : null;
      instance.emit("current-change", currentRow.value, null);
    };
    const updateCurrentRow = (_currentRow) => {
      const oldCurrentRow = currentRow.value;
      if (_currentRow && _currentRow !== oldCurrentRow) {
        currentRow.value = _currentRow;
        instance.emit("current-change", currentRow.value, oldCurrentRow);
        return;
      }
      if (!_currentRow && oldCurrentRow) {
        currentRow.value = null;
        instance.emit("current-change", null, oldCurrentRow);
      }
    };
    const updateCurrentRowData = () => {
      const rowKey = watcherData.rowKey.value;
      const data = watcherData.data.value || [];
      const oldCurrentRow = currentRow.value;
      if (oldCurrentRow && !data.includes(oldCurrentRow)) {
        if (rowKey) {
          const currentRowKey = getRowIdentity(oldCurrentRow, rowKey);
          setCurrentRowByKey(currentRowKey);
        } else {
          currentRow.value = null;
        }
        if (isNull(currentRow.value)) {
          instance.emit("current-change", null, oldCurrentRow);
        }
      } else if (_currentRowKey.value) {
        setCurrentRowByKey(_currentRowKey.value);
        restoreCurrentRowKey();
      }
    };
    return {
      setCurrentRowKey,
      restoreCurrentRowKey,
      setCurrentRowByKey,
      updateCurrentRow,
      updateCurrentRowData,
      states: {
        _currentRowKey,
        currentRow
      }
    };
  }

  function useTree$2(watcherData) {
    const expandRowKeys = vue.ref([]);
    const treeData = vue.ref({});
    const indent = vue.ref(16);
    const lazy = vue.ref(false);
    const lazyTreeNodeMap = vue.ref({});
    const lazyColumnIdentifier = vue.ref("hasChildren");
    const childrenColumnName = vue.ref("children");
    const checkStrictly = vue.ref(false);
    const instance = vue.getCurrentInstance();
    const normalizedData = vue.computed(() => {
      if (!watcherData.rowKey.value)
        return {};
      const data = watcherData.data.value || [];
      return normalize(data);
    });
    const normalizedLazyNode = vue.computed(() => {
      const rowKey = watcherData.rowKey.value;
      const keys = Object.keys(lazyTreeNodeMap.value);
      const res = {};
      if (!keys.length)
        return res;
      keys.forEach((key) => {
        if (lazyTreeNodeMap.value[key].length) {
          const item = { children: [] };
          lazyTreeNodeMap.value[key].forEach((row) => {
            const currentRowKey = getRowIdentity(row, rowKey);
            item.children.push(currentRowKey);
            if (row[lazyColumnIdentifier.value] && !res[currentRowKey]) {
              res[currentRowKey] = { children: [] };
            }
          });
          res[key] = item;
        }
      });
      return res;
    });
    const normalize = (data) => {
      const rowKey = watcherData.rowKey.value;
      const res = {};
      walkTreeNode(data, (parent, children, level) => {
        const parentId = getRowIdentity(parent, rowKey);
        if (isArray$1(children)) {
          res[parentId] = {
            children: children.map((row) => getRowIdentity(row, rowKey)),
            level
          };
        } else if (lazy.value) {
          res[parentId] = {
            children: [],
            lazy: true,
            level
          };
        }
      }, childrenColumnName.value, lazyColumnIdentifier.value, lazy.value);
      return res;
    };
    const updateTreeData = (ifChangeExpandRowKeys = false, ifExpandAll) => {
      var _a, _b;
      ifExpandAll || (ifExpandAll = (_a = instance.store) == null ? void 0 : _a.states.defaultExpandAll.value);
      const nested = normalizedData.value;
      const normalizedLazyNode_ = normalizedLazyNode.value;
      const keys = Object.keys(nested);
      const newTreeData = {};
      if (keys.length) {
        const oldTreeData = vue.unref(treeData);
        const rootLazyRowKeys = [];
        const getExpanded = (oldValue, key) => {
          if (ifChangeExpandRowKeys) {
            if (expandRowKeys.value) {
              return ifExpandAll || expandRowKeys.value.includes(key);
            } else {
              return !!(ifExpandAll || (oldValue == null ? void 0 : oldValue.expanded));
            }
          } else {
            const included = ifExpandAll || expandRowKeys.value && expandRowKeys.value.includes(key);
            return !!((oldValue == null ? void 0 : oldValue.expanded) || included);
          }
        };
        keys.forEach((key) => {
          const oldValue = oldTreeData[key];
          const newValue = { ...nested[key] };
          newValue.expanded = getExpanded(oldValue, key);
          if (newValue.lazy) {
            const { loaded = false, loading = false } = oldValue || {};
            newValue.loaded = !!loaded;
            newValue.loading = !!loading;
            rootLazyRowKeys.push(key);
          }
          newTreeData[key] = newValue;
        });
        const lazyKeys = Object.keys(normalizedLazyNode_);
        if (lazy.value && lazyKeys.length && rootLazyRowKeys.length) {
          lazyKeys.forEach((key) => {
            var _a2;
            const oldValue = oldTreeData[key];
            const lazyNodeChildren = normalizedLazyNode_[key].children;
            if (rootLazyRowKeys.includes(key)) {
              if (((_a2 = newTreeData[key].children) == null ? void 0 : _a2.length) !== 0) {
                throw new Error("[ElTable]children must be an empty array.");
              }
              newTreeData[key].children = lazyNodeChildren;
            } else {
              const { loaded = false, loading = false } = oldValue || {};
              newTreeData[key] = {
                lazy: true,
                loaded: !!loaded,
                loading: !!loading,
                expanded: getExpanded(oldValue, key),
                children: lazyNodeChildren,
                level: void 0
              };
            }
          });
        }
      }
      treeData.value = newTreeData;
      (_b = instance.store) == null ? void 0 : _b.updateTableScrollY();
    };
    vue.watch(() => expandRowKeys.value, () => {
      updateTreeData(true);
    });
    vue.watch(() => normalizedData.value, () => {
      updateTreeData();
    });
    vue.watch(() => normalizedLazyNode.value, () => {
      updateTreeData();
    });
    const updateTreeExpandKeys = (value) => {
      expandRowKeys.value = value;
      updateTreeData();
    };
    const isUseLazy = (data) => {
      return lazy.value && data && "loaded" in data && !data.loaded;
    };
    const toggleTreeExpansion = (row, expanded) => {
      instance.store.assertRowKey();
      const rowKey = watcherData.rowKey.value;
      const id = getRowIdentity(row, rowKey);
      const data = id && treeData.value[id];
      if (id && data && "expanded" in data) {
        const oldExpanded = data.expanded;
        expanded = isUndefined(expanded) ? !data.expanded : expanded;
        treeData.value[id].expanded = expanded;
        if (oldExpanded !== expanded) {
          instance.emit("expand-change", row, expanded);
        }
        isUseLazy(data) && loadData(row, id, data);
        instance.store.updateTableScrollY();
      }
    };
    const loadOrToggle = (row) => {
      instance.store.assertRowKey();
      const rowKey = watcherData.rowKey.value;
      const id = getRowIdentity(row, rowKey);
      const data = treeData.value[id];
      if (isUseLazy(data)) {
        loadData(row, id, data);
      } else {
        toggleTreeExpansion(row, void 0);
      }
    };
    const loadData = (row, key, treeNode) => {
      const { load } = instance.props;
      if (load && !treeData.value[key].loaded) {
        treeData.value[key].loading = true;
        load(row, treeNode, (data) => {
          if (!isArray$1(data)) {
            throw new TypeError("[ElTable] data must be an array");
          }
          treeData.value[key].loading = false;
          treeData.value[key].loaded = true;
          treeData.value[key].expanded = true;
          if (data.length) {
            lazyTreeNodeMap.value[key] = data;
          }
          instance.emit("expand-change", row, true);
        });
      }
    };
    const updateKeyChildren = (key, data) => {
      const { lazy: lazy2, rowKey } = instance.props;
      if (!lazy2)
        return;
      if (!rowKey)
        throw new Error("[Table] rowKey is required in updateKeyChild");
      if (lazyTreeNodeMap.value[key]) {
        lazyTreeNodeMap.value[key] = data;
      }
    };
    return {
      loadData,
      loadOrToggle,
      toggleTreeExpansion,
      updateTreeExpandKeys,
      updateTreeData,
      updateKeyChildren,
      normalize,
      states: {
        expandRowKeys,
        treeData,
        indent,
        lazy,
        lazyTreeNodeMap,
        lazyColumnIdentifier,
        childrenColumnName,
        checkStrictly
      }
    };
  }

  const sortData = (data, states) => {
    const sortingColumn = states.sortingColumn;
    if (!sortingColumn || isString$1(sortingColumn.sortable)) {
      return data;
    }
    return orderBy(data, states.sortProp, states.sortOrder, sortingColumn.sortMethod, sortingColumn.sortBy);
  };
  const doFlattenColumns = (columns) => {
    const result = [];
    columns.forEach((column) => {
      if (column.children && column.children.length > 0) {
        result.push.apply(result, doFlattenColumns(column.children));
      } else {
        result.push(column);
      }
    });
    return result;
  };
  function useWatcher$1() {
    var _a;
    const instance = vue.getCurrentInstance();
    const { size: tableSize } = vue.toRefs((_a = instance.proxy) == null ? void 0 : _a.$props);
    const rowKey = vue.ref(null);
    const data = vue.ref([]);
    const _data = vue.ref([]);
    const isComplex = vue.ref(false);
    const _columns = vue.ref([]);
    const originColumns = vue.ref([]);
    const columns = vue.ref([]);
    const fixedColumns = vue.ref([]);
    const rightFixedColumns = vue.ref([]);
    const leafColumns = vue.ref([]);
    const fixedLeafColumns = vue.ref([]);
    const rightFixedLeafColumns = vue.ref([]);
    const updateOrderFns = [];
    const leafColumnsLength = vue.ref(0);
    const fixedLeafColumnsLength = vue.ref(0);
    const rightFixedLeafColumnsLength = vue.ref(0);
    const isAllSelected = vue.ref(false);
    const selection = vue.ref([]);
    const reserveSelection = vue.ref(false);
    const selectOnIndeterminate = vue.ref(false);
    const selectable = vue.ref(null);
    const filters = vue.ref({});
    const filteredData = vue.ref(null);
    const sortingColumn = vue.ref(null);
    const sortProp = vue.ref(null);
    const sortOrder = vue.ref(null);
    const hoverRow = vue.ref(null);
    const selectedMap = vue.computed(() => {
      return rowKey.value ? getKeysMap(selection.value, rowKey.value) : void 0;
    });
    vue.watch(data, () => {
      var _a2;
      if (instance.state) {
        scheduleLayout(false);
        const needUpdateFixed = instance.props.tableLayout === "auto";
        if (needUpdateFixed) {
          (_a2 = instance.refs.tableHeaderRef) == null ? void 0 : _a2.updateFixedColumnStyle();
        }
      }
    }, {
      deep: true
    });
    const assertRowKey = () => {
      if (!rowKey.value)
        throw new Error("[ElTable] prop row-key is required");
    };
    const updateChildFixed = (column) => {
      var _a2;
      (_a2 = column.children) == null ? void 0 : _a2.forEach((childColumn) => {
        childColumn.fixed = column.fixed;
        updateChildFixed(childColumn);
      });
    };
    const updateColumns = () => {
      _columns.value.forEach((column) => {
        updateChildFixed(column);
      });
      fixedColumns.value = _columns.value.filter((column) => [true, "left"].includes(column.fixed));
      const selectColumn = _columns.value.find((column) => column.type === "selection");
      let selectColFixLeft;
      if (selectColumn && selectColumn.fixed !== "right" && !fixedColumns.value.includes(selectColumn)) {
        const selectColumnIndex = _columns.value.indexOf(selectColumn);
        if (selectColumnIndex === 0 && fixedColumns.value.length) {
          fixedColumns.value.unshift(selectColumn);
          selectColFixLeft = true;
        }
      }
      rightFixedColumns.value = _columns.value.filter((column) => column.fixed === "right");
      const notFixedColumns = _columns.value.filter((column) => (selectColFixLeft ? column.type !== "selection" : true) && !column.fixed);
      originColumns.value = Array.from(fixedColumns.value).concat(notFixedColumns).concat(rightFixedColumns.value);
      const leafColumns2 = doFlattenColumns(notFixedColumns);
      const fixedLeafColumns2 = doFlattenColumns(fixedColumns.value);
      const rightFixedLeafColumns2 = doFlattenColumns(rightFixedColumns.value);
      leafColumnsLength.value = leafColumns2.length;
      fixedLeafColumnsLength.value = fixedLeafColumns2.length;
      rightFixedLeafColumnsLength.value = rightFixedLeafColumns2.length;
      columns.value = Array.from(fixedLeafColumns2).concat(leafColumns2).concat(rightFixedLeafColumns2);
      isComplex.value = fixedColumns.value.length > 0 || rightFixedColumns.value.length > 0;
    };
    const scheduleLayout = (needUpdateColumns, immediate = false) => {
      if (needUpdateColumns) {
        updateColumns();
      }
      if (immediate) {
        instance.state.doLayout();
      } else {
        instance.state.debouncedUpdateLayout();
      }
    };
    const isSelected = (row) => {
      if (selectedMap.value) {
        return !!selectedMap.value[getRowIdentity(row, rowKey.value)];
      } else {
        return selection.value.includes(row);
      }
    };
    const clearSelection = () => {
      isAllSelected.value = false;
      const oldSelection = selection.value;
      selection.value = [];
      if (oldSelection.length) {
        instance.emit("selection-change", []);
      }
    };
    const cleanSelection = () => {
      var _a2, _b;
      let deleted;
      if (rowKey.value) {
        deleted = [];
        const childrenKey = (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.childrenColumnName.value;
        const dataMap = getKeysMap(data.value, rowKey.value, true, childrenKey);
        for (const key in selectedMap.value) {
          if (hasOwn(selectedMap.value, key) && !dataMap[key]) {
            deleted.push(selectedMap.value[key].row);
          }
        }
      } else {
        deleted = selection.value.filter((item) => !data.value.includes(item));
      }
      if (deleted.length) {
        const newSelection = selection.value.filter((item) => !deleted.includes(item));
        selection.value = newSelection;
        instance.emit("selection-change", newSelection.slice());
      }
    };
    const getSelectionRows = () => {
      return (selection.value || []).slice();
    };
    const toggleRowSelection = (row, selected, emitChange = true, ignoreSelectable = false) => {
      var _a2, _b, _c, _d;
      const treeProps = {
        children: (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.childrenColumnName.value,
        checkStrictly: (_d = (_c = instance == null ? void 0 : instance.store) == null ? void 0 : _c.states) == null ? void 0 : _d.checkStrictly.value
      };
      const changed = toggleRowStatus(selection.value, row, selected, treeProps, ignoreSelectable ? void 0 : selectable.value, data.value.indexOf(row), rowKey.value);
      if (changed) {
        const newSelection = (selection.value || []).slice();
        if (emitChange) {
          instance.emit("select", newSelection, row);
        }
        instance.emit("selection-change", newSelection);
      }
    };
    const _toggleAllSelection = () => {
      var _a2, _b;
      const value = selectOnIndeterminate.value ? !isAllSelected.value : !(isAllSelected.value || selection.value.length);
      isAllSelected.value = value;
      let selectionChanged = false;
      let childrenCount = 0;
      const rowKey2 = (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.rowKey.value;
      const { childrenColumnName } = instance.store.states;
      const treeProps = {
        children: childrenColumnName.value,
        checkStrictly: false
      };
      data.value.forEach((row, index) => {
        const rowIndex = index + childrenCount;
        if (toggleRowStatus(selection.value, row, value, treeProps, selectable.value, rowIndex, rowKey2)) {
          selectionChanged = true;
        }
        childrenCount += getChildrenCount(getRowIdentity(row, rowKey2));
      });
      if (selectionChanged) {
        instance.emit("selection-change", selection.value ? selection.value.slice() : []);
      }
      instance.emit("select-all", (selection.value || []).slice());
    };
    const updateAllSelected = () => {
      var _a2;
      if (((_a2 = data.value) == null ? void 0 : _a2.length) === 0) {
        isAllSelected.value = false;
        return;
      }
      const { childrenColumnName } = instance.store.states;
      let rowIndex = 0;
      let selectedCount = 0;
      const checkSelectedStatus = (data2) => {
        var _a3;
        for (const row of data2) {
          const isRowSelectable = selectable.value && selectable.value.call(null, row, rowIndex);
          if (!isSelected(row)) {
            if (!selectable.value || isRowSelectable) {
              return false;
            }
          } else {
            selectedCount++;
          }
          rowIndex++;
          if (((_a3 = row[childrenColumnName.value]) == null ? void 0 : _a3.length) && !checkSelectedStatus(row[childrenColumnName.value])) {
            return false;
          }
        }
        return true;
      };
      const isAllSelected_ = checkSelectedStatus(data.value || []);
      isAllSelected.value = selectedCount === 0 ? false : isAllSelected_;
    };
    const getChildrenCount = (rowKey2) => {
      var _a2;
      if (!instance || !instance.store)
        return 0;
      const { treeData } = instance.store.states;
      let count = 0;
      const children = (_a2 = treeData.value[rowKey2]) == null ? void 0 : _a2.children;
      if (children) {
        count += children.length;
        children.forEach((childKey) => {
          count += getChildrenCount(childKey);
        });
      }
      return count;
    };
    const updateFilters = (column, values) => {
      const filters_ = {};
      castArray$1(column).forEach((col) => {
        filters.value[col.id] = values;
        filters_[col.columnKey || col.id] = values;
      });
      return filters_;
    };
    const updateSort = (column, prop, order) => {
      if (sortingColumn.value && sortingColumn.value !== column) {
        sortingColumn.value.order = null;
      }
      sortingColumn.value = column;
      sortProp.value = prop;
      sortOrder.value = order;
    };
    const execFilter = () => {
      let sourceData = vue.unref(_data);
      Object.keys(filters.value).forEach((columnId) => {
        const values = filters.value[columnId];
        if (!values || values.length === 0)
          return;
        const column = getColumnById({
          columns: columns.value
        }, columnId);
        if (column && column.filterMethod) {
          sourceData = sourceData.filter((row) => {
            return values.some((value) => column.filterMethod.call(null, value, row, column));
          });
        }
      });
      filteredData.value = sourceData;
    };
    const execSort = () => {
      var _a2;
      data.value = sortData((_a2 = filteredData.value) != null ? _a2 : [], {
        sortingColumn: sortingColumn.value,
        sortProp: sortProp.value,
        sortOrder: sortOrder.value
      });
    };
    const execQuery = (ignore = void 0) => {
      if (!(ignore == null ? void 0 : ignore.filter)) {
        execFilter();
      }
      execSort();
    };
    const clearFilter = (columnKeys) => {
      const { tableHeaderRef } = instance.refs;
      if (!tableHeaderRef)
        return;
      const panels = Object.assign({}, tableHeaderRef.filterPanels);
      const keys = Object.keys(panels);
      if (!keys.length)
        return;
      if (isString$1(columnKeys)) {
        columnKeys = [columnKeys];
      }
      if (isArray$1(columnKeys)) {
        const columns_ = columnKeys.map((key) => getColumnByKey({
          columns: columns.value
        }, key));
        keys.forEach((key) => {
          const column = columns_.find((col) => col.id === key);
          if (column) {
            column.filteredValue = [];
          }
        });
        instance.store.commit("filterChange", {
          column: columns_,
          values: [],
          silent: true,
          multi: true
        });
      } else {
        keys.forEach((key) => {
          const column = columns.value.find((col) => col.id === key);
          if (column) {
            column.filteredValue = [];
          }
        });
        filters.value = {};
        instance.store.commit("filterChange", {
          column: {},
          values: [],
          silent: true
        });
      }
    };
    const clearSort = () => {
      if (!sortingColumn.value)
        return;
      updateSort(null, null, null);
      instance.store.commit("changeSortCondition", {
        silent: true
      });
    };
    const {
      setExpandRowKeys,
      toggleRowExpansion,
      updateExpandRows,
      states: expandStates,
      isRowExpanded
    } = useExpand({
      data,
      rowKey
    });
    const {
      updateTreeExpandKeys,
      toggleTreeExpansion,
      updateTreeData,
      updateKeyChildren,
      loadOrToggle,
      states: treeStates
    } = useTree$2({
      data,
      rowKey
    });
    const {
      updateCurrentRowData,
      updateCurrentRow,
      setCurrentRowKey,
      states: currentData
    } = useCurrent({
      data,
      rowKey
    });
    const setExpandRowKeysAdapter = (val) => {
      setExpandRowKeys(val);
      updateTreeExpandKeys(val);
    };
    const toggleRowExpansionAdapter = (row, expanded) => {
      const hasExpandColumn = columns.value.some(({ type }) => type === "expand");
      if (hasExpandColumn) {
        toggleRowExpansion(row, expanded);
      } else {
        toggleTreeExpansion(row, expanded);
      }
    };
    return {
      assertRowKey,
      updateColumns,
      scheduleLayout,
      isSelected,
      clearSelection,
      cleanSelection,
      getSelectionRows,
      toggleRowSelection,
      _toggleAllSelection,
      toggleAllSelection: null,
      updateAllSelected,
      updateFilters,
      updateCurrentRow,
      updateSort,
      execFilter,
      execSort,
      execQuery,
      clearFilter,
      clearSort,
      toggleRowExpansion,
      setExpandRowKeysAdapter,
      setCurrentRowKey,
      toggleRowExpansionAdapter,
      isRowExpanded,
      updateExpandRows,
      updateCurrentRowData,
      loadOrToggle,
      updateTreeData,
      updateKeyChildren,
      states: {
        tableSize,
        rowKey,
        data,
        _data,
        isComplex,
        _columns,
        originColumns,
        columns,
        fixedColumns,
        rightFixedColumns,
        leafColumns,
        fixedLeafColumns,
        rightFixedLeafColumns,
        updateOrderFns,
        leafColumnsLength,
        fixedLeafColumnsLength,
        rightFixedLeafColumnsLength,
        isAllSelected,
        selection,
        reserveSelection,
        selectOnIndeterminate,
        selectable,
        filters,
        filteredData,
        sortingColumn,
        sortProp,
        sortOrder,
        hoverRow,
        ...expandStates,
        ...treeStates,
        ...currentData
      }
    };
  }

  function replaceColumn(array, column) {
    return array.map((item) => {
      var _a;
      if (item.id === column.id) {
        return column;
      } else if ((_a = item.children) == null ? void 0 : _a.length) {
        item.children = replaceColumn(item.children, column);
      }
      return item;
    });
  }
  function sortColumn(array) {
    array.forEach((item) => {
      var _a, _b;
      item.no = (_a = item.getColumnIndex) == null ? void 0 : _a.call(item);
      if ((_b = item.children) == null ? void 0 : _b.length) {
        sortColumn(item.children);
      }
    });
    array.sort((cur, pre) => cur.no - pre.no);
  }
  function useStore() {
    const instance = vue.getCurrentInstance();
    const watcher = useWatcher$1();
    const ns = useNamespace("table");
    const mutations = {
      setData(states, data) {
        const dataInstanceChanged = vue.unref(states._data) !== data;
        states.data.value = data;
        states._data.value = data;
        instance.store.execQuery();
        instance.store.updateCurrentRowData();
        instance.store.updateExpandRows();
        instance.store.updateTreeData(instance.store.states.defaultExpandAll.value);
        if (vue.unref(states.reserveSelection)) {
          instance.store.assertRowKey();
        } else {
          if (dataInstanceChanged) {
            instance.store.clearSelection();
          } else {
            instance.store.cleanSelection();
          }
        }
        instance.store.updateAllSelected();
        if (instance.$ready) {
          instance.store.scheduleLayout();
        }
      },
      insertColumn(states, column, parent, updateColumnOrder) {
        var _a;
        const array = vue.unref(states._columns);
        let newColumns = [];
        if (!parent) {
          array.push(column);
          newColumns = array;
        } else {
          if (parent && !parent.children) {
            parent.children = [];
          }
          (_a = parent.children) == null ? void 0 : _a.push(column);
          newColumns = replaceColumn(array, parent);
        }
        sortColumn(newColumns);
        states._columns.value = newColumns;
        states.updateOrderFns.push(updateColumnOrder);
        if (column.type === "selection") {
          states.selectable.value = column.selectable;
          states.reserveSelection.value = column.reserveSelection;
        }
        if (instance.$ready) {
          instance.store.updateColumns();
          instance.store.scheduleLayout();
        }
      },
      updateColumnOrder(states, column) {
        var _a;
        const newColumnIndex = (_a = column.getColumnIndex) == null ? void 0 : _a.call(column);
        if (newColumnIndex === column.no)
          return;
        sortColumn(states._columns.value);
        if (instance.$ready) {
          instance.store.updateColumns();
        }
      },
      removeColumn(states, column, parent, updateColumnOrder) {
        var _a;
        const array = vue.unref(states._columns) || [];
        if (parent) {
          (_a = parent.children) == null ? void 0 : _a.splice(parent.children.findIndex((item) => item.id === column.id), 1);
          vue.nextTick(() => {
            var _a2;
            if (((_a2 = parent.children) == null ? void 0 : _a2.length) === 0) {
              delete parent.children;
            }
          });
          states._columns.value = replaceColumn(array, parent);
        } else {
          const index = array.indexOf(column);
          if (index > -1) {
            array.splice(index, 1);
            states._columns.value = array;
          }
        }
        const updateFnIndex = states.updateOrderFns.indexOf(updateColumnOrder);
        updateFnIndex > -1 && states.updateOrderFns.splice(updateFnIndex, 1);
        if (instance.$ready) {
          instance.store.updateColumns();
          instance.store.scheduleLayout();
        }
      },
      sort(states, options) {
        const { prop, order, init } = options;
        if (prop) {
          const column = vue.unref(states.columns).find((column2) => column2.property === prop);
          if (column) {
            column.order = order;
            instance.store.updateSort(column, prop, order);
            instance.store.commit("changeSortCondition", { init });
          }
        }
      },
      changeSortCondition(states, options) {
        const { sortingColumn, sortProp, sortOrder } = states;
        const columnValue = vue.unref(sortingColumn), propValue = vue.unref(sortProp), orderValue = vue.unref(sortOrder);
        if (isNull(orderValue)) {
          states.sortingColumn.value = null;
          states.sortProp.value = null;
        }
        const ignore = { filter: true };
        instance.store.execQuery(ignore);
        if (!options || !(options.silent || options.init)) {
          instance.emit("sort-change", {
            column: columnValue,
            prop: propValue,
            order: orderValue
          });
        }
        instance.store.updateTableScrollY();
      },
      filterChange(_states, options) {
        const { column, values, silent } = options;
        const newFilters = instance.store.updateFilters(column, values);
        instance.store.execQuery();
        if (!silent) {
          instance.emit("filter-change", newFilters);
        }
        instance.store.updateTableScrollY();
      },
      toggleAllSelection() {
        var _a, _b;
        (_b = (_a = instance.store).toggleAllSelection) == null ? void 0 : _b.call(_a);
      },
      rowSelectedChanged(_states, row) {
        instance.store.toggleRowSelection(row);
        instance.store.updateAllSelected();
      },
      setHoverRow(states, row) {
        states.hoverRow.value = row;
      },
      setCurrentRow(_states, row) {
        instance.store.updateCurrentRow(row);
      }
    };
    const commit = function(name, ...args) {
      const mutations2 = instance.store.mutations;
      if (mutations2[name]) {
        mutations2[name].apply(instance, [
          instance.store.states,
          ...args
        ]);
      } else {
        throw new Error(`Action not found: ${name}`);
      }
    };
    const updateTableScrollY = function() {
      vue.nextTick(() => instance.layout.updateScrollY.apply(instance.layout));
    };
    return {
      ns,
      ...watcher,
      mutations,
      commit,
      updateTableScrollY
    };
  }

  const InitialStateMap = {
    rowKey: "rowKey",
    defaultExpandAll: "defaultExpandAll",
    selectOnIndeterminate: "selectOnIndeterminate",
    indent: "indent",
    lazy: "lazy",
    data: "data",
    ["treeProps.hasChildren"]: {
      key: "lazyColumnIdentifier",
      default: "hasChildren"
    },
    ["treeProps.children"]: {
      key: "childrenColumnName",
      default: "children"
    },
    ["treeProps.checkStrictly"]: {
      key: "checkStrictly",
      default: false
    }
  };
  function createStore(table, props) {
    if (!table) {
      throw new Error("Table is required.");
    }
    const store = useStore();
    store.toggleAllSelection = debounce(store._toggleAllSelection, 10);
    Object.keys(InitialStateMap).forEach((key) => {
      handleValue(getArrKeysValue(props, key), key, store);
    });
    proxyTableProps(store, props);
    return store;
  }
  function proxyTableProps(store, props) {
    Object.keys(InitialStateMap).forEach((key) => {
      vue.watch(() => getArrKeysValue(props, key), (value) => {
        handleValue(value, key, store);
      });
    });
  }
  function handleValue(value, propsKey, store) {
    let newVal = value;
    let storeKey = InitialStateMap[propsKey];
    if (isObject$1(storeKey)) {
      newVal = newVal || storeKey.default;
      storeKey = storeKey.key;
    }
    store.states[storeKey].value = newVal;
  }
  function getArrKeysValue(props, key) {
    if (key.includes(".")) {
      const keyList = key.split(".");
      let value = props;
      keyList.forEach((k) => {
        value = value[k];
      });
      return value;
    } else {
      return props[key];
    }
  }

  class TableLayout {
    constructor(options) {
      this.observers = [];
      this.table = null;
      this.store = null;
      this.columns = [];
      this.fit = true;
      this.showHeader = true;
      this.height = vue.ref(null);
      this.scrollX = vue.ref(false);
      this.scrollY = vue.ref(false);
      this.bodyWidth = vue.ref(null);
      this.fixedWidth = vue.ref(null);
      this.rightFixedWidth = vue.ref(null);
      this.gutterWidth = 0;
      for (const name in options) {
        if (hasOwn(options, name)) {
          if (vue.isRef(this[name])) {
            this[name].value = options[name];
          } else {
            this[name] = options[name];
          }
        }
      }
      if (!this.table) {
        throw new Error("Table is required for Table Layout");
      }
      if (!this.store) {
        throw new Error("Store is required for Table Layout");
      }
    }
    updateScrollY() {
      const height = this.height.value;
      if (isNull(height))
        return false;
      const scrollBarRef = this.table.refs.scrollBarRef;
      if (this.table.vnode.el && (scrollBarRef == null ? void 0 : scrollBarRef.wrapRef)) {
        let scrollY = true;
        const prevScrollY = this.scrollY.value;
        scrollY = scrollBarRef.wrapRef.scrollHeight > scrollBarRef.wrapRef.clientHeight;
        this.scrollY.value = scrollY;
        return prevScrollY !== scrollY;
      }
      return false;
    }
    setHeight(value, prop = "height") {
      if (!isClient)
        return;
      const el = this.table.vnode.el;
      value = parseHeight(value);
      this.height.value = Number(value);
      if (!el && (value || value === 0)) {
        vue.nextTick(() => this.setHeight(value, prop));
        return;
      }
      if (el && isNumber(value)) {
        el.style[prop] = `${value}px`;
        this.updateElsHeight();
      } else if (el && isString$1(value)) {
        el.style[prop] = value;
        this.updateElsHeight();
      }
    }
    setMaxHeight(value) {
      this.setHeight(value, "max-height");
    }
    getFlattenColumns() {
      const flattenColumns = [];
      const columns = this.table.store.states.columns.value;
      columns.forEach((column) => {
        if (column.isColumnGroup) {
          flattenColumns.push.apply(flattenColumns, column.columns);
        } else {
          flattenColumns.push(column);
        }
      });
      return flattenColumns;
    }
    updateElsHeight() {
      this.updateScrollY();
      this.notifyObservers("scrollable");
    }
    headerDisplayNone(elm) {
      if (!elm)
        return true;
      let headerChild = elm;
      while (headerChild.tagName !== "DIV") {
        if (getComputedStyle(headerChild).display === "none") {
          return true;
        }
        headerChild = headerChild.parentElement;
      }
      return false;
    }
    updateColumnsWidth() {
      var _a;
      if (!isClient)
        return;
      const fit = this.fit;
      const bodyWidth = (_a = this.table.vnode.el) == null ? void 0 : _a.clientWidth;
      let bodyMinWidth = 0;
      const flattenColumns = this.getFlattenColumns();
      const flexColumns = flattenColumns.filter((column) => !isNumber(column.width));
      flattenColumns.forEach((column) => {
        if (isNumber(column.width) && column.realWidth)
          column.realWidth = null;
      });
      if (flexColumns.length > 0 && fit) {
        flattenColumns.forEach((column) => {
          bodyMinWidth += Number(column.width || column.minWidth || 80);
        });
        if (bodyMinWidth <= bodyWidth) {
          this.scrollX.value = false;
          const totalFlexWidth = bodyWidth - bodyMinWidth;
          if (flexColumns.length === 1) {
            flexColumns[0].realWidth = Number(flexColumns[0].minWidth || 80) + totalFlexWidth;
          } else {
            const allColumnsWidth = flexColumns.reduce((prev, column) => prev + Number(column.minWidth || 80), 0);
            const flexWidthPerPixel = totalFlexWidth / allColumnsWidth;
            let noneFirstWidth = 0;
            flexColumns.forEach((column, index) => {
              if (index === 0)
                return;
              const flexWidth = Math.floor(Number(column.minWidth || 80) * flexWidthPerPixel);
              noneFirstWidth += flexWidth;
              column.realWidth = Number(column.minWidth || 80) + flexWidth;
            });
            flexColumns[0].realWidth = Number(flexColumns[0].minWidth || 80) + totalFlexWidth - noneFirstWidth;
          }
        } else {
          this.scrollX.value = true;
          flexColumns.forEach((column) => {
            column.realWidth = Number(column.minWidth);
          });
        }
        this.bodyWidth.value = Math.max(bodyMinWidth, bodyWidth);
        this.table.state.resizeState.value.width = this.bodyWidth.value;
      } else {
        flattenColumns.forEach((column) => {
          if (!column.width && !column.minWidth) {
            column.realWidth = 80;
          } else {
            column.realWidth = Number(column.width || column.minWidth);
          }
          bodyMinWidth += column.realWidth;
        });
        this.scrollX.value = bodyMinWidth > bodyWidth;
        this.bodyWidth.value = bodyMinWidth;
      }
      const fixedColumns = this.store.states.fixedColumns.value;
      if (fixedColumns.length > 0) {
        let fixedWidth = 0;
        fixedColumns.forEach((column) => {
          fixedWidth += Number(column.realWidth || column.width);
        });
        this.fixedWidth.value = fixedWidth;
      }
      const rightFixedColumns = this.store.states.rightFixedColumns.value;
      if (rightFixedColumns.length > 0) {
        let rightFixedWidth = 0;
        rightFixedColumns.forEach((column) => {
          rightFixedWidth += Number(column.realWidth || column.width);
        });
        this.rightFixedWidth.value = rightFixedWidth;
      }
      this.notifyObservers("columns");
    }
    addObserver(observer) {
      this.observers.push(observer);
    }
    removeObserver(observer) {
      const index = this.observers.indexOf(observer);
      if (index !== -1) {
        this.observers.splice(index, 1);
      }
    }
    notifyObservers(event) {
      const observers = this.observers;
      observers.forEach((observer) => {
        var _a, _b;
        switch (event) {
          case "columns":
            (_a = observer.state) == null ? void 0 : _a.onColumnsChange(this);
            break;
          case "scrollable":
            (_b = observer.state) == null ? void 0 : _b.onScrollableChange(this);
            break;
          default:
            throw new Error(`Table Layout don't have event ${event}.`);
        }
      });
    }
  }
  var TableLayout$1 = TableLayout;

  const { CheckboxGroup: ElCheckboxGroup } = ElCheckbox;
  const _sfc_main$z = vue.defineComponent({
    name: "ElTableFilterPanel",
    components: {
      ElCheckbox,
      ElCheckboxGroup,
      ElScrollbar,
      ElTooltip,
      ElIcon,
      ArrowDown: arrow_down_default,
      ArrowUp: arrow_up_default
    },
    directives: { ClickOutside },
    props: {
      placement: {
        type: String,
        default: "bottom-start"
      },
      store: {
        type: Object
      },
      column: {
        type: Object
      },
      upDataColumn: {
        type: Function
      },
      appendTo: useTooltipContentProps.appendTo
    },
    setup(props) {
      const instance = vue.getCurrentInstance();
      const { t } = useLocale();
      const ns = useNamespace("table-filter");
      const parent = instance == null ? void 0 : instance.parent;
      if (props.column && !parent.filterPanels.value[props.column.id]) {
        parent.filterPanels.value[props.column.id] = instance;
      }
      const tooltipVisible = vue.ref(false);
      const tooltip = vue.ref(null);
      const filters = vue.computed(() => {
        return props.column && props.column.filters;
      });
      const filterClassName = vue.computed(() => {
        if (props.column && props.column.filterClassName) {
          return `${ns.b()} ${props.column.filterClassName}`;
        }
        return ns.b();
      });
      const filterValue = vue.computed({
        get: () => {
          var _a;
          return (((_a = props.column) == null ? void 0 : _a.filteredValue) || [])[0];
        },
        set: (value) => {
          if (filteredValue.value) {
            if (!isPropAbsent(value)) {
              filteredValue.value.splice(0, 1, value);
            } else {
              filteredValue.value.splice(0, 1);
            }
          }
        }
      });
      const filteredValue = vue.computed({
        get() {
          if (props.column) {
            return props.column.filteredValue || [];
          }
          return [];
        },
        set(value) {
          var _a;
          if (props.column) {
            (_a = props.upDataColumn) == null ? void 0 : _a.call(props, "filteredValue", value);
          }
        }
      });
      const multiple = vue.computed(() => {
        if (props.column) {
          return props.column.filterMultiple;
        }
        return true;
      });
      const isActive = (filter) => {
        return filter.value === filterValue.value;
      };
      const hidden = () => {
        tooltipVisible.value = false;
      };
      const showFilterPanel = (e) => {
        e.stopPropagation();
        tooltipVisible.value = !tooltipVisible.value;
      };
      const hideFilterPanel = () => {
        tooltipVisible.value = false;
      };
      const handleConfirm = () => {
        confirmFilter(filteredValue.value);
        hidden();
      };
      const handleReset = () => {
        filteredValue.value = [];
        confirmFilter(filteredValue.value);
        hidden();
      };
      const handleSelect = (_filterValue) => {
        filterValue.value = _filterValue;
        if (!isPropAbsent(_filterValue)) {
          confirmFilter(filteredValue.value);
        } else {
          confirmFilter([]);
        }
        hidden();
      };
      const confirmFilter = (filteredValue2) => {
        var _a, _b;
        (_a = props.store) == null ? void 0 : _a.commit("filterChange", {
          column: props.column,
          values: filteredValue2
        });
        (_b = props.store) == null ? void 0 : _b.updateAllSelected();
      };
      vue.watch(tooltipVisible, (value) => {
        var _a;
        if (props.column) {
          (_a = props.upDataColumn) == null ? void 0 : _a.call(props, "filterOpened", value);
        }
      }, {
        immediate: true
      });
      const popperPaneRef = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = tooltip.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
      });
      return {
        tooltipVisible,
        multiple,
        filterClassName,
        filteredValue,
        filterValue,
        filters,
        handleConfirm,
        handleReset,
        handleSelect,
        isPropAbsent,
        isActive,
        t,
        ns,
        showFilterPanel,
        hideFilterPanel,
        popperPaneRef,
        tooltip
      };
    }
  });
  function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_checkbox = vue.resolveComponent("el-checkbox");
    const _component_el_checkbox_group = vue.resolveComponent("el-checkbox-group");
    const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
    const _component_arrow_up = vue.resolveComponent("arrow-up");
    const _component_arrow_down = vue.resolveComponent("arrow-down");
    const _component_el_icon = vue.resolveComponent("el-icon");
    const _component_el_tooltip = vue.resolveComponent("el-tooltip");
    const _directive_click_outside = vue.resolveDirective("click-outside");
    return vue.openBlock(), vue.createBlock(_component_el_tooltip, {
      ref: "tooltip",
      visible: _ctx.tooltipVisible,
      offset: 0,
      placement: _ctx.placement,
      "show-arrow": false,
      "stop-popper-mouse-event": false,
      teleported: "",
      effect: "light",
      pure: "",
      "popper-class": _ctx.filterClassName,
      persistent: "",
      "append-to": _ctx.appendTo
    }, {
      content: vue.withCtx(() => [
        _ctx.multiple ? (vue.openBlock(), vue.createElementBlock("div", { key: 0 }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(_ctx.ns.e("content"))
          }, [
            vue.createVNode(_component_el_scrollbar, {
              "wrap-class": _ctx.ns.e("wrap")
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(_component_el_checkbox_group, {
                  modelValue: _ctx.filteredValue,
                  "onUpdate:modelValue": ($event) => _ctx.filteredValue = $event,
                  class: vue.normalizeClass(_ctx.ns.e("checkbox-group"))
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.filters, (filter) => {
                      return vue.openBlock(), vue.createBlock(_component_el_checkbox, {
                        key: filter.value,
                        value: filter.value
                      }, {
                        default: vue.withCtx(() => [
                          vue.createTextVNode(vue.toDisplayString(filter.text), 1)
                        ]),
                        _: 2
                      }, 1032, ["value"]);
                    }), 128))
                  ]),
                  _: 1
                }, 8, ["modelValue", "onUpdate:modelValue", "class"])
              ]),
              _: 1
            }, 8, ["wrap-class"])
          ], 2),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(_ctx.ns.e("bottom"))
          }, [
            vue.createElementVNode("button", {
              class: vue.normalizeClass(_ctx.ns.is("disabled", _ctx.filteredValue.length === 0)),
              disabled: _ctx.filteredValue.length === 0,
              type: "button",
              onClick: _ctx.handleConfirm
            }, vue.toDisplayString(_ctx.t("el.table.confirmFilter")), 11, ["disabled", "onClick"]),
            vue.createElementVNode("button", {
              type: "button",
              onClick: _ctx.handleReset
            }, vue.toDisplayString(_ctx.t("el.table.resetFilter")), 9, ["onClick"])
          ], 2)
        ])) : (vue.openBlock(), vue.createElementBlock("ul", {
          key: 1,
          class: vue.normalizeClass(_ctx.ns.e("list"))
        }, [
          vue.createElementVNode("li", {
            class: vue.normalizeClass([
              _ctx.ns.e("list-item"),
              _ctx.ns.is("active", _ctx.isPropAbsent(_ctx.filterValue))
            ]),
            onClick: ($event) => _ctx.handleSelect(null)
          }, vue.toDisplayString(_ctx.t("el.table.clearFilter")), 11, ["onClick"]),
          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.filters, (filter) => {
            return vue.openBlock(), vue.createElementBlock("li", {
              key: filter.value,
              class: vue.normalizeClass([_ctx.ns.e("list-item"), _ctx.ns.is("active", _ctx.isActive(filter))]),
              label: filter.value,
              onClick: ($event) => _ctx.handleSelect(filter.value)
            }, vue.toDisplayString(filter.text), 11, ["label", "onClick"]);
          }), 128))
        ], 2))
      ]),
      default: vue.withCtx(() => [
        vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
          class: vue.normalizeClass([
            `${_ctx.ns.namespace.value}-table__column-filter-trigger`,
            `${_ctx.ns.namespace.value}-none-outline`
          ]),
          onClick: _ctx.showFilterPanel
        }, [
          vue.createVNode(_component_el_icon, null, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "filter-icon", {}, () => {
                var _a;
                return [
                  ((_a = _ctx.column) == null ? void 0 : _a.filterOpened) ? (vue.openBlock(), vue.createBlock(_component_arrow_up, { key: 0 })) : (vue.openBlock(), vue.createBlock(_component_arrow_down, { key: 1 }))
                ];
              })
            ]),
            _: 3
          })
        ], 10, ["onClick"])), [
          [_directive_click_outside, _ctx.hideFilterPanel, _ctx.popperPaneRef]
        ])
      ]),
      _: 3
    }, 8, ["visible", "placement", "popper-class", "append-to"]);
  }
  var FilterPanel = /* @__PURE__ */ _export_sfc(_sfc_main$z, [["render", _sfc_render$4], ["__file", "filter-panel.vue"]]);

  function useLayoutObserver(root) {
    const instance = vue.getCurrentInstance();
    vue.onBeforeMount(() => {
      tableLayout.value.addObserver(instance);
    });
    vue.onMounted(() => {
      onColumnsChange(tableLayout.value);
      onScrollableChange(tableLayout.value);
    });
    vue.onUpdated(() => {
      onColumnsChange(tableLayout.value);
      onScrollableChange(tableLayout.value);
    });
    vue.onUnmounted(() => {
      tableLayout.value.removeObserver(instance);
    });
    const tableLayout = vue.computed(() => {
      const layout = root.layout;
      if (!layout) {
        throw new Error("Can not find table layout.");
      }
      return layout;
    });
    const onColumnsChange = (layout) => {
      var _a;
      const cols = ((_a = root.vnode.el) == null ? void 0 : _a.querySelectorAll("colgroup > col")) || [];
      if (!cols.length)
        return;
      const flattenColumns = layout.getFlattenColumns();
      const columnsMap = {};
      flattenColumns.forEach((column) => {
        columnsMap[column.id] = column;
      });
      for (let i = 0, j = cols.length; i < j; i++) {
        const col = cols[i];
        const name = col.getAttribute("name");
        const column = columnsMap[name];
        if (column) {
          col.setAttribute("width", column.realWidth || column.width);
        }
      }
    };
    const onScrollableChange = (layout) => {
      var _a, _b;
      const cols = ((_a = root.vnode.el) == null ? void 0 : _a.querySelectorAll("colgroup > col[name=gutter]")) || [];
      for (let i = 0, j = cols.length; i < j; i++) {
        const col = cols[i];
        col.setAttribute("width", layout.scrollY.value ? layout.gutterWidth : "0");
      }
      const ths = ((_b = root.vnode.el) == null ? void 0 : _b.querySelectorAll("th.gutter")) || [];
      for (let i = 0, j = ths.length; i < j; i++) {
        const th = ths[i];
        th.style.width = layout.scrollY.value ? `${layout.gutterWidth}px` : "0";
        th.style.display = layout.scrollY.value ? "" : "none";
      }
    };
    return {
      tableLayout: tableLayout.value,
      onColumnsChange,
      onScrollableChange
    };
  }

  const TABLE_INJECTION_KEY = Symbol("ElTable");

  function useEvent(props, emit) {
    const instance = vue.getCurrentInstance();
    const parent = vue.inject(TABLE_INJECTION_KEY);
    const handleFilterClick = (event) => {
      event.stopPropagation();
      return;
    };
    const handleHeaderClick = (event, column) => {
      if (!column.filters && column.sortable) {
        handleSortClick(event, column, false);
      } else if (column.filterable && !column.sortable) {
        handleFilterClick(event);
      }
      parent == null ? void 0 : parent.emit("header-click", column, event);
    };
    const handleHeaderContextMenu = (event, column) => {
      parent == null ? void 0 : parent.emit("header-contextmenu", column, event);
    };
    const draggingColumn = vue.ref(null);
    const dragging = vue.ref(false);
    const dragState = vue.ref();
    const handleMouseDown = (event, column) => {
      var _a, _b;
      if (!isClient)
        return;
      if (column.children && column.children.length > 0)
        return;
      if (draggingColumn.value && props.border) {
        dragging.value = true;
        const table = parent;
        emit("set-drag-visible", true);
        const tableEl = table == null ? void 0 : table.vnode.el;
        const tableLeft = tableEl == null ? void 0 : tableEl.getBoundingClientRect().left;
        const columnEl = (_b = (_a = instance == null ? void 0 : instance.vnode) == null ? void 0 : _a.el) == null ? void 0 : _b.querySelector(`th.${column.id}`);
        const columnRect = columnEl.getBoundingClientRect();
        const minLeft = columnRect.left - tableLeft + 30;
        addClass(columnEl, "noclick");
        dragState.value = {
          startMouseLeft: event.clientX,
          startLeft: columnRect.right - tableLeft,
          startColumnLeft: columnRect.left - tableLeft,
          tableLeft
        };
        const resizeProxy = table == null ? void 0 : table.refs.resizeProxy;
        resizeProxy.style.left = `${dragState.value.startLeft}px`;
        document.onselectstart = function() {
          return false;
        };
        document.ondragstart = function() {
          return false;
        };
        const handleMouseMove2 = (event2) => {
          const deltaLeft = event2.clientX - dragState.value.startMouseLeft;
          const proxyLeft = dragState.value.startLeft + deltaLeft;
          resizeProxy.style.left = `${Math.max(minLeft, proxyLeft)}px`;
        };
        const handleMouseUp = () => {
          if (dragging.value) {
            const { startColumnLeft, startLeft } = dragState.value;
            const finalLeft = Number.parseInt(resizeProxy.style.left, 10);
            const columnWidth = finalLeft - startColumnLeft;
            column.width = column.realWidth = columnWidth;
            table == null ? void 0 : table.emit("header-dragend", column.width, startLeft - startColumnLeft, column, event);
            requestAnimationFrame(() => {
              props.store.scheduleLayout(false, true);
            });
            document.body.style.cursor = "";
            dragging.value = false;
            draggingColumn.value = null;
            dragState.value = void 0;
            emit("set-drag-visible", false);
          }
          document.removeEventListener("mousemove", handleMouseMove2);
          document.removeEventListener("mouseup", handleMouseUp);
          document.onselectstart = null;
          document.ondragstart = null;
          setTimeout(() => {
            removeClass(columnEl, "noclick");
          }, 0);
        };
        document.addEventListener("mousemove", handleMouseMove2);
        document.addEventListener("mouseup", handleMouseUp);
      }
    };
    const handleMouseMove = (event, column) => {
      var _a;
      if (column.children && column.children.length > 0)
        return;
      const el = event.target;
      if (!isElement$2(el)) {
        return;
      }
      const target = el == null ? void 0 : el.closest("th");
      if (!column || !column.resizable || !target)
        return;
      if (!dragging.value && props.border) {
        const rect = target.getBoundingClientRect();
        const bodyStyle = document.body.style;
        const isLastTh = ((_a = target.parentNode) == null ? void 0 : _a.lastElementChild) === target;
        const allowDarg = props.allowDragLastColumn || !isLastTh;
        if (rect.width > 12 && rect.right - event.clientX < 8 && allowDarg) {
          bodyStyle.cursor = "col-resize";
          if (hasClass(target, "is-sortable")) {
            target.style.cursor = "col-resize";
          }
          draggingColumn.value = column;
        } else if (!dragging.value) {
          bodyStyle.cursor = "";
          if (hasClass(target, "is-sortable")) {
            target.style.cursor = "pointer";
          }
          draggingColumn.value = null;
        }
      }
    };
    const handleMouseOut = () => {
      if (!isClient)
        return;
      document.body.style.cursor = "";
    };
    const toggleOrder = ({ order, sortOrders }) => {
      if (order === "")
        return sortOrders[0];
      const index = sortOrders.indexOf(order || null);
      return sortOrders[index > sortOrders.length - 2 ? 0 : index + 1];
    };
    const handleSortClick = (event, column, givenOrder) => {
      var _a;
      event.stopPropagation();
      const order = column.order === givenOrder ? null : givenOrder || toggleOrder(column);
      const target = (_a = event.target) == null ? void 0 : _a.closest("th");
      if (target) {
        if (hasClass(target, "noclick")) {
          removeClass(target, "noclick");
          return;
        }
      }
      if (!column.sortable)
        return;
      const clickTarget = event.currentTarget;
      if (["ascending", "descending"].some((str) => hasClass(clickTarget, str) && !column.sortOrders.includes(str))) {
        return;
      }
      const states = props.store.states;
      let sortProp = states.sortProp.value;
      let sortOrder;
      const sortingColumn = states.sortingColumn.value;
      if (sortingColumn !== column || sortingColumn === column && isNull(sortingColumn.order)) {
        if (sortingColumn) {
          sortingColumn.order = null;
        }
        states.sortingColumn.value = column;
        sortProp = column.property;
      }
      if (!order) {
        sortOrder = column.order = null;
      } else {
        sortOrder = column.order = order;
      }
      states.sortProp.value = sortProp;
      states.sortOrder.value = sortOrder;
      parent == null ? void 0 : parent.store.commit("changeSortCondition");
    };
    return {
      handleHeaderClick,
      handleHeaderContextMenu,
      handleMouseDown,
      handleMouseMove,
      handleMouseOut,
      handleSortClick,
      handleFilterClick
    };
  }

  function useStyle$2(props) {
    const parent = vue.inject(TABLE_INJECTION_KEY);
    const ns = useNamespace("table");
    const getHeaderRowStyle = (rowIndex) => {
      const headerRowStyle = parent == null ? void 0 : parent.props.headerRowStyle;
      if (isFunction$1(headerRowStyle)) {
        return headerRowStyle.call(null, { rowIndex });
      }
      return headerRowStyle;
    };
    const getHeaderRowClass = (rowIndex) => {
      const classes = [];
      const headerRowClassName = parent == null ? void 0 : parent.props.headerRowClassName;
      if (isString$1(headerRowClassName)) {
        classes.push(headerRowClassName);
      } else if (isFunction$1(headerRowClassName)) {
        classes.push(headerRowClassName.call(null, { rowIndex }));
      }
      return classes.join(" ");
    };
    const getHeaderCellStyle = (rowIndex, columnIndex, row, column) => {
      var _a;
      let headerCellStyles = (_a = parent == null ? void 0 : parent.props.headerCellStyle) != null ? _a : {};
      if (isFunction$1(headerCellStyles)) {
        headerCellStyles = headerCellStyles.call(null, {
          rowIndex,
          columnIndex,
          row,
          column
        });
      }
      const fixedStyle = getFixedColumnOffset(columnIndex, column.fixed, props.store, row);
      ensurePosition(fixedStyle, "left");
      ensurePosition(fixedStyle, "right");
      return Object.assign({}, headerCellStyles, fixedStyle);
    };
    const getHeaderCellClass = (rowIndex, columnIndex, row, column) => {
      const fixedClasses = getFixedColumnsClass(ns.b(), columnIndex, column.fixed, props.store, row);
      const classes = [
        column.id,
        column.order,
        column.headerAlign,
        column.className,
        column.labelClassName,
        ...fixedClasses
      ];
      if (!column.children) {
        classes.push("is-leaf");
      }
      if (column.sortable) {
        classes.push("is-sortable");
      }
      const headerCellClassName = parent == null ? void 0 : parent.props.headerCellClassName;
      if (isString$1(headerCellClassName)) {
        classes.push(headerCellClassName);
      } else if (isFunction$1(headerCellClassName)) {
        classes.push(headerCellClassName.call(null, {
          rowIndex,
          columnIndex,
          row,
          column
        }));
      }
      classes.push(ns.e("cell"));
      return classes.filter((className) => Boolean(className)).join(" ");
    };
    return {
      getHeaderRowStyle,
      getHeaderRowClass,
      getHeaderCellStyle,
      getHeaderCellClass
    };
  }

  const getAllColumns = (columns) => {
    const result = [];
    columns.forEach((column) => {
      if (column.children) {
        result.push(column);
        result.push.apply(result, getAllColumns(column.children));
      } else {
        result.push(column);
      }
    });
    return result;
  };
  const convertToRows = (originColumns) => {
    let maxLevel = 1;
    const traverse = (column, parent) => {
      if (parent) {
        column.level = parent.level + 1;
        if (maxLevel < column.level) {
          maxLevel = column.level;
        }
      }
      if (column.children) {
        let colSpan = 0;
        column.children.forEach((subColumn) => {
          traverse(subColumn, column);
          colSpan += subColumn.colSpan;
        });
        column.colSpan = colSpan;
      } else {
        column.colSpan = 1;
      }
    };
    originColumns.forEach((column) => {
      column.level = 1;
      traverse(column, void 0);
    });
    const rows = [];
    for (let i = 0; i < maxLevel; i++) {
      rows.push([]);
    }
    const allColumns = getAllColumns(originColumns);
    allColumns.forEach((column) => {
      if (!column.children) {
        column.rowSpan = maxLevel - column.level + 1;
      } else {
        column.rowSpan = 1;
        column.children.forEach((col) => col.isSubColumn = true);
      }
      rows[column.level - 1].push(column);
    });
    return rows;
  };
  function useUtils$1(props) {
    const parent = vue.inject(TABLE_INJECTION_KEY);
    const columnRows = vue.computed(() => {
      return convertToRows(props.store.states.originColumns.value);
    });
    const isGroup = vue.computed(() => {
      const result = columnRows.value.length > 1;
      if (result && parent) {
        parent.state.isGroup.value = true;
      }
      return result;
    });
    const toggleAllSelection = (event) => {
      event.stopPropagation();
      parent == null ? void 0 : parent.store.commit("toggleAllSelection");
    };
    return {
      isGroup,
      toggleAllSelection,
      columnRows
    };
  }

  var TableHeader = vue.defineComponent({
    name: "ElTableHeader",
    components: {
      ElCheckbox
    },
    props: {
      fixed: {
        type: String,
        default: ""
      },
      store: {
        required: true,
        type: Object
      },
      border: Boolean,
      defaultSort: {
        type: Object,
        default: () => {
          return {
            prop: "",
            order: ""
          };
        }
      },
      appendFilterPanelTo: {
        type: String
      },
      allowDragLastColumn: {
        type: Boolean
      }
    },
    setup(props, { emit }) {
      const instance = vue.getCurrentInstance();
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const filterPanels = vue.ref({});
      const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent);
      const isTableLayoutAuto = (parent == null ? void 0 : parent.props.tableLayout) === "auto";
      const saveIndexSelection = vue.reactive(/* @__PURE__ */ new Map());
      const theadRef = vue.ref();
      let delayId;
      const updateFixedColumnStyle = () => {
        delayId = setTimeout(() => {
          if (saveIndexSelection.size > 0) {
            saveIndexSelection.forEach((column, key) => {
              const el = theadRef.value.querySelector(`.${key.replace(/\s/g, ".")}`);
              if (el) {
                const width = el.getBoundingClientRect().width;
                column.width = width || column.width;
              }
            });
            saveIndexSelection.clear();
          }
        });
      };
      vue.watch(saveIndexSelection, updateFixedColumnStyle);
      vue.onBeforeUnmount(() => {
        if (delayId) {
          clearTimeout(delayId);
          delayId = void 0;
        }
      });
      vue.onMounted(async () => {
        await vue.nextTick();
        await vue.nextTick();
        const { prop, order } = props.defaultSort;
        parent == null ? void 0 : parent.store.commit("sort", { prop, order, init: true });
        updateFixedColumnStyle();
      });
      const {
        handleHeaderClick,
        handleHeaderContextMenu,
        handleMouseDown,
        handleMouseMove,
        handleMouseOut,
        handleSortClick,
        handleFilterClick
      } = useEvent(props, emit);
      const {
        getHeaderRowStyle,
        getHeaderRowClass,
        getHeaderCellStyle,
        getHeaderCellClass
      } = useStyle$2(props);
      const { isGroup, toggleAllSelection, columnRows } = useUtils$1(props);
      instance.state = {
        onColumnsChange,
        onScrollableChange
      };
      instance.filterPanels = filterPanels;
      return {
        ns,
        filterPanels,
        onColumnsChange,
        onScrollableChange,
        columnRows,
        getHeaderRowClass,
        getHeaderRowStyle,
        getHeaderCellClass,
        getHeaderCellStyle,
        handleHeaderClick,
        handleHeaderContextMenu,
        handleMouseDown,
        handleMouseMove,
        handleMouseOut,
        handleSortClick,
        handleFilterClick,
        isGroup,
        toggleAllSelection,
        saveIndexSelection,
        isTableLayoutAuto,
        theadRef,
        updateFixedColumnStyle
      };
    },
    render() {
      const {
        ns,
        isGroup,
        columnRows,
        getHeaderCellStyle,
        getHeaderCellClass,
        getHeaderRowClass,
        getHeaderRowStyle,
        handleHeaderClick,
        handleHeaderContextMenu,
        handleMouseDown,
        handleMouseMove,
        handleSortClick,
        handleMouseOut,
        store,
        $parent,
        saveIndexSelection,
        isTableLayoutAuto
      } = this;
      let rowSpan = 1;
      return vue.h("thead", {
        ref: "theadRef",
        class: ns.is("group", isGroup)
      }, columnRows.map((subColumns, rowIndex) => vue.h("tr", {
        class: getHeaderRowClass(rowIndex),
        key: rowIndex,
        style: getHeaderRowStyle(rowIndex)
      }, subColumns.map((column, cellIndex) => {
        if (column.rowSpan > rowSpan) {
          rowSpan = column.rowSpan;
        }
        const _class = getHeaderCellClass(rowIndex, cellIndex, subColumns, column);
        if (isTableLayoutAuto && column.fixed) {
          saveIndexSelection.set(_class, column);
        }
        return vue.h("th", {
          class: _class,
          colspan: column.colSpan,
          key: `${column.id}-thead`,
          rowspan: column.rowSpan,
          style: getHeaderCellStyle(rowIndex, cellIndex, subColumns, column),
          onClick: ($event) => {
            var _a;
            if ((_a = $event.currentTarget) == null ? void 0 : _a.classList.contains("noclick")) {
              return;
            }
            handleHeaderClick($event, column);
          },
          onContextmenu: ($event) => handleHeaderContextMenu($event, column),
          onMousedown: ($event) => handleMouseDown($event, column),
          onMousemove: ($event) => handleMouseMove($event, column),
          onMouseout: handleMouseOut
        }, [
          vue.h("div", {
            class: [
              "cell",
              column.filteredValue && column.filteredValue.length > 0 ? "highlight" : ""
            ]
          }, [
            column.renderHeader ? column.renderHeader({
              column,
              $index: cellIndex,
              store,
              _self: $parent
            }) : column.label,
            column.sortable && vue.h("span", {
              onClick: ($event) => handleSortClick($event, column),
              class: "caret-wrapper"
            }, [
              vue.h("i", {
                onClick: ($event) => handleSortClick($event, column, "ascending"),
                class: "sort-caret ascending"
              }),
              vue.h("i", {
                onClick: ($event) => handleSortClick($event, column, "descending"),
                class: "sort-caret descending"
              })
            ]),
            column.filterable && vue.h(FilterPanel, {
              store,
              placement: column.filterPlacement || "bottom-start",
              appendTo: $parent == null ? void 0 : $parent.appendFilterPanelTo,
              column,
              upDataColumn: (key, value) => {
                column[key] = value;
              }
            }, {
              "filter-icon": () => column.renderFilterIcon ? column.renderFilterIcon({
                filterOpened: column.filterOpened
              }) : null
            })
          ])
        ]);
      }))));
    }
  });

  function isGreaterThan(a, b, epsilon = 0.03) {
    return a - b > epsilon;
  }
  function useEvents(props) {
    const parent = vue.inject(TABLE_INJECTION_KEY);
    const tooltipContent = vue.ref("");
    const tooltipTrigger = vue.ref(vue.h("div"));
    const handleEvent = (event, row, name) => {
      var _a, _b, _c;
      const table = parent;
      const cell = getCell(event);
      let column = null;
      const namespace = (_a = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a.dataset.prefix;
      if (cell) {
        column = getColumnByCell({
          columns: (_c = (_b = props.store) == null ? void 0 : _b.states.columns.value) != null ? _c : []
        }, cell, namespace);
        if (column) {
          table == null ? void 0 : table.emit(`cell-${name}`, row, column, cell, event);
        }
      }
      table == null ? void 0 : table.emit(`row-${name}`, row, column, event);
    };
    const handleDoubleClick = (event, row) => {
      handleEvent(event, row, "dblclick");
    };
    const handleClick = (event, row) => {
      var _a;
      (_a = props.store) == null ? void 0 : _a.commit("setCurrentRow", row);
      handleEvent(event, row, "click");
    };
    const handleContextMenu = (event, row) => {
      handleEvent(event, row, "contextmenu");
    };
    const handleMouseEnter = debounce((index) => {
      var _a;
      (_a = props.store) == null ? void 0 : _a.commit("setHoverRow", index);
    }, 30);
    const handleMouseLeave = debounce(() => {
      var _a;
      (_a = props.store) == null ? void 0 : _a.commit("setHoverRow", null);
    }, 30);
    const getPadding = (el) => {
      const style = window.getComputedStyle(el, null);
      const paddingLeft = Number.parseInt(style.paddingLeft, 10) || 0;
      const paddingRight = Number.parseInt(style.paddingRight, 10) || 0;
      const paddingTop = Number.parseInt(style.paddingTop, 10) || 0;
      const paddingBottom = Number.parseInt(style.paddingBottom, 10) || 0;
      return {
        left: paddingLeft,
        right: paddingRight,
        top: paddingTop,
        bottom: paddingBottom
      };
    };
    const toggleRowClassByCell = (rowSpan, event, toggle) => {
      var _a;
      let node = (_a = event == null ? void 0 : event.target) == null ? void 0 : _a.parentNode;
      while (rowSpan > 1) {
        node = node == null ? void 0 : node.nextSibling;
        if (!node || node.nodeName !== "TR")
          break;
        toggle(node, "hover-row hover-fixed-row");
        rowSpan--;
      }
    };
    const handleCellMouseEnter = (event, row, tooltipOptions) => {
      var _a, _b, _c, _d, _e, _f, _g, _h;
      if (!parent)
        return;
      const table = parent;
      const cell = getCell(event);
      const namespace = (_a = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a.dataset.prefix;
      let column = null;
      if (cell) {
        column = getColumnByCell({
          columns: (_c = (_b = props.store) == null ? void 0 : _b.states.columns.value) != null ? _c : []
        }, cell, namespace);
        if (!column) {
          return;
        }
        if (cell.rowSpan > 1) {
          toggleRowClassByCell(cell.rowSpan, event, addClass);
        }
        const hoverState = table.hoverState = {
          cell,
          column,
          row
        };
        table == null ? void 0 : table.emit("cell-mouse-enter", hoverState.row, hoverState.column, hoverState.cell, event);
      }
      if (!tooltipOptions) {
        if (((_d = removePopper) == null ? void 0 : _d.trigger) === cell) {
          (_e = removePopper) == null ? void 0 : _e();
        }
        return;
      }
      const cellChild = event.target.querySelector(".cell");
      if (!(hasClass(cellChild, `${namespace}-tooltip`) && cellChild.childNodes.length)) {
        return;
      }
      const range = document.createRange();
      range.setStart(cellChild, 0);
      range.setEnd(cellChild, cellChild.childNodes.length);
      const { width: rangeWidth, height: rangeHeight } = range.getBoundingClientRect();
      const { width: cellChildWidth, height: cellChildHeight } = cellChild.getBoundingClientRect();
      const { top, left, right, bottom } = getPadding(cellChild);
      const horizontalPadding = left + right;
      const verticalPadding = top + bottom;
      if (isGreaterThan(rangeWidth + horizontalPadding, cellChildWidth) || isGreaterThan(rangeHeight + verticalPadding, cellChildHeight) || isGreaterThan(cellChild.scrollWidth, cellChildWidth)) {
        createTablePopper(tooltipOptions, (_f = (cell == null ? void 0 : cell.innerText) || (cell == null ? void 0 : cell.textContent)) != null ? _f : "", row, column, cell, table);
      } else if (((_g = removePopper) == null ? void 0 : _g.trigger) === cell) {
        (_h = removePopper) == null ? void 0 : _h();
      }
    };
    const handleCellMouseLeave = (event) => {
      const cell = getCell(event);
      if (!cell)
        return;
      if (cell.rowSpan > 1) {
        toggleRowClassByCell(cell.rowSpan, event, removeClass);
      }
      const oldHoverState = parent == null ? void 0 : parent.hoverState;
      parent == null ? void 0 : parent.emit("cell-mouse-leave", oldHoverState == null ? void 0 : oldHoverState.row, oldHoverState == null ? void 0 : oldHoverState.column, oldHoverState == null ? void 0 : oldHoverState.cell, event);
    };
    return {
      handleDoubleClick,
      handleClick,
      handleContextMenu,
      handleMouseEnter,
      handleMouseLeave,
      handleCellMouseEnter,
      handleCellMouseLeave,
      tooltipContent,
      tooltipTrigger
    };
  }

  function useStyles$1(props) {
    const parent = vue.inject(TABLE_INJECTION_KEY);
    const ns = useNamespace("table");
    const getRowStyle = (row, rowIndex) => {
      const rowStyle = parent == null ? void 0 : parent.props.rowStyle;
      if (isFunction$1(rowStyle)) {
        return rowStyle.call(null, {
          row,
          rowIndex
        });
      }
      return rowStyle || null;
    };
    const getRowClass = (row, rowIndex, displayIndex) => {
      var _a;
      const classes = [ns.e("row")];
      if ((parent == null ? void 0 : parent.props.highlightCurrentRow) && row === ((_a = props.store) == null ? void 0 : _a.states.currentRow.value)) {
        classes.push("current-row");
      }
      if (props.stripe && displayIndex % 2 === 1) {
        classes.push(ns.em("row", "striped"));
      }
      const rowClassName = parent == null ? void 0 : parent.props.rowClassName;
      if (isString$1(rowClassName)) {
        classes.push(rowClassName);
      } else if (isFunction$1(rowClassName)) {
        classes.push(rowClassName.call(null, {
          row,
          rowIndex
        }));
      }
      return classes;
    };
    const getCellStyle = (rowIndex, columnIndex, row, column) => {
      const cellStyle = parent == null ? void 0 : parent.props.cellStyle;
      let cellStyles = cellStyle != null ? cellStyle : {};
      if (isFunction$1(cellStyle)) {
        cellStyles = cellStyle.call(null, {
          rowIndex,
          columnIndex,
          row,
          column
        });
      }
      const fixedStyle = getFixedColumnOffset(columnIndex, props == null ? void 0 : props.fixed, props.store);
      ensurePosition(fixedStyle, "left");
      ensurePosition(fixedStyle, "right");
      return Object.assign({}, cellStyles, fixedStyle);
    };
    const getCellClass = (rowIndex, columnIndex, row, column, offset) => {
      const fixedClasses = getFixedColumnsClass(ns.b(), columnIndex, props == null ? void 0 : props.fixed, props.store, void 0, offset);
      const classes = [column.id, column.align, column.className, ...fixedClasses];
      const cellClassName = parent == null ? void 0 : parent.props.cellClassName;
      if (isString$1(cellClassName)) {
        classes.push(cellClassName);
      } else if (isFunction$1(cellClassName)) {
        classes.push(cellClassName.call(null, {
          rowIndex,
          columnIndex,
          row,
          column
        }));
      }
      classes.push(ns.e("cell"));
      return classes.filter((className) => Boolean(className)).join(" ");
    };
    const getSpan = (row, column, rowIndex, columnIndex) => {
      let rowspan = 1;
      let colspan = 1;
      const fn = parent == null ? void 0 : parent.props.spanMethod;
      if (isFunction$1(fn)) {
        const result = fn({
          row,
          column,
          rowIndex,
          columnIndex
        });
        if (isArray$1(result)) {
          rowspan = result[0];
          colspan = result[1];
        } else if (isObject$1(result)) {
          rowspan = result.rowspan;
          colspan = result.colspan;
        }
      }
      return { rowspan, colspan };
    };
    const getColspanRealWidth = (columns, colspan, index) => {
      if (colspan < 1) {
        return columns[index].realWidth;
      }
      const widthArr = columns.map(({ realWidth, width }) => realWidth || width).slice(index, index + colspan);
      return Number(widthArr.reduce((acc, width) => Number(acc) + Number(width), -1));
    };
    return {
      getRowStyle,
      getRowClass,
      getCellStyle,
      getCellClass,
      getSpan,
      getColspanRealWidth
    };
  }

  const __default__$s = vue.defineComponent({
    name: "TableTdWrapper"
  });
  const _sfc_main$y = /* @__PURE__ */ vue.defineComponent({
    ...__default__$s,
    props: {
      colspan: {
        type: Number,
        default: 1
      },
      rowspan: {
        type: Number,
        default: 1
      }
    },
    setup(__props) {
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("td", {
          colspan: __props.colspan,
          rowspan: __props.rowspan
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 8, ["colspan", "rowspan"]);
      };
    }
  });
  var TdWrapper = /* @__PURE__ */ _export_sfc(_sfc_main$y, [["__file", "td-wrapper.vue"]]);

  function useRender$1(props) {
    const parent = vue.inject(TABLE_INJECTION_KEY);
    const ns = useNamespace("table");
    const {
      handleDoubleClick,
      handleClick,
      handleContextMenu,
      handleMouseEnter,
      handleMouseLeave,
      handleCellMouseEnter,
      handleCellMouseLeave,
      tooltipContent,
      tooltipTrigger
    } = useEvents(props);
    const {
      getRowStyle,
      getRowClass,
      getCellStyle,
      getCellClass,
      getSpan,
      getColspanRealWidth
    } = useStyles$1(props);
    let displayIndex = -1;
    const firstDefaultColumnIndex = vue.computed(() => {
      var _a;
      return (_a = props.store) == null ? void 0 : _a.states.columns.value.findIndex(({ type }) => type === "default");
    });
    const getKeyOfRow = (row, index) => {
      var _a;
      const rowKey = (_a = parent == null ? void 0 : parent.props) == null ? void 0 : _a.rowKey;
      if (rowKey) {
        return getRowIdentity(row, rowKey);
      }
      return index;
    };
    const rowRender = (row, $index, treeRowData, expanded = false) => {
      const { tooltipEffect, tooltipOptions, store } = props;
      const { indent, columns } = store.states;
      const rowClasses = [];
      let display = true;
      if (treeRowData) {
        rowClasses.push(ns.em("row", `level-${treeRowData.level}`));
        display = !!treeRowData.display;
      }
      if ($index === 0) {
        displayIndex = -1;
      }
      if (props.stripe && display) {
        displayIndex++;
      }
      rowClasses.push(...getRowClass(row, $index, displayIndex));
      const displayStyle = display ? null : { display: "none" };
      return vue.h("tr", {
        style: [displayStyle, getRowStyle(row, $index)],
        class: rowClasses,
        key: getKeyOfRow(row, $index),
        onDblclick: ($event) => handleDoubleClick($event, row),
        onClick: ($event) => handleClick($event, row),
        onContextmenu: ($event) => handleContextMenu($event, row),
        onMouseenter: () => handleMouseEnter($index),
        onMouseleave: handleMouseLeave
      }, columns.value.map((column, cellIndex) => {
        const { rowspan, colspan } = getSpan(row, column, $index, cellIndex);
        if (!rowspan || !colspan) {
          return null;
        }
        const columnData = Object.assign({}, column);
        columnData.realWidth = getColspanRealWidth(columns.value, colspan, cellIndex);
        const data = {
          store,
          _self: props.context || parent,
          column: columnData,
          row,
          $index,
          cellIndex,
          expanded
        };
        if (cellIndex === firstDefaultColumnIndex.value && treeRowData) {
          data.treeNode = {
            indent: treeRowData.level && treeRowData.level * indent.value,
            level: treeRowData.level
          };
          if (isBoolean(treeRowData.expanded)) {
            data.treeNode.expanded = treeRowData.expanded;
            if ("loading" in treeRowData) {
              data.treeNode.loading = treeRowData.loading;
            }
            if ("noLazyChildren" in treeRowData) {
              data.treeNode.noLazyChildren = treeRowData.noLazyChildren;
            }
          }
        }
        const baseKey = `${getKeyOfRow(row, $index)},${cellIndex}`;
        const patchKey = columnData.columnKey || columnData.rawColumnKey || "";
        const mergedTooltipOptions = column.showOverflowTooltip && merge({
          effect: tooltipEffect
        }, tooltipOptions, column.showOverflowTooltip);
        return vue.h(TdWrapper, {
          style: getCellStyle($index, cellIndex, row, column),
          class: getCellClass($index, cellIndex, row, column, colspan - 1),
          key: `${patchKey}${baseKey}`,
          rowspan,
          colspan,
          onMouseenter: ($event) => handleCellMouseEnter($event, row, mergedTooltipOptions),
          onMouseleave: handleCellMouseLeave
        }, {
          default: () => cellChildren(cellIndex, column, data)
        });
      }));
    };
    const cellChildren = (_cellIndex, column, data) => {
      return column.renderCell(data);
    };
    const wrappedRowRender = (row, $index) => {
      const store = props.store;
      const { isRowExpanded, assertRowKey } = store;
      const { treeData, lazyTreeNodeMap, childrenColumnName, rowKey } = store.states;
      const columns = store.states.columns.value;
      const hasExpandColumn = columns.some(({ type }) => type === "expand");
      if (hasExpandColumn) {
        const expanded = isRowExpanded(row);
        const tr = rowRender(row, $index, void 0, expanded);
        const renderExpanded = parent == null ? void 0 : parent.renderExpanded;
        if (!renderExpanded) {
          console.error("[Element Error]renderExpanded is required.");
          return tr;
        }
        const rows = [[tr]];
        if (parent.props.preserveExpandedContent || expanded) {
          rows[0].push(vue.h("tr", {
            key: `expanded-row__${tr.key}`,
            style: { display: expanded ? "" : "none" }
          }, [
            vue.h("td", {
              colspan: columns.length,
              class: `${ns.e("cell")} ${ns.e("expanded-cell")}`
            }, [renderExpanded({ row, $index, store, expanded })])
          ]));
        }
        return rows;
      } else if (Object.keys(treeData.value).length) {
        assertRowKey();
        const key = getRowIdentity(row, rowKey.value);
        let cur = treeData.value[key];
        let treeRowData = null;
        if (cur) {
          treeRowData = {
            expanded: cur.expanded,
            level: cur.level,
            display: true,
            noLazyChildren: void 0,
            loading: void 0
          };
          if (isBoolean(cur.lazy)) {
            if (treeRowData && isBoolean(cur.loaded) && cur.loaded) {
              treeRowData.noLazyChildren = !(cur.children && cur.children.length);
            }
            treeRowData.loading = cur.loading;
          }
        }
        const tmp = [rowRender(row, $index, treeRowData != null ? treeRowData : void 0)];
        if (cur) {
          let i = 0;
          const traverse = (children, parent2) => {
            if (!(children && children.length && parent2))
              return;
            children.forEach((node) => {
              const innerTreeRowData = {
                display: parent2.display && parent2.expanded,
                level: parent2.level + 1,
                expanded: false,
                noLazyChildren: false,
                loading: false
              };
              const childKey = getRowIdentity(node, rowKey.value);
              if (isPropAbsent(childKey)) {
                throw new Error("For nested data item, row-key is required.");
              }
              cur = { ...treeData.value[childKey] };
              if (cur) {
                innerTreeRowData.expanded = cur.expanded;
                cur.level = cur.level || innerTreeRowData.level;
                cur.display = !!(cur.expanded && innerTreeRowData.display);
                if (isBoolean(cur.lazy)) {
                  if (isBoolean(cur.loaded) && cur.loaded) {
                    innerTreeRowData.noLazyChildren = !(cur.children && cur.children.length);
                  }
                  innerTreeRowData.loading = cur.loading;
                }
              }
              i++;
              tmp.push(rowRender(node, $index + i, innerTreeRowData));
              if (cur) {
                const nodes2 = lazyTreeNodeMap.value[childKey] || node[childrenColumnName.value];
                traverse(nodes2, cur);
              }
            });
          };
          cur.display = true;
          const nodes = lazyTreeNodeMap.value[key] || row[childrenColumnName.value];
          traverse(nodes, cur);
        }
        return tmp;
      } else {
        return rowRender(row, $index, void 0);
      }
    };
    return {
      wrappedRowRender,
      tooltipContent,
      tooltipTrigger
    };
  }

  const defaultProps$3 = {
    store: {
      required: true,
      type: Object
    },
    stripe: Boolean,
    tooltipEffect: String,
    tooltipOptions: {
      type: Object
    },
    context: {
      default: () => ({}),
      type: Object
    },
    rowClassName: [String, Function],
    rowStyle: [Object, Function],
    fixed: {
      type: String,
      default: ""
    },
    highlight: Boolean
  };
  var defaultProps$4 = defaultProps$3;

  var TableBody = vue.defineComponent({
    name: "ElTableBody",
    props: defaultProps$4,
    setup(props) {
      var _a;
      const instance = vue.getCurrentInstance();
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const { wrappedRowRender, tooltipContent, tooltipTrigger } = useRender$1(props);
      const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent);
      const hoveredCellList = [];
      vue.watch((_a = props.store) == null ? void 0 : _a.states.hoverRow, (newVal, oldVal) => {
        var _a2, _b;
        const el = instance == null ? void 0 : instance.vnode.el;
        const rows = Array.from((el == null ? void 0 : el.children) || []).filter((e) => e == null ? void 0 : e.classList.contains(`${ns.e("row")}`));
        let rowNum = newVal;
        const childNodes = (_a2 = rows[rowNum]) == null ? void 0 : _a2.childNodes;
        if (childNodes == null ? void 0 : childNodes.length) {
          let control = 0;
          const indexes = Array.from(childNodes).reduce((acc, item, index) => {
            var _a3, _b2;
            if (((_a3 = childNodes[index]) == null ? void 0 : _a3.colSpan) > 1) {
              control = (_b2 = childNodes[index]) == null ? void 0 : _b2.colSpan;
            }
            if (item.nodeName !== "TD" && control === 0) {
              acc.push(index);
            }
            control > 0 && control--;
            return acc;
          }, []);
          indexes.forEach((rowIndex) => {
            var _a3;
            rowNum = newVal;
            while (rowNum > 0) {
              const preChildNodes = (_a3 = rows[rowNum - 1]) == null ? void 0 : _a3.childNodes;
              if (preChildNodes[rowIndex] && preChildNodes[rowIndex].nodeName === "TD" && preChildNodes[rowIndex].rowSpan > 1) {
                addClass(preChildNodes[rowIndex], "hover-cell");
                hoveredCellList.push(preChildNodes[rowIndex]);
                break;
              }
              rowNum--;
            }
          });
        } else {
          hoveredCellList.forEach((item) => removeClass(item, "hover-cell"));
          hoveredCellList.length = 0;
        }
        if (!((_b = props.store) == null ? void 0 : _b.states.isComplex.value) || !isClient)
          return;
        rAF(() => {
          const oldRow = rows[oldVal];
          const newRow = rows[newVal];
          if (oldRow && !oldRow.classList.contains("hover-fixed-row")) {
            removeClass(oldRow, "hover-row");
          }
          if (newRow) {
            addClass(newRow, "hover-row");
          }
        });
      });
      vue.onUnmounted(() => {
        var _a2;
        (_a2 = removePopper) == null ? void 0 : _a2();
      });
      return {
        ns,
        onColumnsChange,
        onScrollableChange,
        wrappedRowRender,
        tooltipContent,
        tooltipTrigger
      };
    },
    render() {
      const { wrappedRowRender, store } = this;
      const data = (store == null ? void 0 : store.states.data.value) || [];
      return vue.h("tbody", { tabIndex: -1 }, [
        data.reduce((acc, row) => {
          return acc.concat(wrappedRowRender(row, acc.length));
        }, [])
      ]);
    }
  });

  function useMapState() {
    const table = vue.inject(TABLE_INJECTION_KEY);
    const store = table == null ? void 0 : table.store;
    const leftFixedLeafCount = vue.computed(() => {
      var _a;
      return (_a = store == null ? void 0 : store.states.fixedLeafColumnsLength.value) != null ? _a : 0;
    });
    const rightFixedLeafCount = vue.computed(() => {
      var _a;
      return (_a = store == null ? void 0 : store.states.rightFixedColumns.value.length) != null ? _a : 0;
    });
    const columnsCount = vue.computed(() => {
      var _a;
      return (_a = store == null ? void 0 : store.states.columns.value.length) != null ? _a : 0;
    });
    const leftFixedCount = vue.computed(() => {
      var _a;
      return (_a = store == null ? void 0 : store.states.fixedColumns.value.length) != null ? _a : 0;
    });
    const rightFixedCount = vue.computed(() => {
      var _a;
      return (_a = store == null ? void 0 : store.states.rightFixedColumns.value.length) != null ? _a : 0;
    });
    return {
      leftFixedLeafCount,
      rightFixedLeafCount,
      columnsCount,
      leftFixedCount,
      rightFixedCount,
      columns: vue.computed(() => {
        var _a;
        return (_a = store == null ? void 0 : store.states.columns.value) != null ? _a : [];
      })
    };
  }

  function useStyle$1(props) {
    const { columns } = useMapState();
    const ns = useNamespace("table");
    const getCellClasses = (columns2, cellIndex) => {
      const column = columns2[cellIndex];
      const classes = [
        ns.e("cell"),
        column.id,
        column.align,
        column.labelClassName,
        ...getFixedColumnsClass(ns.b(), cellIndex, column.fixed, props.store)
      ];
      if (column.className) {
        classes.push(column.className);
      }
      if (!column.children) {
        classes.push(ns.is("leaf"));
      }
      return classes;
    };
    const getCellStyles = (column, cellIndex) => {
      const fixedStyle = getFixedColumnOffset(cellIndex, column.fixed, props.store);
      ensurePosition(fixedStyle, "left");
      ensurePosition(fixedStyle, "right");
      return fixedStyle;
    };
    return {
      getCellClasses,
      getCellStyles,
      columns
    };
  }

  var TableFooter = vue.defineComponent({
    name: "ElTableFooter",
    props: {
      fixed: {
        type: String,
        default: ""
      },
      store: {
        required: true,
        type: Object
      },
      summaryMethod: Function,
      sumText: String,
      border: Boolean,
      defaultSort: {
        type: Object,
        default: () => {
          return {
            prop: "",
            order: ""
          };
        }
      }
    },
    setup(props) {
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const { getCellClasses, getCellStyles, columns } = useStyle$1(props);
      const { onScrollableChange, onColumnsChange } = useLayoutObserver(parent);
      return {
        ns,
        onScrollableChange,
        onColumnsChange,
        getCellClasses,
        getCellStyles,
        columns
      };
    },
    render() {
      const { columns, getCellStyles, getCellClasses, summaryMethod, sumText } = this;
      const data = this.store.states.data.value;
      let sums = [];
      if (summaryMethod) {
        sums = summaryMethod({
          columns,
          data
        });
      } else {
        columns.forEach((column, index) => {
          if (index === 0) {
            sums[index] = sumText;
            return;
          }
          const values = data.map((item) => Number(item[column.property]));
          const precisions = [];
          let notNumber = true;
          values.forEach((value) => {
            if (!Number.isNaN(+value)) {
              notNumber = false;
              const decimal = `${value}`.split(".")[1];
              precisions.push(decimal ? decimal.length : 0);
            }
          });
          const precision = Math.max.apply(null, precisions);
          if (!notNumber) {
            sums[index] = values.reduce((prev, curr) => {
              const value = Number(curr);
              if (!Number.isNaN(+value)) {
                return Number.parseFloat((prev + curr).toFixed(Math.min(precision, 20)));
              } else {
                return prev;
              }
            }, 0);
          } else {
            sums[index] = "";
          }
        });
      }
      return vue.h(vue.h("tfoot", [
        vue.h("tr", {}, [
          ...columns.map((column, cellIndex) => vue.h("td", {
            key: cellIndex,
            colspan: column.colSpan,
            rowspan: column.rowSpan,
            class: getCellClasses(columns, cellIndex),
            style: getCellStyles(column, cellIndex)
          }, [
            vue.h("div", {
              class: ["cell", column.labelClassName]
            }, [sums[cellIndex]])
          ]))
        ])
      ]));
    }
  });

  function useUtils(store) {
    const setCurrentRow = (row) => {
      store.commit("setCurrentRow", row);
    };
    const getSelectionRows = () => {
      return store.getSelectionRows();
    };
    const toggleRowSelection = (row, selected, ignoreSelectable = true) => {
      store.toggleRowSelection(row, selected, false, ignoreSelectable);
      store.updateAllSelected();
    };
    const clearSelection = () => {
      store.clearSelection();
    };
    const clearFilter = (columnKeys) => {
      store.clearFilter(columnKeys);
    };
    const toggleAllSelection = () => {
      store.commit("toggleAllSelection");
    };
    const toggleRowExpansion = (row, expanded) => {
      store.toggleRowExpansionAdapter(row, expanded);
    };
    const clearSort = () => {
      store.clearSort();
    };
    const sort = (prop, order) => {
      store.commit("sort", { prop, order });
    };
    const updateKeyChildren = (key, data) => {
      store.updateKeyChildren(key, data);
    };
    return {
      setCurrentRow,
      getSelectionRows,
      toggleRowSelection,
      clearSelection,
      clearFilter,
      toggleAllSelection,
      toggleRowExpansion,
      clearSort,
      sort,
      updateKeyChildren
    };
  }

  function useStyle(props, layout, store, table) {
    const isHidden = vue.ref(false);
    const renderExpanded = vue.ref(null);
    const resizeProxyVisible = vue.ref(false);
    const setDragVisible = (visible) => {
      resizeProxyVisible.value = visible;
    };
    const resizeState = vue.ref({
      width: null,
      height: null,
      headerHeight: null
    });
    const isGroup = vue.ref(false);
    const scrollbarViewStyle = {
      display: "inline-block",
      verticalAlign: "middle"
    };
    const tableWidth = vue.ref();
    const tableScrollHeight = vue.ref(0);
    const bodyScrollHeight = vue.ref(0);
    const headerScrollHeight = vue.ref(0);
    const footerScrollHeight = vue.ref(0);
    const appendScrollHeight = vue.ref(0);
    vue.watchEffect(() => {
      var _a;
      layout.setHeight((_a = props.height) != null ? _a : null);
    });
    vue.watchEffect(() => {
      var _a;
      layout.setMaxHeight((_a = props.maxHeight) != null ? _a : null);
    });
    vue.watch(() => [props.currentRowKey, store.states.rowKey], ([currentRowKey, rowKey]) => {
      if (!vue.unref(rowKey) || !vue.unref(currentRowKey))
        return;
      store.setCurrentRowKey(`${currentRowKey}`);
    }, {
      immediate: true
    });
    vue.watch(() => props.data, (data) => {
      table.store.commit("setData", data);
    }, {
      immediate: true,
      deep: true
    });
    vue.watchEffect(() => {
      if (props.expandRowKeys) {
        store.setExpandRowKeysAdapter(props.expandRowKeys);
      }
    });
    const handleMouseLeave = () => {
      table.store.commit("setHoverRow", null);
      if (table.hoverState)
        table.hoverState = null;
    };
    const handleHeaderFooterMousewheel = (_event, data) => {
      const { pixelX, pixelY } = data;
      if (Math.abs(pixelX) >= Math.abs(pixelY)) {
        table.refs.bodyWrapper.scrollLeft += data.pixelX / 5;
      }
    };
    const shouldUpdateHeight = vue.computed(() => {
      return props.height || props.maxHeight || store.states.fixedColumns.value.length > 0 || store.states.rightFixedColumns.value.length > 0;
    });
    const tableBodyStyles = vue.computed(() => {
      return {
        width: layout.bodyWidth.value ? `${layout.bodyWidth.value}px` : ""
      };
    });
    const doLayout = () => {
      if (shouldUpdateHeight.value) {
        layout.updateElsHeight();
      }
      layout.updateColumnsWidth();
      if (typeof window === "undefined")
        return;
      requestAnimationFrame(syncPosition);
    };
    vue.onMounted(async () => {
      await vue.nextTick();
      store.updateColumns();
      bindEvents();
      requestAnimationFrame(doLayout);
      const el = table.vnode.el;
      const tableHeader = table.refs.headerWrapper;
      if (props.flexible && el && el.parentElement) {
        el.parentElement.style.minWidth = "0";
      }
      resizeState.value = {
        width: tableWidth.value = el.offsetWidth,
        height: el.offsetHeight,
        headerHeight: props.showHeader && tableHeader ? tableHeader.offsetHeight : null
      };
      store.states.columns.value.forEach((column) => {
        if (column.filteredValue && column.filteredValue.length) {
          table.store.commit("filterChange", {
            column,
            values: column.filteredValue,
            silent: true
          });
        }
      });
      table.$ready = true;
    });
    const setScrollClassByEl = (el, className) => {
      if (!el)
        return;
      const classList = Array.from(el.classList).filter((item) => !item.startsWith("is-scrolling-"));
      classList.push(layout.scrollX.value ? className : "is-scrolling-none");
      el.className = classList.join(" ");
    };
    const setScrollClass = (className) => {
      const { tableWrapper } = table.refs;
      setScrollClassByEl(tableWrapper, className);
    };
    const hasScrollClass = (className) => {
      const { tableWrapper } = table.refs;
      return !!(tableWrapper && tableWrapper.classList.contains(className));
    };
    const syncPosition = function() {
      if (!table.refs.scrollBarRef)
        return;
      if (!layout.scrollX.value) {
        const scrollingNoneClass = "is-scrolling-none";
        if (!hasScrollClass(scrollingNoneClass)) {
          setScrollClass(scrollingNoneClass);
        }
        return;
      }
      const scrollContainer = table.refs.scrollBarRef.wrapRef;
      if (!scrollContainer)
        return;
      const { scrollLeft, offsetWidth, scrollWidth } = scrollContainer;
      const { headerWrapper, footerWrapper } = table.refs;
      if (headerWrapper)
        headerWrapper.scrollLeft = scrollLeft;
      if (footerWrapper)
        footerWrapper.scrollLeft = scrollLeft;
      const maxScrollLeftPosition = scrollWidth - offsetWidth - 1;
      if (scrollLeft >= maxScrollLeftPosition) {
        setScrollClass("is-scrolling-right");
      } else if (scrollLeft === 0) {
        setScrollClass("is-scrolling-left");
      } else {
        setScrollClass("is-scrolling-middle");
      }
    };
    const bindEvents = () => {
      if (!table.refs.scrollBarRef)
        return;
      if (table.refs.scrollBarRef.wrapRef) {
        useEventListener(table.refs.scrollBarRef.wrapRef, "scroll", syncPosition, {
          passive: true
        });
      }
      if (props.fit) {
        useResizeObserver(table.vnode.el, resizeListener);
      } else {
        useEventListener(window, "resize", resizeListener);
      }
      useResizeObserver(table.refs.bodyWrapper, () => {
        var _a, _b;
        resizeListener();
        (_b = (_a = table.refs) == null ? void 0 : _a.scrollBarRef) == null ? void 0 : _b.update();
      });
    };
    const resizeListener = () => {
      var _a, _b, _c, _d;
      const el = table.vnode.el;
      if (!table.$ready || !el)
        return;
      let shouldUpdateLayout = false;
      const {
        width: oldWidth,
        height: oldHeight,
        headerHeight: oldHeaderHeight
      } = resizeState.value;
      const width = tableWidth.value = el.offsetWidth;
      if (oldWidth !== width) {
        shouldUpdateLayout = true;
      }
      const height = el.offsetHeight;
      if ((props.height || shouldUpdateHeight.value) && oldHeight !== height) {
        shouldUpdateLayout = true;
      }
      const tableHeader = props.tableLayout === "fixed" ? table.refs.headerWrapper : (_a = table.refs.tableHeaderRef) == null ? void 0 : _a.$el;
      if (props.showHeader && (tableHeader == null ? void 0 : tableHeader.offsetHeight) !== oldHeaderHeight) {
        shouldUpdateLayout = true;
      }
      tableScrollHeight.value = ((_b = table.refs.tableWrapper) == null ? void 0 : _b.scrollHeight) || 0;
      headerScrollHeight.value = (tableHeader == null ? void 0 : tableHeader.scrollHeight) || 0;
      footerScrollHeight.value = ((_c = table.refs.footerWrapper) == null ? void 0 : _c.offsetHeight) || 0;
      appendScrollHeight.value = ((_d = table.refs.appendWrapper) == null ? void 0 : _d.offsetHeight) || 0;
      bodyScrollHeight.value = tableScrollHeight.value - headerScrollHeight.value - footerScrollHeight.value - appendScrollHeight.value;
      if (shouldUpdateLayout) {
        resizeState.value = {
          width,
          height,
          headerHeight: props.showHeader && (tableHeader == null ? void 0 : tableHeader.offsetHeight) || 0
        };
        doLayout();
      }
    };
    const tableSize = useFormSize();
    const bodyWidth = vue.computed(() => {
      const { bodyWidth: bodyWidth_, scrollY, gutterWidth } = layout;
      return bodyWidth_.value ? `${bodyWidth_.value - (scrollY.value ? gutterWidth : 0)}px` : "";
    });
    const tableLayout = vue.computed(() => {
      if (props.maxHeight)
        return "fixed";
      return props.tableLayout;
    });
    const emptyBlockStyle = vue.computed(() => {
      if (props.data && props.data.length)
        return;
      let height = "100%";
      if (props.height && bodyScrollHeight.value) {
        height = `${bodyScrollHeight.value}px`;
      }
      const width = tableWidth.value;
      return {
        width: width ? `${width}px` : "",
        height
      };
    });
    const scrollbarStyle = vue.computed(() => {
      if (props.height) {
        return {
          height: "100%"
        };
      }
      if (props.maxHeight) {
        if (!Number.isNaN(Number(props.maxHeight))) {
          return {
            maxHeight: `${+props.maxHeight - headerScrollHeight.value - footerScrollHeight.value}px`
          };
        } else {
          return {
            maxHeight: `calc(${props.maxHeight} - ${headerScrollHeight.value + footerScrollHeight.value}px)`
          };
        }
      }
      return {};
    });
    return {
      isHidden,
      renderExpanded,
      setDragVisible,
      isGroup,
      handleMouseLeave,
      handleHeaderFooterMousewheel,
      tableSize,
      emptyBlockStyle,
      resizeProxyVisible,
      bodyWidth,
      resizeState,
      doLayout,
      tableBodyStyles,
      tableLayout,
      scrollbarViewStyle,
      scrollbarStyle
    };
  }

  function useKeyRender(table) {
    const observer = vue.ref();
    const initWatchDom = () => {
      const el = table.vnode.el;
      const columnsWrapper = el.querySelector(".hidden-columns");
      const config = { childList: true, subtree: true };
      const updateOrderFns = table.store.states.updateOrderFns;
      observer.value = new MutationObserver(() => {
        updateOrderFns.forEach((fn) => fn());
      });
      observer.value.observe(columnsWrapper, config);
    };
    vue.onMounted(() => {
      initWatchDom();
    });
    vue.onUnmounted(() => {
      var _a;
      (_a = observer.value) == null ? void 0 : _a.disconnect();
    });
  }

  var defaultProps$2 = {
    data: {
      type: Array,
      default: () => []
    },
    size: useSizeProp,
    width: [String, Number],
    height: [String, Number],
    maxHeight: [String, Number],
    fit: {
      type: Boolean,
      default: true
    },
    stripe: Boolean,
    border: Boolean,
    rowKey: [String, Function],
    showHeader: {
      type: Boolean,
      default: true
    },
    showSummary: Boolean,
    sumText: String,
    summaryMethod: Function,
    rowClassName: [String, Function],
    rowStyle: [Object, Function],
    cellClassName: [String, Function],
    cellStyle: [Object, Function],
    headerRowClassName: [String, Function],
    headerRowStyle: [Object, Function],
    headerCellClassName: [String, Function],
    headerCellStyle: [Object, Function],
    highlightCurrentRow: Boolean,
    currentRowKey: [String, Number],
    emptyText: String,
    expandRowKeys: Array,
    defaultExpandAll: Boolean,
    defaultSort: Object,
    tooltipEffect: String,
    tooltipOptions: Object,
    spanMethod: Function,
    selectOnIndeterminate: {
      type: Boolean,
      default: true
    },
    indent: {
      type: Number,
      default: 16
    },
    treeProps: {
      type: Object,
      default: () => {
        return {
          hasChildren: "hasChildren",
          children: "children",
          checkStrictly: false
        };
      }
    },
    lazy: Boolean,
    load: Function,
    style: {
      type: Object,
      default: () => ({})
    },
    className: {
      type: String,
      default: ""
    },
    tableLayout: {
      type: String,
      default: "fixed"
    },
    scrollbarAlwaysOn: Boolean,
    flexible: Boolean,
    showOverflowTooltip: [Boolean, Object],
    tooltipFormatter: Function,
    appendFilterPanelTo: String,
    scrollbarTabindex: {
      type: [Number, String],
      default: void 0
    },
    allowDragLastColumn: {
      type: Boolean,
      default: true
    },
    preserveExpandedContent: Boolean,
    nativeScrollbar: Boolean
  };

  function hColgroup(props) {
    const isAuto = props.tableLayout === "auto";
    let columns = props.columns || [];
    if (isAuto) {
      if (columns.every(({ width }) => isUndefined(width))) {
        columns = [];
      }
    }
    const getPropsData = (column) => {
      const propsData = {
        key: `${props.tableLayout}_${column.id}`,
        style: {},
        name: void 0
      };
      if (isAuto) {
        propsData.style = {
          width: `${column.width}px`
        };
      } else {
        propsData.name = column.id;
      }
      return propsData;
    };
    return vue.h("colgroup", {}, columns.map((column) => vue.h("col", getPropsData(column))));
  }
  hColgroup.props = ["columns", "tableLayout"];

  const useScrollbar$1 = () => {
    const scrollBarRef = vue.ref();
    const scrollTo = (options, yCoord) => {
      const scrollbar = scrollBarRef.value;
      if (scrollbar) {
        scrollbar.scrollTo(options, yCoord);
      }
    };
    const setScrollPosition = (position, offset) => {
      const scrollbar = scrollBarRef.value;
      if (scrollbar && isNumber(offset) && ["Top", "Left"].includes(position)) {
        scrollbar[`setScroll${position}`](offset);
      }
    };
    const setScrollTop = (top) => setScrollPosition("Top", top);
    const setScrollLeft = (left) => setScrollPosition("Left", left);
    return {
      scrollBarRef,
      scrollTo,
      setScrollTop,
      setScrollLeft
    };
  };

  let tableIdSeed = 1;
  const _sfc_main$x = vue.defineComponent({
    name: "ElTable",
    directives: {
      Mousewheel
    },
    components: {
      TableHeader,
      TableBody,
      TableFooter,
      ElScrollbar,
      hColgroup
    },
    props: defaultProps$2,
    emits: [
      "select",
      "select-all",
      "selection-change",
      "cell-mouse-enter",
      "cell-mouse-leave",
      "cell-contextmenu",
      "cell-click",
      "cell-dblclick",
      "row-click",
      "row-contextmenu",
      "row-dblclick",
      "header-click",
      "header-contextmenu",
      "sort-change",
      "filter-change",
      "current-change",
      "header-dragend",
      "expand-change",
      "scroll"
    ],
    setup(props) {
      const { t } = useLocale();
      const ns = useNamespace("table");
      const table = vue.getCurrentInstance();
      vue.provide(TABLE_INJECTION_KEY, table);
      const store = createStore(table, props);
      table.store = store;
      const layout = new TableLayout$1({
        store: table.store,
        table,
        fit: props.fit,
        showHeader: props.showHeader
      });
      table.layout = layout;
      const isEmpty = vue.computed(() => (store.states.data.value || []).length === 0);
      const {
        setCurrentRow,
        getSelectionRows,
        toggleRowSelection,
        clearSelection,
        clearFilter,
        toggleAllSelection,
        toggleRowExpansion,
        clearSort,
        sort,
        updateKeyChildren
      } = useUtils(store);
      const {
        isHidden,
        renderExpanded,
        setDragVisible,
        isGroup,
        handleMouseLeave,
        handleHeaderFooterMousewheel,
        tableSize,
        emptyBlockStyle,
        resizeProxyVisible,
        bodyWidth,
        resizeState,
        doLayout,
        tableBodyStyles,
        tableLayout,
        scrollbarViewStyle,
        scrollbarStyle
      } = useStyle(props, layout, store, table);
      const { scrollBarRef, scrollTo, setScrollLeft, setScrollTop } = useScrollbar$1();
      const debouncedUpdateLayout = debounce(doLayout, 50);
      const tableId = `${ns.namespace.value}-table_${tableIdSeed++}`;
      table.tableId = tableId;
      table.state = {
        isGroup,
        resizeState,
        doLayout,
        debouncedUpdateLayout
      };
      const computedSumText = vue.computed(() => {
        var _a;
        return (_a = props.sumText) != null ? _a : t("el.table.sumText");
      });
      const computedEmptyText = vue.computed(() => {
        var _a;
        return (_a = props.emptyText) != null ? _a : t("el.table.emptyText");
      });
      const columns = vue.computed(() => {
        return convertToRows(store.states.originColumns.value)[0];
      });
      useKeyRender(table);
      vue.onBeforeUnmount(() => {
        debouncedUpdateLayout.cancel();
      });
      return {
        ns,
        layout,
        store,
        columns,
        handleHeaderFooterMousewheel,
        handleMouseLeave,
        tableId,
        tableSize,
        isHidden,
        isEmpty,
        renderExpanded,
        resizeProxyVisible,
        resizeState,
        isGroup,
        bodyWidth,
        tableBodyStyles,
        emptyBlockStyle,
        debouncedUpdateLayout,
        setCurrentRow,
        getSelectionRows,
        toggleRowSelection,
        clearSelection,
        clearFilter,
        toggleAllSelection,
        toggleRowExpansion,
        clearSort,
        doLayout,
        sort,
        updateKeyChildren,
        t,
        setDragVisible,
        context: table,
        computedSumText,
        computedEmptyText,
        tableLayout,
        scrollbarViewStyle,
        scrollbarStyle,
        scrollBarRef,
        scrollTo,
        setScrollLeft,
        setScrollTop,
        allowDragLastColumn: props.allowDragLastColumn
      };
    }
  });
  function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_hColgroup = vue.resolveComponent("hColgroup");
    const _component_table_header = vue.resolveComponent("table-header");
    const _component_table_body = vue.resolveComponent("table-body");
    const _component_table_footer = vue.resolveComponent("table-footer");
    const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
    const _directive_mousewheel = vue.resolveDirective("mousewheel");
    return vue.openBlock(), vue.createElementBlock("div", {
      ref: "tableWrapper",
      class: vue.normalizeClass([
        {
          [_ctx.ns.m("fit")]: _ctx.fit,
          [_ctx.ns.m("striped")]: _ctx.stripe,
          [_ctx.ns.m("border")]: _ctx.border || _ctx.isGroup,
          [_ctx.ns.m("hidden")]: _ctx.isHidden,
          [_ctx.ns.m("group")]: _ctx.isGroup,
          [_ctx.ns.m("fluid-height")]: _ctx.maxHeight,
          [_ctx.ns.m("scrollable-x")]: _ctx.layout.scrollX.value,
          [_ctx.ns.m("scrollable-y")]: _ctx.layout.scrollY.value,
          [_ctx.ns.m("enable-row-hover")]: !_ctx.store.states.isComplex.value,
          [_ctx.ns.m("enable-row-transition")]: (_ctx.store.states.data.value || []).length !== 0 && (_ctx.store.states.data.value || []).length < 100,
          "has-footer": _ctx.showSummary
        },
        _ctx.ns.m(_ctx.tableSize),
        _ctx.className,
        _ctx.ns.b(),
        _ctx.ns.m(`layout-${_ctx.tableLayout}`)
      ]),
      style: vue.normalizeStyle(_ctx.style),
      "data-prefix": _ctx.ns.namespace.value,
      onMouseleave: _ctx.handleMouseLeave
    }, [
      vue.createElementVNode("div", {
        class: vue.normalizeClass(_ctx.ns.e("inner-wrapper"))
      }, [
        vue.createElementVNode("div", {
          ref: "hiddenColumns",
          class: "hidden-columns"
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 512),
        _ctx.showHeader && _ctx.tableLayout === "fixed" ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
          key: 0,
          ref: "headerWrapper",
          class: vue.normalizeClass(_ctx.ns.e("header-wrapper"))
        }, [
          vue.createElementVNode("table", {
            ref: "tableHeader",
            class: vue.normalizeClass(_ctx.ns.e("header")),
            style: vue.normalizeStyle(_ctx.tableBodyStyles),
            border: "0",
            cellpadding: "0",
            cellspacing: "0"
          }, [
            vue.createVNode(_component_hColgroup, {
              columns: _ctx.store.states.columns.value,
              "table-layout": _ctx.tableLayout
            }, null, 8, ["columns", "table-layout"]),
            vue.createVNode(_component_table_header, {
              ref: "tableHeaderRef",
              border: _ctx.border,
              "default-sort": _ctx.defaultSort,
              store: _ctx.store,
              "append-filter-panel-to": _ctx.appendFilterPanelTo,
              "allow-drag-last-column": _ctx.allowDragLastColumn,
              onSetDragVisible: _ctx.setDragVisible
            }, null, 8, ["border", "default-sort", "store", "append-filter-panel-to", "allow-drag-last-column", "onSetDragVisible"])
          ], 6)
        ], 2)), [
          [_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
        ]) : vue.createCommentVNode("v-if", true),
        vue.createElementVNode("div", {
          ref: "bodyWrapper",
          class: vue.normalizeClass(_ctx.ns.e("body-wrapper"))
        }, [
          vue.createVNode(_component_el_scrollbar, {
            ref: "scrollBarRef",
            "view-style": _ctx.scrollbarViewStyle,
            "wrap-style": _ctx.scrollbarStyle,
            always: _ctx.scrollbarAlwaysOn,
            tabindex: _ctx.scrollbarTabindex,
            native: _ctx.nativeScrollbar,
            onScroll: ($event) => _ctx.$emit("scroll", $event)
          }, {
            default: vue.withCtx(() => [
              vue.createElementVNode("table", {
                ref: "tableBody",
                class: vue.normalizeClass(_ctx.ns.e("body")),
                cellspacing: "0",
                cellpadding: "0",
                border: "0",
                style: vue.normalizeStyle({
                  width: _ctx.bodyWidth,
                  tableLayout: _ctx.tableLayout
                })
              }, [
                vue.createVNode(_component_hColgroup, {
                  columns: _ctx.store.states.columns.value,
                  "table-layout": _ctx.tableLayout
                }, null, 8, ["columns", "table-layout"]),
                _ctx.showHeader && _ctx.tableLayout === "auto" ? (vue.openBlock(), vue.createBlock(_component_table_header, {
                  key: 0,
                  ref: "tableHeaderRef",
                  class: vue.normalizeClass(_ctx.ns.e("body-header")),
                  border: _ctx.border,
                  "default-sort": _ctx.defaultSort,
                  store: _ctx.store,
                  "append-filter-panel-to": _ctx.appendFilterPanelTo,
                  onSetDragVisible: _ctx.setDragVisible
                }, null, 8, ["class", "border", "default-sort", "store", "append-filter-panel-to", "onSetDragVisible"])) : vue.createCommentVNode("v-if", true),
                vue.createVNode(_component_table_body, {
                  context: _ctx.context,
                  highlight: _ctx.highlightCurrentRow,
                  "row-class-name": _ctx.rowClassName,
                  "tooltip-effect": _ctx.tooltipEffect,
                  "tooltip-options": _ctx.tooltipOptions,
                  "row-style": _ctx.rowStyle,
                  store: _ctx.store,
                  stripe: _ctx.stripe
                }, null, 8, ["context", "highlight", "row-class-name", "tooltip-effect", "tooltip-options", "row-style", "store", "stripe"]),
                _ctx.showSummary && _ctx.tableLayout === "auto" ? (vue.openBlock(), vue.createBlock(_component_table_footer, {
                  key: 1,
                  class: vue.normalizeClass(_ctx.ns.e("body-footer")),
                  border: _ctx.border,
                  "default-sort": _ctx.defaultSort,
                  store: _ctx.store,
                  "sum-text": _ctx.computedSumText,
                  "summary-method": _ctx.summaryMethod
                }, null, 8, ["class", "border", "default-sort", "store", "sum-text", "summary-method"])) : vue.createCommentVNode("v-if", true)
              ], 6),
              _ctx.isEmpty ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                ref: "emptyBlock",
                style: vue.normalizeStyle(_ctx.emptyBlockStyle),
                class: vue.normalizeClass(_ctx.ns.e("empty-block"))
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(_ctx.ns.e("empty-text"))
                }, [
                  vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                    vue.createTextVNode(vue.toDisplayString(_ctx.computedEmptyText), 1)
                  ])
                ], 2)
              ], 6)) : vue.createCommentVNode("v-if", true),
              _ctx.$slots.append ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                ref: "appendWrapper",
                class: vue.normalizeClass(_ctx.ns.e("append-wrapper"))
              }, [
                vue.renderSlot(_ctx.$slots, "append")
              ], 2)) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["view-style", "wrap-style", "always", "tabindex", "native", "onScroll"])
        ], 2),
        _ctx.showSummary && _ctx.tableLayout === "fixed" ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
          key: 1,
          ref: "footerWrapper",
          class: vue.normalizeClass(_ctx.ns.e("footer-wrapper"))
        }, [
          vue.createElementVNode("table", {
            class: vue.normalizeClass(_ctx.ns.e("footer")),
            cellspacing: "0",
            cellpadding: "0",
            border: "0",
            style: vue.normalizeStyle(_ctx.tableBodyStyles)
          }, [
            vue.createVNode(_component_hColgroup, {
              columns: _ctx.store.states.columns.value,
              "table-layout": _ctx.tableLayout
            }, null, 8, ["columns", "table-layout"]),
            vue.createVNode(_component_table_footer, {
              border: _ctx.border,
              "default-sort": _ctx.defaultSort,
              store: _ctx.store,
              "sum-text": _ctx.computedSumText,
              "summary-method": _ctx.summaryMethod
            }, null, 8, ["border", "default-sort", "store", "sum-text", "summary-method"])
          ], 6)
        ], 2)), [
          [vue.vShow, !_ctx.isEmpty],
          [_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
        ]) : vue.createCommentVNode("v-if", true),
        _ctx.border || _ctx.isGroup ? (vue.openBlock(), vue.createElementBlock("div", {
          key: 2,
          class: vue.normalizeClass(_ctx.ns.e("border-left-patch"))
        }, null, 2)) : vue.createCommentVNode("v-if", true)
      ], 2),
      vue.withDirectives(vue.createElementVNode("div", {
        ref: "resizeProxy",
        class: vue.normalizeClass(_ctx.ns.e("column-resize-proxy"))
      }, null, 2), [
        [vue.vShow, _ctx.resizeProxyVisible]
      ])
    ], 46, ["data-prefix", "onMouseleave"]);
  }
  var Table = /* @__PURE__ */ _export_sfc(_sfc_main$x, [["render", _sfc_render$3], ["__file", "table.vue"]]);

  const defaultClassNames = {
    selection: "table-column--selection",
    expand: "table__expand-column"
  };
  const cellStarts = {
    default: {
      order: ""
    },
    selection: {
      width: 48,
      minWidth: 48,
      realWidth: 48,
      order: ""
    },
    expand: {
      width: 48,
      minWidth: 48,
      realWidth: 48,
      order: ""
    },
    index: {
      width: 48,
      minWidth: 48,
      realWidth: 48,
      order: ""
    }
  };
  const getDefaultClassName = (type) => {
    return defaultClassNames[type] || "";
  };
  const cellForced = {
    selection: {
      renderHeader({
        store,
        column
      }) {
        var _a;
        function isDisabled() {
          return store.states.data.value && store.states.data.value.length === 0;
        }
        return vue.h(ElCheckbox, {
          disabled: isDisabled(),
          size: store.states.tableSize.value,
          indeterminate: store.states.selection.value.length > 0 && !store.states.isAllSelected.value,
          "onUpdate:modelValue": (_a = store.toggleAllSelection) != null ? _a : void 0,
          modelValue: store.states.isAllSelected.value,
          ariaLabel: column.label
        });
      },
      renderCell({
        row,
        column,
        store,
        $index
      }) {
        return vue.h(ElCheckbox, {
          disabled: column.selectable ? !column.selectable.call(null, row, $index) : false,
          size: store.states.tableSize.value,
          onChange: () => {
            store.commit("rowSelectedChanged", row);
          },
          onClick: (event) => event.stopPropagation(),
          modelValue: store.isSelected(row),
          ariaLabel: column.label
        });
      },
      sortable: false,
      resizable: false
    },
    index: {
      renderHeader({
        column
      }) {
        return column.label || "#";
      },
      renderCell({
        column,
        $index
      }) {
        let i = $index + 1;
        const index = column.index;
        if (isNumber(index)) {
          i = $index + index;
        } else if (isFunction$1(index)) {
          i = index($index);
        }
        return vue.h("div", {}, [i]);
      },
      sortable: false
    },
    expand: {
      renderHeader({
        column
      }) {
        return column.label || "";
      },
      renderCell({
        column,
        row,
        store,
        expanded
      }) {
        const { ns } = store;
        const classes = [ns.e("expand-icon")];
        if (!column.renderExpand && expanded) {
          classes.push(ns.em("expand-icon", "expanded"));
        }
        const callback = function(e) {
          e.stopPropagation();
          store.toggleRowExpansion(row);
        };
        return vue.h("div", {
          class: classes,
          onClick: callback
        }, {
          default: () => {
            if (column.renderExpand) {
              return [
                column.renderExpand({
                  expanded
                })
              ];
            }
            return [
              vue.h(ElIcon, null, {
                default: () => {
                  return [vue.h(arrow_right_default)];
                }
              })
            ];
          }
        });
      },
      sortable: false,
      resizable: false
    }
  };
  function defaultRenderCell({
    row,
    column,
    $index
  }) {
    var _a;
    const property = column.property;
    const value = property && getProp(row, property).value;
    if (column && column.formatter) {
      return column.formatter(row, column, value, $index);
    }
    return ((_a = value == null ? void 0 : value.toString) == null ? void 0 : _a.call(value)) || "";
  }
  function treeCellPrefix({
    row,
    treeNode,
    store
  }, createPlaceholder = false) {
    const { ns } = store;
    if (!treeNode) {
      if (createPlaceholder) {
        return [
          vue.h("span", {
            class: ns.e("placeholder")
          })
        ];
      }
      return null;
    }
    const ele = [];
    const callback = function(e) {
      e.stopPropagation();
      if (treeNode.loading) {
        return;
      }
      store.loadOrToggle(row);
    };
    if (treeNode.indent) {
      ele.push(vue.h("span", {
        class: ns.e("indent"),
        style: { "padding-left": `${treeNode.indent}px` }
      }));
    }
    if (isBoolean(treeNode.expanded) && !treeNode.noLazyChildren) {
      const expandClasses = [
        ns.e("expand-icon"),
        treeNode.expanded ? ns.em("expand-icon", "expanded") : ""
      ];
      let icon = arrow_right_default;
      if (treeNode.loading) {
        icon = loading_default;
      }
      ele.push(vue.h("div", {
        class: expandClasses,
        onClick: callback
      }, {
        default: () => {
          return [
            vue.h(ElIcon, { class: ns.is("loading", treeNode.loading) }, {
              default: () => [vue.h(icon)]
            })
          ];
        }
      }));
    } else {
      ele.push(vue.h("span", {
        class: ns.e("placeholder")
      }));
    }
    return ele;
  }

  function getAllAliases(props, aliases) {
    return props.reduce((prev, cur) => {
      prev[cur] = cur;
      return prev;
    }, aliases);
  }
  function useWatcher(owner, props_) {
    const instance = vue.getCurrentInstance();
    const registerComplexWatchers = () => {
      const props = ["fixed"];
      const aliases = {
        realWidth: "width",
        realMinWidth: "minWidth"
      };
      const allAliases = getAllAliases(props, aliases);
      Object.keys(allAliases).forEach((key) => {
        const columnKey = aliases[key];
        if (hasOwn(props_, columnKey)) {
          vue.watch(() => props_[columnKey], (newVal) => {
            let value = newVal;
            if (columnKey === "width" && key === "realWidth") {
              value = parseWidth(newVal);
            }
            if (columnKey === "minWidth" && key === "realMinWidth") {
              value = parseMinWidth(newVal);
            }
            instance.columnConfig.value[columnKey] = value;
            instance.columnConfig.value[key] = value;
            const updateColumns = columnKey === "fixed";
            owner.value.store.scheduleLayout(updateColumns);
          });
        }
      });
    };
    const registerNormalWatchers = () => {
      const props = [
        "label",
        "filters",
        "filterMultiple",
        "filteredValue",
        "sortable",
        "index",
        "formatter",
        "className",
        "labelClassName",
        "filterClassName",
        "showOverflowTooltip",
        "tooltipFormatter",
        "resizable"
      ];
      const parentProps = ["showOverflowTooltip"];
      const aliases = {
        property: "prop",
        align: "realAlign",
        headerAlign: "realHeaderAlign"
      };
      const allAliases = getAllAliases(props, aliases);
      Object.keys(allAliases).forEach((key) => {
        const columnKey = aliases[key];
        if (hasOwn(props_, columnKey)) {
          vue.watch(() => props_[columnKey], (newVal) => {
            instance.columnConfig.value[key] = newVal;
          });
        }
      });
      parentProps.forEach((key) => {
        if (hasOwn(owner.value.props, key)) {
          vue.watch(() => owner.value.props[key], (newVal) => {
            instance.columnConfig.value[key] = newVal;
          });
        }
      });
    };
    return {
      registerComplexWatchers,
      registerNormalWatchers
    };
  }

  function useRender(props, slots, owner) {
    const instance = vue.getCurrentInstance();
    const columnId = vue.ref("");
    const isSubColumn = vue.ref(false);
    const realAlign = vue.ref();
    const realHeaderAlign = vue.ref();
    const ns = useNamespace("table");
    vue.watchEffect(() => {
      realAlign.value = props.align ? `is-${props.align}` : null;
      realAlign.value;
    });
    vue.watchEffect(() => {
      realHeaderAlign.value = props.headerAlign ? `is-${props.headerAlign}` : realAlign.value;
      realHeaderAlign.value;
    });
    const columnOrTableParent = vue.computed(() => {
      let parent = instance.vnode.vParent || instance.parent;
      while (parent && !parent.tableId && !parent.columnId) {
        parent = parent.vnode.vParent || parent.parent;
      }
      return parent;
    });
    const hasTreeColumn = vue.computed(() => {
      const { store } = instance.parent;
      if (!store)
        return false;
      const { treeData } = store.states;
      const treeDataValue = treeData.value;
      return treeDataValue && Object.keys(treeDataValue).length > 0;
    });
    const realWidth = vue.ref(parseWidth(props.width));
    const realMinWidth = vue.ref(parseMinWidth(props.minWidth));
    const setColumnWidth = (column) => {
      if (realWidth.value)
        column.width = realWidth.value;
      if (realMinWidth.value) {
        column.minWidth = realMinWidth.value;
      }
      if (!realWidth.value && realMinWidth.value) {
        column.width = void 0;
      }
      if (!column.minWidth) {
        column.minWidth = 80;
      }
      column.realWidth = Number(isUndefined(column.width) ? column.minWidth : column.width);
      return column;
    };
    const setColumnForcedProps = (column) => {
      const type = column.type;
      const source = cellForced[type] || {};
      Object.keys(source).forEach((prop) => {
        const value = source[prop];
        if (prop !== "className" && !isUndefined(value)) {
          column[prop] = value;
        }
      });
      const className = getDefaultClassName(type);
      if (className) {
        const forceClass = `${vue.unref(ns.namespace)}-${className}`;
        column.className = column.className ? `${column.className} ${forceClass}` : forceClass;
      }
      return column;
    };
    const checkSubColumn = (children) => {
      if (isArray$1(children)) {
        children.forEach((child) => check(child));
      } else {
        check(children);
      }
      function check(item) {
        var _a;
        if (((_a = item == null ? void 0 : item.type) == null ? void 0 : _a.name) === "ElTableColumn") {
          item.vParent = instance;
        }
      }
    };
    const setColumnRenders = (column) => {
      if (props.renderHeader) {
        debugWarn("TableColumn", "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.");
      } else if (column.type !== "selection") {
        column.renderHeader = (scope) => {
          instance.columnConfig.value["label"];
          return vue.renderSlot(slots, "header", scope, () => [column.label]);
        };
      }
      if (slots["filter-icon"]) {
        column.renderFilterIcon = (scope) => {
          return vue.renderSlot(slots, "filter-icon", scope);
        };
      }
      if (slots.expand) {
        column.renderExpand = (scope) => {
          return vue.renderSlot(slots, "expand", scope);
        };
      }
      let originRenderCell = column.renderCell;
      if (column.type === "expand") {
        column.renderCell = (data) => vue.h("div", {
          class: "cell"
        }, [originRenderCell(data)]);
        owner.value.renderExpanded = (row) => {
          return slots.default ? slots.default(row) : slots.default;
        };
      } else {
        originRenderCell = originRenderCell || defaultRenderCell;
        column.renderCell = (data) => {
          let children = null;
          if (slots.default) {
            const vnodes = slots.default(data);
            children = vnodes.some((v) => v.type !== vue.Comment) ? vnodes : originRenderCell(data);
          } else {
            children = originRenderCell(data);
          }
          const { columns } = owner.value.store.states;
          const firstUserColumnIndex = columns.value.findIndex((item) => item.type === "default");
          const shouldCreatePlaceholder = hasTreeColumn.value && data.cellIndex === firstUserColumnIndex;
          const prefix = treeCellPrefix(data, shouldCreatePlaceholder);
          const props2 = {
            class: "cell",
            style: {}
          };
          if (column.showOverflowTooltip) {
            props2.class = `${props2.class} ${vue.unref(ns.namespace)}-tooltip`;
            props2.style = {
              width: `${(data.column.realWidth || Number(data.column.width)) - 1}px`
            };
          }
          checkSubColumn(children);
          return vue.h("div", props2, [prefix, children]);
        };
      }
      return column;
    };
    const getPropsData = (...propsKey) => {
      return propsKey.reduce((prev, cur) => {
        if (isArray$1(cur)) {
          cur.forEach((key) => {
            prev[key] = props[key];
          });
        }
        return prev;
      }, {});
    };
    const getColumnElIndex = (children, child) => {
      return Array.prototype.indexOf.call(children, child);
    };
    const updateColumnOrder = () => {
      owner.value.store.commit("updateColumnOrder", instance.columnConfig.value);
    };
    return {
      columnId,
      realAlign,
      isSubColumn,
      realHeaderAlign,
      columnOrTableParent,
      setColumnWidth,
      setColumnForcedProps,
      setColumnRenders,
      getPropsData,
      getColumnElIndex,
      updateColumnOrder
    };
  }

  var defaultProps$1 = {
    type: {
      type: String,
      default: "default"
    },
    label: String,
    className: String,
    labelClassName: String,
    property: String,
    prop: String,
    width: {
      type: [String, Number],
      default: ""
    },
    minWidth: {
      type: [String, Number],
      default: ""
    },
    renderHeader: Function,
    sortable: {
      type: [Boolean, String],
      default: false
    },
    sortMethod: Function,
    sortBy: [String, Function, Array],
    resizable: {
      type: Boolean,
      default: true
    },
    columnKey: String,
    align: String,
    headerAlign: String,
    showOverflowTooltip: {
      type: [Boolean, Object],
      default: void 0
    },
    tooltipFormatter: Function,
    fixed: [Boolean, String],
    formatter: Function,
    selectable: Function,
    reserveSelection: Boolean,
    filterMethod: Function,
    filteredValue: Array,
    filters: Array,
    filterPlacement: String,
    filterMultiple: {
      type: Boolean,
      default: true
    },
    filterClassName: String,
    index: [Number, Function],
    sortOrders: {
      type: Array,
      default: () => {
        return ["ascending", "descending", null];
      },
      validator: (val) => {
        return val.every((order) => ["ascending", "descending", null].includes(order));
      }
    }
  };

  let columnIdSeed = 1;
  var ElTableColumn$1 = vue.defineComponent({
    name: "ElTableColumn",
    components: {
      ElCheckbox
    },
    props: defaultProps$1,
    setup(props, { slots }) {
      const instance = vue.getCurrentInstance();
      const columnConfig = vue.ref({});
      const owner = vue.computed(() => {
        let parent2 = instance.parent;
        while (parent2 && !parent2.tableId) {
          parent2 = parent2.parent;
        }
        return parent2;
      });
      const { registerNormalWatchers, registerComplexWatchers } = useWatcher(owner, props);
      const {
        columnId,
        isSubColumn,
        realHeaderAlign,
        columnOrTableParent,
        setColumnWidth,
        setColumnForcedProps,
        setColumnRenders,
        getPropsData,
        getColumnElIndex,
        realAlign,
        updateColumnOrder
      } = useRender(props, slots, owner);
      const parent = columnOrTableParent.value;
      columnId.value = `${"tableId" in parent && parent.tableId || "columnId" in parent && parent.columnId}_column_${columnIdSeed++}`;
      vue.onBeforeMount(() => {
        isSubColumn.value = owner.value !== parent;
        const type = props.type || "default";
        const sortable = props.sortable === "" ? true : props.sortable;
        const showOverflowTooltip = type === "selection" ? false : isUndefined(props.showOverflowTooltip) ? parent.props.showOverflowTooltip : props.showOverflowTooltip;
        const tooltipFormatter = isUndefined(props.tooltipFormatter) ? parent.props.tooltipFormatter : props.tooltipFormatter;
        const defaults = {
          ...cellStarts[type],
          id: columnId.value,
          type,
          property: props.prop || props.property,
          align: realAlign,
          headerAlign: realHeaderAlign,
          showOverflowTooltip,
          tooltipFormatter,
          filterable: props.filters || props.filterMethod,
          filteredValue: [],
          filterPlacement: "",
          filterClassName: "",
          isColumnGroup: false,
          isSubColumn: false,
          filterOpened: false,
          sortable,
          index: props.index,
          rawColumnKey: instance.vnode.key
        };
        const basicProps = [
          "columnKey",
          "label",
          "className",
          "labelClassName",
          "type",
          "renderHeader",
          "formatter",
          "fixed",
          "resizable"
        ];
        const sortProps = ["sortMethod", "sortBy", "sortOrders"];
        const selectProps = ["selectable", "reserveSelection"];
        const filterProps = [
          "filterMethod",
          "filters",
          "filterMultiple",
          "filterOpened",
          "filteredValue",
          "filterPlacement",
          "filterClassName"
        ];
        let column = getPropsData(basicProps, sortProps, selectProps, filterProps);
        column = mergeOptions(defaults, column);
        const chains = compose(setColumnRenders, setColumnWidth, setColumnForcedProps);
        column = chains(column);
        columnConfig.value = column;
        registerNormalWatchers();
        registerComplexWatchers();
      });
      vue.onMounted(() => {
        var _a, _b;
        const parent2 = columnOrTableParent.value;
        const children = isSubColumn.value ? (_a = parent2.vnode.el) == null ? void 0 : _a.children : (_b = parent2.refs.hiddenColumns) == null ? void 0 : _b.children;
        const getColumnIndex = () => getColumnElIndex(children || [], instance.vnode.el);
        columnConfig.value.getColumnIndex = getColumnIndex;
        const columnIndex = getColumnIndex();
        columnIndex > -1 && owner.value.store.commit("insertColumn", columnConfig.value, isSubColumn.value ? "columnConfig" in parent2 && parent2.columnConfig.value : null, updateColumnOrder);
      });
      vue.onBeforeUnmount(() => {
        const getColumnIndex = columnConfig.value.getColumnIndex;
        const columnIndex = getColumnIndex ? getColumnIndex() : -1;
        columnIndex > -1 && owner.value.store.commit("removeColumn", columnConfig.value, isSubColumn.value ? "columnConfig" in parent && parent.columnConfig.value : null, updateColumnOrder);
      });
      instance.columnId = columnId.value;
      instance.columnConfig = columnConfig;
      return;
    },
    render() {
      var _a, _b, _c;
      try {
        const renderDefault = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a, {
          row: {},
          column: {},
          $index: -1
        });
        const children = [];
        if (isArray$1(renderDefault)) {
          for (const childNode of renderDefault) {
            if (((_c = childNode.type) == null ? void 0 : _c.name) === "ElTableColumn" || childNode.shapeFlag & 2) {
              children.push(childNode);
            } else if (childNode.type === vue.Fragment && isArray$1(childNode.children)) {
              childNode.children.forEach((vnode2) => {
                if ((vnode2 == null ? void 0 : vnode2.patchFlag) !== 1024 && !isString$1(vnode2 == null ? void 0 : vnode2.children)) {
                  children.push(vnode2);
                }
              });
            }
          }
        }
        const vnode = vue.h("div", children);
        return vnode;
      } catch (e) {
        return vue.h("div", []);
      }
    }
  });

  const ElTable = withInstall(Table, {
    TableColumn: ElTableColumn$1
  });
  const ElTableColumn = withNoopInstall(ElTableColumn$1);

  var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
    SortOrder2["ASC"] = "asc";
    SortOrder2["DESC"] = "desc";
    return SortOrder2;
  })(SortOrder || {});
  var Alignment = /* @__PURE__ */ ((Alignment2) => {
    Alignment2["LEFT"] = "left";
    Alignment2["CENTER"] = "center";
    Alignment2["RIGHT"] = "right";
    return Alignment2;
  })(Alignment || {});
  var FixedDir = /* @__PURE__ */ ((FixedDir2) => {
    FixedDir2["LEFT"] = "left";
    FixedDir2["RIGHT"] = "right";
    return FixedDir2;
  })(FixedDir || {});
  const oppositeOrderMap = {
    ["asc" /* ASC */]: "desc" /* DESC */,
    ["desc" /* DESC */]: "asc" /* ASC */
  };

  const placeholderSign = Symbol("placeholder");

  const calcColumnStyle = (column, fixedColumn, fixed) => {
    var _a;
    const flex = {
      flexGrow: 0,
      flexShrink: 0,
      ...fixed ? {} : {
        flexGrow: column.flexGrow || 0,
        flexShrink: column.flexShrink || 1
      }
    };
    if (!fixed) {
      flex.flexShrink = 1;
    }
    const style = {
      ...(_a = column.style) != null ? _a : {},
      ...flex,
      flexBasis: "auto",
      width: column.width
    };
    if (!fixedColumn) {
      if (column.maxWidth)
        style.maxWidth = column.maxWidth;
      if (column.minWidth)
        style.minWidth = column.minWidth;
    }
    return style;
  };

  function useColumns(props, columns, fixed) {
    const _columns = vue.computed(() => vue.unref(columns).map((column, index) => {
      var _a, _b;
      return {
        ...column,
        key: (_b = (_a = column.key) != null ? _a : column.dataKey) != null ? _b : index
      };
    }));
    const visibleColumns = vue.computed(() => {
      return vue.unref(_columns).filter((column) => !column.hidden);
    });
    const fixedColumnsOnLeft = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
    const fixedColumnsOnRight = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "right"));
    const normalColumns = vue.computed(() => vue.unref(visibleColumns).filter((column) => !column.fixed));
    const mainColumns = vue.computed(() => {
      const ret = [];
      vue.unref(fixedColumnsOnLeft).forEach((column) => {
        ret.push({
          ...column,
          placeholderSign
        });
      });
      vue.unref(normalColumns).forEach((column) => {
        ret.push(column);
      });
      vue.unref(fixedColumnsOnRight).forEach((column) => {
        ret.push({
          ...column,
          placeholderSign
        });
      });
      return ret;
    });
    const hasFixedColumns = vue.computed(() => {
      return vue.unref(fixedColumnsOnLeft).length || vue.unref(fixedColumnsOnRight).length;
    });
    const columnsStyles = vue.computed(() => {
      return vue.unref(_columns).reduce((style, column) => {
        style[column.key] = calcColumnStyle(column, vue.unref(fixed), props.fixed);
        return style;
      }, {});
    });
    const columnsTotalWidth = vue.computed(() => {
      return vue.unref(visibleColumns).reduce((width, column) => width + column.width, 0);
    });
    const getColumn = (key) => {
      return vue.unref(_columns).find((column) => column.key === key);
    };
    const getColumnStyle = (key) => {
      return vue.unref(columnsStyles)[key];
    };
    const updateColumnWidth = (column, width) => {
      column.width = width;
    };
    function onColumnSorted(e) {
      var _a;
      const { key } = e.currentTarget.dataset;
      if (!key)
        return;
      const { sortState, sortBy } = props;
      let order = SortOrder.ASC;
      if (isObject$1(sortState)) {
        order = oppositeOrderMap[sortState[key]];
      } else {
        order = oppositeOrderMap[sortBy.order];
      }
      (_a = props.onColumnSort) == null ? void 0 : _a.call(props, { column: getColumn(key), key, order });
    }
    return {
      columns: _columns,
      columnsStyles,
      columnsTotalWidth,
      fixedColumnsOnLeft,
      fixedColumnsOnRight,
      hasFixedColumns,
      mainColumns,
      normalColumns,
      visibleColumns,
      getColumn,
      getColumnStyle,
      updateColumnWidth,
      onColumnSorted
    };
  }

  const useScrollbar = (props, {
    mainTableRef,
    leftTableRef,
    rightTableRef,
    onMaybeEndReached
  }) => {
    const scrollPos = vue.ref({ scrollLeft: 0, scrollTop: 0 });
    function doScroll(params) {
      var _a, _b, _c;
      const { scrollTop } = params;
      (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo(params);
      (_b = leftTableRef.value) == null ? void 0 : _b.scrollToTop(scrollTop);
      (_c = rightTableRef.value) == null ? void 0 : _c.scrollToTop(scrollTop);
    }
    function scrollTo(params) {
      scrollPos.value = params;
      doScroll(params);
    }
    function scrollToTop(scrollTop) {
      scrollPos.value.scrollTop = scrollTop;
      doScroll(vue.unref(scrollPos));
    }
    function scrollToLeft(scrollLeft) {
      var _a, _b;
      scrollPos.value.scrollLeft = scrollLeft;
      (_b = (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo) == null ? void 0 : _b.call(_a, vue.unref(scrollPos));
    }
    function onScroll(params) {
      var _a;
      scrollTo(params);
      (_a = props.onScroll) == null ? void 0 : _a.call(props, params);
    }
    function onVerticalScroll({ scrollTop }) {
      const { scrollTop: currentScrollTop } = vue.unref(scrollPos);
      if (scrollTop !== currentScrollTop)
        scrollToTop(scrollTop);
    }
    function scrollToRow(row, strategy = "auto") {
      var _a;
      (_a = mainTableRef.value) == null ? void 0 : _a.scrollToRow(row, strategy);
    }
    vue.watch(() => vue.unref(scrollPos).scrollTop, (cur, prev) => {
      if (cur > prev)
        onMaybeEndReached();
    });
    return {
      scrollPos,
      scrollTo,
      scrollToLeft,
      scrollToTop,
      scrollToRow,
      onScroll,
      onVerticalScroll
    };
  };

  const useRow = (props, {
    mainTableRef,
    leftTableRef,
    rightTableRef,
    tableInstance,
    ns,
    isScrolling
  }) => {
    const vm = vue.getCurrentInstance();
    const { emit } = vm;
    const isResetting = vue.shallowRef(false);
    const expandedRowKeys = vue.ref(props.defaultExpandedRowKeys || []);
    const lastRenderedRowIndex = vue.ref(-1);
    const resetIndex = vue.shallowRef(null);
    const rowHeights = vue.ref({});
    const pendingRowHeights = vue.ref({});
    const leftTableHeights = vue.shallowRef({});
    const mainTableHeights = vue.shallowRef({});
    const rightTableHeights = vue.shallowRef({});
    const isDynamic = vue.computed(() => isNumber(props.estimatedRowHeight));
    function onRowsRendered(params) {
      var _a;
      (_a = props.onRowsRendered) == null ? void 0 : _a.call(props, params);
      if (params.rowCacheEnd > vue.unref(lastRenderedRowIndex)) {
        lastRenderedRowIndex.value = params.rowCacheEnd;
      }
    }
    function onRowHovered({ hovered, rowKey }) {
      if (isScrolling.value) {
        return;
      }
      const tableRoot = tableInstance.vnode.el;
      const rows = tableRoot.querySelectorAll(`[rowkey="${String(rowKey)}"]`);
      rows.forEach((row) => {
        if (hovered) {
          row.classList.add(ns.is("hovered"));
        } else {
          row.classList.remove(ns.is("hovered"));
        }
      });
    }
    function onRowExpanded({
      expanded,
      rowData,
      rowIndex,
      rowKey
    }) {
      var _a, _b;
      const _expandedRowKeys = [...vue.unref(expandedRowKeys)];
      const currentKeyIndex = _expandedRowKeys.indexOf(rowKey);
      if (expanded) {
        if (currentKeyIndex === -1)
          _expandedRowKeys.push(rowKey);
      } else {
        if (currentKeyIndex > -1)
          _expandedRowKeys.splice(currentKeyIndex, 1);
      }
      expandedRowKeys.value = _expandedRowKeys;
      emit("update:expandedRowKeys", _expandedRowKeys);
      (_a = props.onRowExpand) == null ? void 0 : _a.call(props, {
        expanded,
        rowData,
        rowIndex,
        rowKey
      });
      (_b = props.onExpandedRowsChange) == null ? void 0 : _b.call(props, _expandedRowKeys);
      const tableRoot = tableInstance.vnode.el;
      const hoverRow = tableRoot.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey)}"]`);
      if (hoverRow) {
        vue.nextTick(() => onRowHovered({ hovered: true, rowKey }));
      }
    }
    const flushingRowHeights = debounce(() => {
      var _a, _b, _c, _d;
      isResetting.value = true;
      rowHeights.value = { ...vue.unref(rowHeights), ...vue.unref(pendingRowHeights) };
      resetAfterIndex(vue.unref(resetIndex), false);
      pendingRowHeights.value = {};
      resetIndex.value = null;
      (_a = mainTableRef.value) == null ? void 0 : _a.forceUpdate();
      (_b = leftTableRef.value) == null ? void 0 : _b.forceUpdate();
      (_c = rightTableRef.value) == null ? void 0 : _c.forceUpdate();
      (_d = vm.proxy) == null ? void 0 : _d.$forceUpdate();
      isResetting.value = false;
    }, 0);
    function resetAfterIndex(index, forceUpdate = false) {
      if (!vue.unref(isDynamic))
        return;
      [mainTableRef, leftTableRef, rightTableRef].forEach((tableRef) => {
        const table = vue.unref(tableRef);
        if (table)
          table.resetAfterRowIndex(index, forceUpdate);
      });
    }
    function resetHeights(rowKey, height, rowIdx) {
      const resetIdx = vue.unref(resetIndex);
      if (resetIdx === null) {
        resetIndex.value = rowIdx;
      } else {
        if (resetIdx > rowIdx) {
          resetIndex.value = rowIdx;
        }
      }
      pendingRowHeights.value[rowKey] = height;
    }
    function onRowHeightChange({ rowKey, height, rowIndex }, fixedDir) {
      if (!fixedDir) {
        mainTableHeights.value[rowKey] = height;
      } else {
        if (fixedDir === FixedDir.RIGHT) {
          rightTableHeights.value[rowKey] = height;
        } else {
          leftTableHeights.value[rowKey] = height;
        }
      }
      const maximumHeight = Math.max(...[leftTableHeights, rightTableHeights, mainTableHeights].map((records) => records.value[rowKey] || 0));
      if (vue.unref(rowHeights)[rowKey] !== maximumHeight) {
        resetHeights(rowKey, maximumHeight, rowIndex);
        flushingRowHeights();
      }
    }
    return {
      expandedRowKeys,
      lastRenderedRowIndex,
      isDynamic,
      isResetting,
      rowHeights,
      resetAfterIndex,
      onRowExpanded,
      onRowHovered,
      onRowsRendered,
      onRowHeightChange
    };
  };

  const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
    const depthMap = vue.ref({});
    const flattenedData = vue.computed(() => {
      const depths = {};
      const { data: data2, rowKey } = props;
      const _expandedRowKeys = vue.unref(expandedRowKeys);
      if (!_expandedRowKeys || !_expandedRowKeys.length)
        return data2;
      const array = [];
      const keysSet = /* @__PURE__ */ new Set();
      _expandedRowKeys.forEach((x) => keysSet.add(x));
      let copy = data2.slice();
      copy.forEach((x) => depths[x[rowKey]] = 0);
      while (copy.length > 0) {
        const item = copy.shift();
        array.push(item);
        if (keysSet.has(item[rowKey]) && isArray$1(item.children) && item.children.length > 0) {
          copy = [...item.children, ...copy];
          item.children.forEach((child) => depths[child[rowKey]] = depths[item[rowKey]] + 1);
        }
      }
      depthMap.value = depths;
      return array;
    });
    const data = vue.computed(() => {
      const { data: data2, expandColumnKey } = props;
      return expandColumnKey ? vue.unref(flattenedData) : data2;
    });
    vue.watch(data, (val, prev) => {
      if (val !== prev) {
        lastRenderedRowIndex.value = -1;
        resetAfterIndex(0, true);
      }
    });
    return {
      data,
      depthMap
    };
  };

  const sumReducer = (sum2, num) => sum2 + num;
  const sum = (listLike) => {
    return isArray$1(listLike) ? listLike.reduce(sumReducer, 0) : listLike;
  };
  const tryCall = (fLike, params, defaultRet = {}) => {
    return isFunction$1(fLike) ? fLike(params) : fLike != null ? fLike : defaultRet;
  };
  const enforceUnit = (style) => {
    ["width", "maxWidth", "minWidth", "height"].forEach((key) => {
      style[key] = addUnit(style[key]);
    });
    return style;
  };
  const componentToSlot = (ComponentLike) => vue.isVNode(ComponentLike) ? (props) => vue.h(ComponentLike, props) : ComponentLike;

  const useStyles = (props, {
    columnsTotalWidth,
    rowsHeight,
    fixedColumnsOnLeft,
    fixedColumnsOnRight
  }) => {
    const bodyWidth = vue.computed(() => {
      const { fixed, width, vScrollbarSize } = props;
      const ret = width - vScrollbarSize;
      return fixed ? Math.max(Math.round(vue.unref(columnsTotalWidth)), ret) : ret;
    });
    const mainTableHeight = vue.computed(() => {
      const { height = 0, maxHeight = 0, footerHeight: footerHeight2, hScrollbarSize } = props;
      if (maxHeight > 0) {
        const _fixedRowsHeight = vue.unref(fixedRowsHeight);
        const _rowsHeight = vue.unref(rowsHeight);
        const _headerHeight = vue.unref(headerHeight);
        const total = _headerHeight + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
        return Math.min(total, maxHeight - footerHeight2);
      }
      return height - footerHeight2;
    });
    const fixedTableHeight = vue.computed(() => {
      const { maxHeight } = props;
      const tableHeight = vue.unref(mainTableHeight);
      if (isNumber(maxHeight) && maxHeight > 0)
        return tableHeight;
      const totalHeight = vue.unref(rowsHeight) + vue.unref(headerHeight) + vue.unref(fixedRowsHeight);
      return Math.min(tableHeight, totalHeight);
    });
    const mapColumn = (column) => column.width;
    const leftTableWidth = vue.computed(() => sum(vue.unref(fixedColumnsOnLeft).map(mapColumn)));
    const rightTableWidth = vue.computed(() => sum(vue.unref(fixedColumnsOnRight).map(mapColumn)));
    const headerHeight = vue.computed(() => sum(props.headerHeight));
    const fixedRowsHeight = vue.computed(() => {
      var _a;
      return (((_a = props.fixedData) == null ? void 0 : _a.length) || 0) * props.rowHeight;
    });
    const windowHeight = vue.computed(() => {
      return vue.unref(mainTableHeight) - vue.unref(headerHeight) - vue.unref(fixedRowsHeight);
    });
    const rootStyle = vue.computed(() => {
      const { style = {}, height, width } = props;
      return enforceUnit({
        ...style,
        height,
        width
      });
    });
    const footerHeight = vue.computed(() => enforceUnit({ height: props.footerHeight }));
    const emptyStyle = vue.computed(() => ({
      top: addUnit(vue.unref(headerHeight)),
      bottom: addUnit(props.footerHeight),
      width: addUnit(props.width)
    }));
    return {
      bodyWidth,
      fixedTableHeight,
      mainTableHeight,
      leftTableWidth,
      rightTableWidth,
      windowHeight,
      footerHeight,
      emptyStyle,
      rootStyle,
      headerHeight
    };
  };

  const useAutoResize = (props) => {
    const sizer = vue.ref();
    const width$ = vue.ref(0);
    const height$ = vue.ref(0);
    let resizerStopper;
    vue.onMounted(() => {
      resizerStopper = useResizeObserver(sizer, ([entry]) => {
        const { width, height } = entry.contentRect;
        const { paddingLeft, paddingRight, paddingTop, paddingBottom } = getComputedStyle(entry.target);
        const left = Number.parseInt(paddingLeft) || 0;
        const right = Number.parseInt(paddingRight) || 0;
        const top = Number.parseInt(paddingTop) || 0;
        const bottom = Number.parseInt(paddingBottom) || 0;
        width$.value = width - left - right;
        height$.value = height - top - bottom;
      }).stop;
    });
    vue.onBeforeUnmount(() => {
      resizerStopper == null ? void 0 : resizerStopper();
    });
    vue.watch([width$, height$], ([width, height]) => {
      var _a;
      (_a = props.onResize) == null ? void 0 : _a.call(props, {
        width,
        height
      });
    });
    return {
      sizer,
      width: width$,
      height: height$
    };
  };

  function useTable(props) {
    const mainTableRef = vue.ref();
    const leftTableRef = vue.ref();
    const rightTableRef = vue.ref();
    const {
      columns,
      columnsStyles,
      columnsTotalWidth,
      fixedColumnsOnLeft,
      fixedColumnsOnRight,
      hasFixedColumns,
      mainColumns,
      onColumnSorted
    } = useColumns(props, vue.toRef(props, "columns"), vue.toRef(props, "fixed"));
    const {
      scrollTo,
      scrollToLeft,
      scrollToTop,
      scrollToRow,
      onScroll,
      onVerticalScroll,
      scrollPos
    } = useScrollbar(props, {
      mainTableRef,
      leftTableRef,
      rightTableRef,
      onMaybeEndReached
    });
    const ns = useNamespace("table-v2");
    const instance = vue.getCurrentInstance();
    const isScrolling = vue.shallowRef(false);
    const {
      expandedRowKeys,
      lastRenderedRowIndex,
      isDynamic,
      isResetting,
      rowHeights,
      resetAfterIndex,
      onRowExpanded,
      onRowHeightChange,
      onRowHovered,
      onRowsRendered
    } = useRow(props, {
      mainTableRef,
      leftTableRef,
      rightTableRef,
      tableInstance: instance,
      ns,
      isScrolling
    });
    const { data, depthMap } = useData(props, {
      expandedRowKeys,
      lastRenderedRowIndex,
      resetAfterIndex
    });
    const rowsHeight = vue.computed(() => {
      const { estimatedRowHeight, rowHeight } = props;
      const _data = vue.unref(data);
      if (isNumber(estimatedRowHeight)) {
        return Object.values(vue.unref(rowHeights)).reduce((acc, curr) => acc + curr, 0);
      }
      return _data.length * rowHeight;
    });
    const {
      bodyWidth,
      fixedTableHeight,
      mainTableHeight,
      leftTableWidth,
      rightTableWidth,
      windowHeight,
      footerHeight,
      emptyStyle,
      rootStyle,
      headerHeight
    } = useStyles(props, {
      columnsTotalWidth,
      fixedColumnsOnLeft,
      fixedColumnsOnRight,
      rowsHeight
    });
    const containerRef = vue.ref();
    const showEmpty = vue.computed(() => {
      const noData = vue.unref(data).length === 0;
      return isArray$1(props.fixedData) ? props.fixedData.length === 0 && noData : noData;
    });
    function getRowHeight(rowIndex) {
      const { estimatedRowHeight, rowHeight, rowKey } = props;
      if (!estimatedRowHeight)
        return rowHeight;
      return vue.unref(rowHeights)[vue.unref(data)[rowIndex][rowKey]] || estimatedRowHeight;
    }
    const isEndReached = vue.ref(false);
    function onMaybeEndReached() {
      const { onEndReached } = props;
      if (!onEndReached)
        return;
      const { scrollTop } = vue.unref(scrollPos);
      const _totalHeight = vue.unref(rowsHeight);
      const clientHeight = vue.unref(windowHeight);
      const remainDistance = _totalHeight - (scrollTop + clientHeight) + props.hScrollbarSize;
      if (!isEndReached.value && vue.unref(lastRenderedRowIndex) >= 0 && _totalHeight <= scrollTop + vue.unref(mainTableHeight) - vue.unref(headerHeight)) {
        isEndReached.value = true;
        onEndReached(remainDistance);
      } else {
        isEndReached.value = false;
      }
    }
    vue.watch(() => vue.unref(rowsHeight), () => isEndReached.value = false);
    vue.watch(() => props.expandedRowKeys, (val) => expandedRowKeys.value = val, {
      deep: true
    });
    return {
      columns,
      containerRef,
      mainTableRef,
      leftTableRef,
      rightTableRef,
      isDynamic,
      isResetting,
      isScrolling,
      hasFixedColumns,
      columnsStyles,
      columnsTotalWidth,
      data,
      expandedRowKeys,
      depthMap,
      fixedColumnsOnLeft,
      fixedColumnsOnRight,
      mainColumns,
      bodyWidth,
      emptyStyle,
      rootStyle,
      footerHeight,
      mainTableHeight,
      fixedTableHeight,
      leftTableWidth,
      rightTableWidth,
      showEmpty,
      getRowHeight,
      onColumnSorted,
      onRowHovered,
      onRowExpanded,
      onRowsRendered,
      onRowHeightChange,
      scrollTo,
      scrollToLeft,
      scrollToTop,
      scrollToRow,
      onScroll,
      onVerticalScroll
    };
  }

  const TableV2InjectionKey = Symbol("tableV2");
  const TABLE_V2_GRID_INJECTION_KEY = "tableV2GridScrollLeft";

  const classType = String;
  const columns = {
    type: definePropType(Array),
    required: true
  };
  const fixedDataType = {
    type: definePropType(Array)
  };
  const dataType = {
    ...fixedDataType,
    required: true
  };
  const expandColumnKey = String;
  const expandKeys = {
    type: definePropType(Array),
    default: () => mutable([])
  };
  const requiredNumber = {
    type: Number,
    required: true
  };
  const rowKey = {
    type: definePropType([String, Number, Symbol]),
    default: "id"
  };
  const styleType = {
    type: definePropType(Object)
  };

  const tableV2RowProps = buildProps({
    class: String,
    columns,
    columnsStyles: {
      type: definePropType(Object),
      required: true
    },
    depth: Number,
    expandColumnKey,
    estimatedRowHeight: {
      ...virtualizedGridProps.estimatedRowHeight,
      default: void 0
    },
    isScrolling: Boolean,
    onRowExpand: {
      type: definePropType(Function)
    },
    onRowHover: {
      type: definePropType(Function)
    },
    onRowHeightChange: {
      type: definePropType(Function)
    },
    rowData: {
      type: definePropType(Object),
      required: true
    },
    rowEventHandlers: {
      type: definePropType(Object)
    },
    rowIndex: {
      type: Number,
      required: true
    },
    rowKey,
    style: {
      type: definePropType(Object)
    }
  });

  const requiredNumberType = {
    type: Number,
    required: true
  };
  const tableV2HeaderProps = buildProps({
    class: String,
    columns,
    fixedHeaderData: {
      type: definePropType(Array)
    },
    headerData: {
      type: definePropType(Array),
      required: true
    },
    headerHeight: {
      type: definePropType([Number, Array]),
      default: 50
    },
    rowWidth: requiredNumberType,
    rowHeight: {
      type: Number,
      default: 50
    },
    height: requiredNumberType,
    width: requiredNumberType
  });

  const tableV2GridProps = buildProps({
    columns,
    data: dataType,
    fixedData: fixedDataType,
    estimatedRowHeight: tableV2RowProps.estimatedRowHeight,
    width: requiredNumber,
    height: requiredNumber,
    headerWidth: requiredNumber,
    headerHeight: tableV2HeaderProps.headerHeight,
    bodyWidth: requiredNumber,
    rowHeight: requiredNumber,
    cache: virtualizedListProps.cache,
    useIsScrolling: Boolean,
    scrollbarAlwaysOn: virtualizedGridProps.scrollbarAlwaysOn,
    scrollbarStartGap: virtualizedGridProps.scrollbarStartGap,
    scrollbarEndGap: virtualizedGridProps.scrollbarEndGap,
    class: classType,
    style: styleType,
    containerStyle: styleType,
    getRowHeight: {
      type: definePropType(Function),
      required: true
    },
    rowKey: tableV2RowProps.rowKey,
    onRowsRendered: {
      type: definePropType(Function)
    },
    onScroll: {
      type: definePropType(Function)
    }
  });

  const tableV2Props = buildProps({
    cache: tableV2GridProps.cache,
    estimatedRowHeight: tableV2RowProps.estimatedRowHeight,
    rowKey,
    headerClass: {
      type: definePropType([
        String,
        Function
      ])
    },
    headerProps: {
      type: definePropType([
        Object,
        Function
      ])
    },
    headerCellProps: {
      type: definePropType([
        Object,
        Function
      ])
    },
    headerHeight: tableV2HeaderProps.headerHeight,
    footerHeight: {
      type: Number,
      default: 0
    },
    rowClass: {
      type: definePropType([String, Function])
    },
    rowProps: {
      type: definePropType([Object, Function])
    },
    rowHeight: {
      type: Number,
      default: 50
    },
    cellProps: {
      type: definePropType([
        Object,
        Function
      ])
    },
    columns,
    data: dataType,
    dataGetter: {
      type: definePropType(Function)
    },
    fixedData: fixedDataType,
    expandColumnKey: tableV2RowProps.expandColumnKey,
    expandedRowKeys: expandKeys,
    defaultExpandedRowKeys: expandKeys,
    class: classType,
    fixed: Boolean,
    style: {
      type: definePropType(Object)
    },
    width: requiredNumber,
    height: requiredNumber,
    maxHeight: Number,
    useIsScrolling: Boolean,
    indentSize: {
      type: Number,
      default: 12
    },
    iconSize: {
      type: Number,
      default: 12
    },
    hScrollbarSize: virtualizedGridProps.hScrollbarSize,
    vScrollbarSize: virtualizedGridProps.vScrollbarSize,
    scrollbarAlwaysOn: virtualizedScrollbarProps.alwaysOn,
    sortBy: {
      type: definePropType(Object),
      default: () => ({})
    },
    sortState: {
      type: definePropType(Object),
      default: void 0
    },
    onColumnSort: {
      type: definePropType(Function)
    },
    onExpandedRowsChange: {
      type: definePropType(Function)
    },
    onEndReached: {
      type: definePropType(Function)
    },
    onRowExpand: tableV2RowProps.onRowExpand,
    onScroll: tableV2GridProps.onScroll,
    onRowsRendered: tableV2GridProps.onRowsRendered,
    rowEventHandlers: tableV2RowProps.rowEventHandlers
  });

  const TableV2Cell = (props, {
    slots
  }) => {
    var _a;
    const {
      cellData,
      style
    } = props;
    const displayText = ((_a = cellData == null ? void 0 : cellData.toString) == null ? void 0 : _a.call(cellData)) || "";
    const defaultSlot = vue.renderSlot(slots, "default", props, () => [displayText]);
    return vue.createVNode("div", {
      "class": props.class,
      "title": displayText,
      "style": style
    }, [defaultSlot]);
  };
  TableV2Cell.displayName = "ElTableV2Cell";
  TableV2Cell.inheritAttrs = false;
  var TableCell = TableV2Cell;

  const HeaderCell = (props, {
    slots
  }) => vue.renderSlot(slots, "default", props, () => {
    var _a, _b;
    return [vue.createVNode("div", {
      "class": props.class,
      "title": (_a = props.column) == null ? void 0 : _a.title
    }, [(_b = props.column) == null ? void 0 : _b.title])];
  });
  HeaderCell.displayName = "ElTableV2HeaderCell";
  HeaderCell.inheritAttrs = false;
  var HeaderCell$1 = HeaderCell;

  const tableV2HeaderRowProps = buildProps({
    class: String,
    columns,
    columnsStyles: {
      type: definePropType(Object),
      required: true
    },
    headerIndex: Number,
    style: { type: definePropType(Object) }
  });

  const TableV2HeaderRow = vue.defineComponent({
    name: "ElTableV2HeaderRow",
    props: tableV2HeaderRowProps,
    setup(props, {
      slots
    }) {
      return () => {
        const {
          columns,
          columnsStyles,
          headerIndex,
          style
        } = props;
        let Cells = columns.map((column, columnIndex) => {
          return slots.cell({
            columns,
            column,
            columnIndex,
            headerIndex,
            style: columnsStyles[column.key]
          });
        });
        if (slots.header) {
          Cells = slots.header({
            cells: Cells.map((node) => {
              if (isArray$1(node) && node.length === 1) {
                return node[0];
              }
              return node;
            }),
            columns,
            headerIndex
          });
        }
        return vue.createVNode("div", {
          "class": props.class,
          "style": style,
          "role": "row"
        }, [Cells]);
      };
    }
  });
  var HeaderRow = TableV2HeaderRow;

  const COMPONENT_NAME$8 = "ElTableV2Header";
  const TableV2Header = vue.defineComponent({
    name: COMPONENT_NAME$8,
    props: tableV2HeaderProps,
    setup(props, {
      slots,
      expose
    }) {
      const ns = useNamespace("table-v2");
      const scrollLeftInfo = vue.inject(TABLE_V2_GRID_INJECTION_KEY);
      const headerRef = vue.ref();
      const headerStyle = vue.computed(() => enforceUnit({
        width: props.width,
        height: props.height
      }));
      const rowStyle = vue.computed(() => enforceUnit({
        width: props.rowWidth,
        height: props.height
      }));
      const headerHeights = vue.computed(() => castArray$1(vue.unref(props.headerHeight)));
      const scrollToLeft = (left) => {
        const headerEl = vue.unref(headerRef);
        vue.nextTick(() => {
          (headerEl == null ? void 0 : headerEl.scroll) && headerEl.scroll({
            left
          });
        });
      };
      const renderFixedRows = () => {
        const fixedRowClassName = ns.e("fixed-header-row");
        const {
          columns,
          fixedHeaderData,
          rowHeight
        } = props;
        return fixedHeaderData == null ? void 0 : fixedHeaderData.map((fixedRowData, fixedRowIndex) => {
          var _a;
          const style = enforceUnit({
            height: rowHeight,
            width: "100%"
          });
          return (_a = slots.fixed) == null ? void 0 : _a.call(slots, {
            class: fixedRowClassName,
            columns,
            rowData: fixedRowData,
            rowIndex: -(fixedRowIndex + 1),
            style
          });
        });
      };
      const renderDynamicRows = () => {
        const dynamicRowClassName = ns.e("dynamic-header-row");
        const {
          columns
        } = props;
        return vue.unref(headerHeights).map((rowHeight, rowIndex) => {
          var _a;
          const style = enforceUnit({
            width: "100%",
            height: rowHeight
          });
          return (_a = slots.dynamic) == null ? void 0 : _a.call(slots, {
            class: dynamicRowClassName,
            columns,
            headerIndex: rowIndex,
            style
          });
        });
      };
      vue.onUpdated(() => {
        if (scrollLeftInfo == null ? void 0 : scrollLeftInfo.value) {
          scrollToLeft(scrollLeftInfo.value);
        }
      });
      expose({
        scrollToLeft
      });
      return () => {
        if (props.height <= 0)
          return;
        return vue.createVNode("div", {
          "ref": headerRef,
          "class": props.class,
          "style": vue.unref(headerStyle),
          "role": "rowgroup"
        }, [vue.createVNode("div", {
          "style": vue.unref(rowStyle),
          "class": ns.e("header")
        }, [renderDynamicRows(), renderFixedRows()])]);
      };
    }
  });
  var Header = TableV2Header;

  const useTableRow = (props) => {
    const {
      isScrolling
    } = vue.inject(TableV2InjectionKey);
    const measured = vue.ref(false);
    const rowRef = vue.ref();
    const measurable = vue.computed(() => {
      return isNumber(props.estimatedRowHeight) && props.rowIndex >= 0;
    });
    const doMeasure = (isInit = false) => {
      const $rowRef = vue.unref(rowRef);
      if (!$rowRef)
        return;
      const {
        columns,
        onRowHeightChange,
        rowKey,
        rowIndex,
        style
      } = props;
      const {
        height
      } = $rowRef.getBoundingClientRect();
      measured.value = true;
      vue.nextTick(() => {
        if (isInit || height !== Number.parseInt(style.height)) {
          const firstColumn = columns[0];
          const isPlaceholder = (firstColumn == null ? void 0 : firstColumn.placeholderSign) === placeholderSign;
          onRowHeightChange == null ? void 0 : onRowHeightChange({
            rowKey,
            height,
            rowIndex
          }, firstColumn && !isPlaceholder && firstColumn.fixed);
        }
      });
    };
    const eventHandlers = vue.computed(() => {
      const {
        rowData,
        rowIndex,
        rowKey,
        onRowHover
      } = props;
      const handlers = props.rowEventHandlers || {};
      const eventHandlers2 = {};
      Object.entries(handlers).forEach(([eventName, handler]) => {
        if (isFunction$1(handler)) {
          eventHandlers2[eventName] = (event) => {
            handler({
              event,
              rowData,
              rowIndex,
              rowKey
            });
          };
        }
      });
      if (onRowHover) {
        [{
          name: "onMouseleave",
          hovered: false
        }, {
          name: "onMouseenter",
          hovered: true
        }].forEach(({
          name,
          hovered
        }) => {
          const existedHandler = eventHandlers2[name];
          eventHandlers2[name] = (event) => {
            onRowHover({
              event,
              hovered,
              rowData,
              rowIndex,
              rowKey
            });
            existedHandler == null ? void 0 : existedHandler(event);
          };
        });
      }
      return eventHandlers2;
    });
    const onExpand = (expanded) => {
      const {
        onRowExpand,
        rowData,
        rowIndex,
        rowKey
      } = props;
      onRowExpand == null ? void 0 : onRowExpand({
        expanded,
        rowData,
        rowIndex,
        rowKey
      });
    };
    vue.onMounted(() => {
      if (vue.unref(measurable)) {
        doMeasure(true);
      }
    });
    return {
      isScrolling,
      measurable,
      measured,
      rowRef,
      eventHandlers,
      onExpand
    };
  };
  const COMPONENT_NAME$7 = "ElTableV2TableRow";
  const TableV2Row = vue.defineComponent({
    name: COMPONENT_NAME$7,
    props: tableV2RowProps,
    setup(props, {
      expose,
      slots,
      attrs
    }) {
      const {
        eventHandlers,
        isScrolling,
        measurable,
        measured,
        rowRef,
        onExpand
      } = useTableRow(props);
      expose({
        onExpand
      });
      return () => {
        const {
          columns,
          columnsStyles,
          expandColumnKey,
          depth,
          rowData,
          rowIndex,
          style
        } = props;
        let ColumnCells = columns.map((column, columnIndex) => {
          const expandable = isArray$1(rowData.children) && rowData.children.length > 0 && column.key === expandColumnKey;
          return slots.cell({
            column,
            columns,
            columnIndex,
            depth,
            style: columnsStyles[column.key],
            rowData,
            rowIndex,
            isScrolling: vue.unref(isScrolling),
            expandIconProps: expandable ? {
              rowData,
              rowIndex,
              onExpand
            } : void 0
          });
        });
        if (slots.row) {
          ColumnCells = slots.row({
            cells: ColumnCells.map((node) => {
              if (isArray$1(node) && node.length === 1) {
                return node[0];
              }
              return node;
            }),
            style,
            columns,
            depth,
            rowData,
            rowIndex,
            isScrolling: vue.unref(isScrolling)
          });
        }
        if (vue.unref(measurable)) {
          const {
            height,
            ...exceptHeightStyle
          } = style || {};
          const _measured = vue.unref(measured);
          return vue.createVNode("div", vue.mergeProps({
            "ref": rowRef,
            "class": props.class,
            "style": _measured ? style : exceptHeightStyle,
            "role": "row"
          }, attrs, vue.unref(eventHandlers)), [ColumnCells]);
        }
        return vue.createVNode("div", vue.mergeProps(attrs, {
          "ref": rowRef,
          "class": props.class,
          "style": style,
          "role": "row"
        }, vue.unref(eventHandlers)), [ColumnCells]);
      };
    }
  });
  var Row = TableV2Row;

  const SortIcon = (props) => {
    const {
      sortOrder
    } = props;
    return vue.createVNode(ElIcon, {
      "size": 14,
      "class": props.class
    }, {
      default: () => [sortOrder === SortOrder.ASC ? vue.createVNode(sort_up_default, null, null) : vue.createVNode(sort_down_default, null, null)]
    });
  };
  var SortIcon$1 = SortIcon;

  const ExpandIcon = (props) => {
    const {
      expanded,
      expandable,
      onExpand,
      style,
      size
    } = props;
    const expandIconProps = {
      onClick: expandable ? () => onExpand(!expanded) : void 0,
      class: props.class
    };
    return vue.createVNode(ElIcon, vue.mergeProps(expandIconProps, {
      "size": size,
      "style": style
    }), {
      default: () => [vue.createVNode(arrow_right_default, null, null)]
    });
  };
  var ExpandIcon$1 = ExpandIcon;

  const COMPONENT_NAME$6 = "ElTableV2Grid";
  const useTableGrid = (props) => {
    const headerRef = vue.ref();
    const bodyRef = vue.ref();
    const scrollLeft = vue.ref(0);
    const totalHeight = vue.computed(() => {
      const {
        data,
        rowHeight,
        estimatedRowHeight
      } = props;
      if (estimatedRowHeight) {
        return;
      }
      return data.length * rowHeight;
    });
    const fixedRowHeight = vue.computed(() => {
      const {
        fixedData,
        rowHeight
      } = props;
      return ((fixedData == null ? void 0 : fixedData.length) || 0) * rowHeight;
    });
    const headerHeight = vue.computed(() => sum(props.headerHeight));
    const gridHeight = vue.computed(() => {
      const {
        height
      } = props;
      return Math.max(0, height - vue.unref(headerHeight) - vue.unref(fixedRowHeight));
    });
    const hasHeader = vue.computed(() => {
      return vue.unref(headerHeight) + vue.unref(fixedRowHeight) > 0;
    });
    const itemKey = ({
      data,
      rowIndex
    }) => data[rowIndex][props.rowKey];
    function onItemRendered({
      rowCacheStart,
      rowCacheEnd,
      rowVisibleStart,
      rowVisibleEnd
    }) {
      var _a;
      (_a = props.onRowsRendered) == null ? void 0 : _a.call(props, {
        rowCacheStart,
        rowCacheEnd,
        rowVisibleStart,
        rowVisibleEnd
      });
    }
    function resetAfterRowIndex(index, forceUpdate2) {
      var _a;
      (_a = bodyRef.value) == null ? void 0 : _a.resetAfterRowIndex(index, forceUpdate2);
    }
    function scrollTo(leftOrOptions, top) {
      const header$ = vue.unref(headerRef);
      const body$ = vue.unref(bodyRef);
      if (isObject$1(leftOrOptions)) {
        header$ == null ? void 0 : header$.scrollToLeft(leftOrOptions.scrollLeft);
        scrollLeft.value = leftOrOptions.scrollLeft;
        body$ == null ? void 0 : body$.scrollTo(leftOrOptions);
      } else {
        header$ == null ? void 0 : header$.scrollToLeft(leftOrOptions);
        scrollLeft.value = leftOrOptions;
        body$ == null ? void 0 : body$.scrollTo({
          scrollLeft: leftOrOptions,
          scrollTop: top
        });
      }
    }
    function scrollToTop(scrollTop) {
      var _a;
      (_a = vue.unref(bodyRef)) == null ? void 0 : _a.scrollTo({
        scrollTop
      });
    }
    function scrollToRow(row, strategy) {
      var _a;
      (_a = vue.unref(bodyRef)) == null ? void 0 : _a.scrollToItem(row, 1, strategy);
    }
    function forceUpdate() {
      var _a, _b;
      (_a = vue.unref(bodyRef)) == null ? void 0 : _a.$forceUpdate();
      (_b = vue.unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
    }
    vue.watch(() => props.bodyWidth, () => {
      var _a;
      if (isNumber(props.estimatedRowHeight))
        (_a = bodyRef.value) == null ? void 0 : _a.resetAfter({
          columnIndex: 0
        }, false);
    });
    return {
      bodyRef,
      forceUpdate,
      fixedRowHeight,
      gridHeight,
      hasHeader,
      headerHeight,
      headerRef,
      totalHeight,
      itemKey,
      onItemRendered,
      resetAfterRowIndex,
      scrollTo,
      scrollToTop,
      scrollToRow,
      scrollLeft
    };
  };
  const TableGrid = vue.defineComponent({
    name: COMPONENT_NAME$6,
    props: tableV2GridProps,
    setup(props, {
      slots,
      expose
    }) {
      const {
        ns
      } = vue.inject(TableV2InjectionKey);
      const {
        bodyRef,
        fixedRowHeight,
        gridHeight,
        hasHeader,
        headerRef,
        headerHeight,
        totalHeight,
        forceUpdate,
        itemKey,
        onItemRendered,
        resetAfterRowIndex,
        scrollTo,
        scrollToTop,
        scrollToRow,
        scrollLeft
      } = useTableGrid(props);
      vue.provide(TABLE_V2_GRID_INJECTION_KEY, scrollLeft);
      vue.onActivated(async () => {
        var _a;
        await vue.nextTick();
        const scrollTop = (_a = bodyRef.value) == null ? void 0 : _a.states.scrollTop;
        scrollTop && scrollToTop(Math.round(scrollTop) + 1);
      });
      expose({
        forceUpdate,
        totalHeight,
        scrollTo,
        scrollToTop,
        scrollToRow,
        resetAfterRowIndex
      });
      const getColumnWidth = () => props.bodyWidth;
      return () => {
        const {
          cache,
          columns,
          data,
          fixedData,
          useIsScrolling,
          scrollbarAlwaysOn,
          scrollbarEndGap,
          scrollbarStartGap,
          style,
          rowHeight,
          bodyWidth,
          estimatedRowHeight,
          headerWidth,
          height,
          width,
          getRowHeight,
          onScroll
        } = props;
        const isDynamicRowEnabled = isNumber(estimatedRowHeight);
        const Grid = isDynamicRowEnabled ? DynamicSizeGrid$1 : FixedSizeGrid$1;
        const _headerHeight = vue.unref(headerHeight);
        return vue.createVNode("div", {
          "role": "table",
          "class": [ns.e("table"), props.class],
          "style": style
        }, [vue.createVNode(Grid, {
          "ref": bodyRef,
          "data": data,
          "useIsScrolling": useIsScrolling,
          "itemKey": itemKey,
          "columnCache": 0,
          "columnWidth": isDynamicRowEnabled ? getColumnWidth : bodyWidth,
          "totalColumn": 1,
          "totalRow": data.length,
          "rowCache": cache,
          "rowHeight": isDynamicRowEnabled ? getRowHeight : rowHeight,
          "width": width,
          "height": vue.unref(gridHeight),
          "class": ns.e("body"),
          "role": "rowgroup",
          "scrollbarStartGap": scrollbarStartGap,
          "scrollbarEndGap": scrollbarEndGap,
          "scrollbarAlwaysOn": scrollbarAlwaysOn,
          "onScroll": onScroll,
          "onItemRendered": onItemRendered,
          "perfMode": false
        }, {
          default: (params) => {
            var _a;
            const rowData = data[params.rowIndex];
            return (_a = slots.row) == null ? void 0 : _a.call(slots, {
              ...params,
              columns,
              rowData
            });
          }
        }), vue.unref(hasHeader) && vue.createVNode(Header, {
          "ref": headerRef,
          "class": ns.e("header-wrapper"),
          "columns": columns,
          "headerData": data,
          "headerHeight": props.headerHeight,
          "fixedHeaderData": fixedData,
          "rowWidth": headerWidth,
          "rowHeight": rowHeight,
          "width": width,
          "height": Math.min(_headerHeight + vue.unref(fixedRowHeight), height)
        }, {
          dynamic: slots.header,
          fixed: slots.row
        })]);
      };
    }
  });

  function _isSlot$5(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  const MainTable = (props, {
    slots
  }) => {
    const {
      mainTableRef,
      ...rest
    } = props;
    return vue.createVNode(TableGrid, vue.mergeProps({
      "ref": mainTableRef
    }, rest), _isSlot$5(slots) ? slots : {
      default: () => [slots]
    });
  };

  function _isSlot$4(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  const LeftTable = (props, {
    slots
  }) => {
    if (!props.columns.length)
      return;
    const {
      leftTableRef,
      ...rest
    } = props;
    return vue.createVNode(TableGrid, vue.mergeProps({
      "ref": leftTableRef
    }, rest), _isSlot$4(slots) ? slots : {
      default: () => [slots]
    });
  };

  function _isSlot$3(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  const RightTable = (props, {
    slots
  }) => {
    if (!props.columns.length)
      return;
    const {
      rightTableRef,
      ...rest
    } = props;
    return vue.createVNode(TableGrid, vue.mergeProps({
      "ref": rightTableRef
    }, rest), _isSlot$3(slots) ? slots : {
      default: () => [slots]
    });
  };

  function _isSlot$2(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  const RowRenderer = (props, {
    slots
  }) => {
    const {
      columns,
      columnsStyles,
      depthMap,
      expandColumnKey,
      expandedRowKeys,
      estimatedRowHeight,
      hasFixedColumns,
      rowData,
      rowIndex,
      style,
      isScrolling,
      rowProps,
      rowClass,
      rowKey,
      rowEventHandlers,
      ns,
      onRowHovered,
      onRowExpanded
    } = props;
    const rowKls = tryCall(rowClass, {
      columns,
      rowData,
      rowIndex
    }, "");
    const additionalProps = tryCall(rowProps, {
      columns,
      rowData,
      rowIndex
    });
    const _rowKey = rowData[rowKey];
    const depth = depthMap[_rowKey] || 0;
    const canExpand = Boolean(expandColumnKey);
    const isFixedRow = rowIndex < 0;
    const kls = [ns.e("row"), rowKls, ns.is("expanded", canExpand && expandedRowKeys.includes(_rowKey)), ns.is("fixed", !depth && isFixedRow), ns.is("customized", Boolean(slots.row)), {
      [ns.e(`row-depth-${depth}`)]: canExpand && rowIndex >= 0
    }];
    const onRowHover = hasFixedColumns ? onRowHovered : void 0;
    const _rowProps = {
      ...additionalProps,
      columns,
      columnsStyles,
      class: kls,
      depth,
      expandColumnKey,
      estimatedRowHeight: isFixedRow ? void 0 : estimatedRowHeight,
      isScrolling,
      rowIndex,
      rowData,
      rowKey: _rowKey,
      rowEventHandlers,
      style
    };
    const handlerMouseEnter = (e) => {
      onRowHover == null ? void 0 : onRowHover({
        hovered: true,
        rowKey: _rowKey,
        event: e,
        rowData,
        rowIndex
      });
    };
    const handlerMouseLeave = (e) => {
      onRowHover == null ? void 0 : onRowHover({
        hovered: false,
        rowKey: _rowKey,
        event: e,
        rowData,
        rowIndex
      });
    };
    return vue.createVNode(Row, vue.mergeProps(_rowProps, {
      "onRowExpand": onRowExpanded,
      "onMouseenter": handlerMouseEnter,
      "onMouseleave": handlerMouseLeave,
      "rowkey": _rowKey
    }), _isSlot$2(slots) ? slots : {
      default: () => [slots]
    });
  };

  const CellRenderer = ({
    columns,
    column,
    columnIndex,
    depth,
    expandIconProps,
    isScrolling,
    rowData,
    rowIndex,
    style,
    expandedRowKeys,
    ns,
    cellProps: _cellProps,
    expandColumnKey,
    indentSize,
    iconSize,
    rowKey
  }, {
    slots
  }) => {
    const cellStyle = enforceUnit(style);
    if (column.placeholderSign === placeholderSign) {
      return vue.createVNode("div", {
        "class": ns.em("row-cell", "placeholder"),
        "style": cellStyle
      }, null);
    }
    const {
      cellRenderer,
      dataKey,
      dataGetter
    } = column;
    const cellData = isFunction$1(dataGetter) ? dataGetter({
      columns,
      column,
      columnIndex,
      rowData,
      rowIndex
    }) : get(rowData, dataKey != null ? dataKey : "");
    const extraCellProps = tryCall(_cellProps, {
      cellData,
      columns,
      column,
      columnIndex,
      rowIndex,
      rowData
    });
    const cellProps = {
      class: ns.e("cell-text"),
      columns,
      column,
      columnIndex,
      cellData,
      isScrolling,
      rowData,
      rowIndex
    };
    const columnCellRenderer = componentToSlot(cellRenderer);
    const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : vue.renderSlot(slots, "default", cellProps, () => [vue.createVNode(TableCell, cellProps, null)]);
    const kls = [ns.e("row-cell"), column.class, column.align === Alignment.CENTER && ns.is("align-center"), column.align === Alignment.RIGHT && ns.is("align-right")];
    const expandable = rowIndex >= 0 && expandColumnKey && column.key === expandColumnKey;
    const expanded = rowIndex >= 0 && expandedRowKeys.includes(rowData[rowKey]);
    let IconOrPlaceholder;
    const iconStyle = `margin-inline-start: ${depth * indentSize}px;`;
    if (expandable) {
      if (isObject$1(expandIconProps)) {
        IconOrPlaceholder = vue.createVNode(ExpandIcon$1, vue.mergeProps(expandIconProps, {
          "class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
          "size": iconSize,
          "expanded": expanded,
          "style": iconStyle,
          "expandable": true
        }), null);
      } else {
        IconOrPlaceholder = vue.createVNode("div", {
          "style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ")
        }, null);
      }
    }
    return vue.createVNode("div", vue.mergeProps({
      "class": kls,
      "style": cellStyle
    }, extraCellProps, {
      "role": "cell"
    }), [IconOrPlaceholder, Cell]);
  };
  CellRenderer.inheritAttrs = false;

  function _isSlot$1(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  const HeaderRenderer = ({
    columns,
    columnsStyles,
    headerIndex,
    style,
    headerClass,
    headerProps,
    ns
  }, {
    slots
  }) => {
    const param = {
      columns,
      headerIndex
    };
    const kls = [ns.e("header-row"), tryCall(headerClass, param, ""), ns.is("customized", Boolean(slots.header))];
    const extraProps = {
      ...tryCall(headerProps, param),
      columnsStyles,
      class: kls,
      columns,
      headerIndex,
      style
    };
    return vue.createVNode(HeaderRow, extraProps, _isSlot$1(slots) ? slots : {
      default: () => [slots]
    });
  };

  const HeaderCellRenderer = (props, {
    slots
  }) => {
    const {
      column,
      ns,
      style,
      onColumnSorted
    } = props;
    const cellStyle = enforceUnit(style);
    if (column.placeholderSign === placeholderSign) {
      return vue.createVNode("div", {
        "class": ns.em("header-row-cell", "placeholder"),
        "style": cellStyle
      }, null);
    }
    const {
      headerCellRenderer,
      headerClass,
      sortable
    } = column;
    const cellProps = {
      ...props,
      class: ns.e("header-cell-text")
    };
    const columnCellRenderer = componentToSlot(headerCellRenderer);
    const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : vue.renderSlot(slots, "default", cellProps, () => [vue.createVNode(HeaderCell$1, cellProps, null)]);
    const {
      sortBy,
      sortState,
      headerCellProps
    } = props;
    let sorting, sortOrder;
    if (sortState) {
      const order = sortState[column.key];
      sorting = Boolean(oppositeOrderMap[order]);
      sortOrder = sorting ? order : SortOrder.ASC;
    } else {
      sorting = column.key === sortBy.key;
      sortOrder = sorting ? sortBy.order : SortOrder.ASC;
    }
    const cellKls = [ns.e("header-cell"), tryCall(headerClass, props, ""), column.align === Alignment.CENTER && ns.is("align-center"), column.align === Alignment.RIGHT && ns.is("align-right"), sortable && ns.is("sortable")];
    const cellWrapperProps = {
      ...tryCall(headerCellProps, props),
      onClick: column.sortable ? onColumnSorted : void 0,
      class: cellKls,
      style: cellStyle,
      ["data-key"]: column.key
    };
    return vue.createVNode("div", vue.mergeProps(cellWrapperProps, {
      "role": "columnheader"
    }), [Cell, sortable && vue.createVNode(SortIcon$1, {
      "class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
      "sortOrder": sortOrder
    }, null)]);
  };

  const Footer$1 = (props, {
    slots
  }) => {
    var _a;
    return vue.createVNode("div", {
      "class": props.class,
      "style": props.style
    }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
  };
  Footer$1.displayName = "ElTableV2Footer";

  const Footer = (props, {
    slots
  }) => {
    const defaultSlot = vue.renderSlot(slots, "default", {}, () => [vue.createVNode(ElEmpty, null, null)]);
    return vue.createVNode("div", {
      "class": props.class,
      "style": props.style
    }, [defaultSlot]);
  };
  Footer.displayName = "ElTableV2Empty";

  const Overlay = (props, {
    slots
  }) => {
    var _a;
    return vue.createVNode("div", {
      "class": props.class,
      "style": props.style
    }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
  };
  Overlay.displayName = "ElTableV2Overlay";

  function _isSlot(s) {
    return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
  }
  const COMPONENT_NAME$5 = "ElTableV2";
  const TableV2 = vue.defineComponent({
    name: COMPONENT_NAME$5,
    props: tableV2Props,
    setup(props, {
      slots,
      expose
    }) {
      const ns = useNamespace("table-v2");
      const {
        columnsStyles,
        fixedColumnsOnLeft,
        fixedColumnsOnRight,
        mainColumns,
        mainTableHeight,
        fixedTableHeight,
        leftTableWidth,
        rightTableWidth,
        data,
        depthMap,
        expandedRowKeys,
        hasFixedColumns,
        mainTableRef,
        leftTableRef,
        rightTableRef,
        isDynamic,
        isResetting,
        isScrolling,
        bodyWidth,
        emptyStyle,
        rootStyle,
        footerHeight,
        showEmpty,
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow,
        getRowHeight,
        onColumnSorted,
        onRowHeightChange,
        onRowHovered,
        onRowExpanded,
        onRowsRendered,
        onScroll,
        onVerticalScroll
      } = useTable(props);
      expose({
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow
      });
      vue.provide(TableV2InjectionKey, {
        ns,
        isResetting,
        isScrolling
      });
      return () => {
        const {
          cache,
          cellProps,
          estimatedRowHeight,
          expandColumnKey,
          fixedData,
          headerHeight,
          headerClass,
          headerProps,
          headerCellProps,
          sortBy,
          sortState,
          rowHeight,
          rowClass,
          rowEventHandlers,
          rowKey,
          rowProps,
          scrollbarAlwaysOn,
          indentSize,
          iconSize,
          useIsScrolling,
          vScrollbarSize,
          width
        } = props;
        const _data = vue.unref(data);
        const mainTableProps = {
          cache,
          class: ns.e("main"),
          columns: vue.unref(mainColumns),
          data: _data,
          fixedData,
          estimatedRowHeight,
          bodyWidth: vue.unref(bodyWidth),
          headerHeight,
          headerWidth: vue.unref(bodyWidth),
          height: vue.unref(mainTableHeight),
          mainTableRef,
          rowKey,
          rowHeight,
          scrollbarAlwaysOn,
          scrollbarStartGap: 2,
          scrollbarEndGap: vScrollbarSize,
          useIsScrolling,
          width,
          getRowHeight,
          onRowsRendered,
          onScroll
        };
        const leftColumnsWidth = vue.unref(leftTableWidth);
        const _fixedTableHeight = vue.unref(fixedTableHeight);
        const leftTableProps = {
          cache,
          class: ns.e("left"),
          columns: vue.unref(fixedColumnsOnLeft),
          data: _data,
          fixedData,
          estimatedRowHeight,
          leftTableRef,
          rowHeight,
          bodyWidth: leftColumnsWidth,
          headerWidth: leftColumnsWidth,
          headerHeight,
          height: _fixedTableHeight,
          rowKey,
          scrollbarAlwaysOn,
          scrollbarStartGap: 2,
          scrollbarEndGap: vScrollbarSize,
          useIsScrolling,
          width: leftColumnsWidth,
          getRowHeight,
          onScroll: onVerticalScroll
        };
        const rightColumnsWidth = vue.unref(rightTableWidth);
        const rightTableProps = {
          cache,
          class: ns.e("right"),
          columns: vue.unref(fixedColumnsOnRight),
          data: _data,
          fixedData,
          estimatedRowHeight,
          rightTableRef,
          rowHeight,
          bodyWidth: rightColumnsWidth,
          headerWidth: rightColumnsWidth,
          headerHeight,
          height: _fixedTableHeight,
          rowKey,
          scrollbarAlwaysOn,
          scrollbarStartGap: 2,
          scrollbarEndGap: vScrollbarSize,
          width: rightColumnsWidth,
          style: `${ns.cssVarName("table-scrollbar-size")}: ${vScrollbarSize}px`,
          useIsScrolling,
          getRowHeight,
          onScroll: onVerticalScroll
        };
        const _columnsStyles = vue.unref(columnsStyles);
        const tableRowProps = {
          ns,
          depthMap: vue.unref(depthMap),
          columnsStyles: _columnsStyles,
          expandColumnKey,
          expandedRowKeys: vue.unref(expandedRowKeys),
          estimatedRowHeight,
          hasFixedColumns: vue.unref(hasFixedColumns),
          rowProps,
          rowClass,
          rowKey,
          rowEventHandlers,
          onRowHovered,
          onRowExpanded,
          onRowHeightChange
        };
        const tableCellProps = {
          cellProps,
          expandColumnKey,
          indentSize,
          iconSize,
          rowKey,
          expandedRowKeys: vue.unref(expandedRowKeys),
          ns
        };
        const tableHeaderProps = {
          ns,
          headerClass,
          headerProps,
          columnsStyles: _columnsStyles
        };
        const tableHeaderCellProps = {
          ns,
          sortBy,
          sortState,
          headerCellProps,
          onColumnSorted
        };
        const tableSlots = {
          row: (props2) => vue.createVNode(RowRenderer, vue.mergeProps(props2, tableRowProps), {
            row: slots.row,
            cell: (props3) => {
              let _slot;
              return slots.cell ? vue.createVNode(CellRenderer, vue.mergeProps(props3, tableCellProps, {
                "style": _columnsStyles[props3.column.key]
              }), _isSlot(_slot = slots.cell(props3)) ? _slot : {
                default: () => [_slot]
              }) : vue.createVNode(CellRenderer, vue.mergeProps(props3, tableCellProps, {
                "style": _columnsStyles[props3.column.key]
              }), null);
            }
          }),
          header: (props2) => vue.createVNode(HeaderRenderer, vue.mergeProps(props2, tableHeaderProps), {
            header: slots.header,
            cell: (props3) => {
              let _slot2;
              return slots["header-cell"] ? vue.createVNode(HeaderCellRenderer, vue.mergeProps(props3, tableHeaderCellProps, {
                "style": _columnsStyles[props3.column.key]
              }), _isSlot(_slot2 = slots["header-cell"](props3)) ? _slot2 : {
                default: () => [_slot2]
              }) : vue.createVNode(HeaderCellRenderer, vue.mergeProps(props3, tableHeaderCellProps, {
                "style": _columnsStyles[props3.column.key]
              }), null);
            }
          })
        };
        const rootKls = [props.class, ns.b(), ns.e("root"), ns.is("dynamic", vue.unref(isDynamic))];
        const footerProps = {
          class: ns.e("footer"),
          style: vue.unref(footerHeight)
        };
        return vue.createVNode("div", {
          "class": rootKls,
          "style": vue.unref(rootStyle)
        }, [vue.createVNode(MainTable, mainTableProps, _isSlot(tableSlots) ? tableSlots : {
          default: () => [tableSlots]
        }), vue.createVNode(LeftTable, leftTableProps, _isSlot(tableSlots) ? tableSlots : {
          default: () => [tableSlots]
        }), vue.createVNode(RightTable, rightTableProps, _isSlot(tableSlots) ? tableSlots : {
          default: () => [tableSlots]
        }), slots.footer && vue.createVNode(Footer$1, footerProps, {
          default: slots.footer
        }), vue.unref(showEmpty) && vue.createVNode(Footer, {
          "class": ns.e("empty"),
          "style": vue.unref(emptyStyle)
        }, {
          default: slots.empty
        }), slots.overlay && vue.createVNode(Overlay, {
          "class": ns.e("overlay")
        }, {
          default: slots.overlay
        })]);
      };
    }
  });
  var TableV2$1 = TableV2;

  const autoResizerProps = buildProps({
    disableWidth: Boolean,
    disableHeight: Boolean,
    onResize: {
      type: definePropType(Function)
    }
  });

  const AutoResizer = vue.defineComponent({
    name: "ElAutoResizer",
    props: autoResizerProps,
    setup(props, {
      slots
    }) {
      const ns = useNamespace("auto-resizer");
      const {
        height,
        width,
        sizer
      } = useAutoResize(props);
      const style = {
        width: "100%",
        height: "100%"
      };
      return () => {
        var _a;
        return vue.createVNode("div", {
          "ref": sizer,
          "class": ns.b(),
          "style": style
        }, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
          height: height.value,
          width: width.value
        })]);
      };
    }
  });

  const ElTableV2 = withInstall(TableV2$1);
  const ElAutoResizer = withInstall(AutoResizer);

  const tabsRootContextKey = Symbol("tabsRootContextKey");

  const tabBarProps = buildProps({
    tabs: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    tabRefs: {
      type: definePropType(Object),
      default: () => mutable({})
    }
  });

  const COMPONENT_NAME$4 = "ElTabBar";
  const __default__$r = vue.defineComponent({
    name: COMPONENT_NAME$4
  });
  const _sfc_main$w = /* @__PURE__ */ vue.defineComponent({
    ...__default__$r,
    props: tabBarProps,
    setup(__props, { expose }) {
      const props = __props;
      const rootTabs = vue.inject(tabsRootContextKey);
      if (!rootTabs)
        throwError(COMPONENT_NAME$4, "<el-tabs><el-tab-bar /></el-tabs>");
      const ns = useNamespace("tabs");
      const barRef = vue.ref();
      const barStyle = vue.ref();
      const getBarStyle = () => {
        let offset = 0;
        let tabSize = 0;
        const sizeName = ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height";
        const sizeDir = sizeName === "width" ? "x" : "y";
        const position = sizeDir === "x" ? "left" : "top";
        props.tabs.every((tab) => {
          if (isUndefined(tab.paneName))
            return false;
          const $el = props.tabRefs[tab.paneName];
          if (!$el)
            return false;
          if (!tab.active) {
            return true;
          }
          offset = $el[`offset${capitalize(position)}`];
          tabSize = $el[`client${capitalize(sizeName)}`];
          const tabStyles = window.getComputedStyle($el);
          if (sizeName === "width") {
            tabSize -= Number.parseFloat(tabStyles.paddingLeft) + Number.parseFloat(tabStyles.paddingRight);
            offset += Number.parseFloat(tabStyles.paddingLeft);
          }
          return false;
        });
        return {
          [sizeName]: `${tabSize}px`,
          transform: `translate${capitalize(sizeDir)}(${offset}px)`
        };
      };
      const update = () => barStyle.value = getBarStyle();
      const tabObservers = [];
      const observerTabs = () => {
        tabObservers.forEach((observer) => observer.stop());
        tabObservers.length = 0;
        Object.values(props.tabRefs).forEach((tab) => {
          tabObservers.push(useResizeObserver(tab, update));
        });
      };
      vue.watch(() => props.tabs, async () => {
        await vue.nextTick();
        update();
        observerTabs();
      }, { immediate: true });
      const barObserver = useResizeObserver(barRef, () => update());
      vue.onBeforeUnmount(() => {
        tabObservers.forEach((observer) => observer.stop());
        tabObservers.length = 0;
        barObserver.stop();
      });
      expose({
        ref: barRef,
        update
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "barRef",
          ref: barRef,
          class: vue.normalizeClass([vue.unref(ns).e("active-bar"), vue.unref(ns).is(vue.unref(rootTabs).props.tabPosition)]),
          style: vue.normalizeStyle(barStyle.value)
        }, null, 6);
      };
    }
  });
  var TabBar = /* @__PURE__ */ _export_sfc(_sfc_main$w, [["__file", "tab-bar.vue"]]);

  const tabNavProps = buildProps({
    panes: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    currentName: {
      type: [String, Number],
      default: ""
    },
    editable: Boolean,
    type: {
      type: String,
      values: ["card", "border-card", ""],
      default: ""
    },
    stretch: Boolean,
    tabindex: {
      type: [String, Number],
      default: void 0
    }
  });
  const tabNavEmits = {
    tabClick: (tab, tabName, ev) => ev instanceof Event,
    tabRemove: (tab, ev) => ev instanceof Event
  };
  const COMPONENT_NAME$3 = "ElTabNav";
  const TabNav = vue.defineComponent({
    name: COMPONENT_NAME$3,
    props: tabNavProps,
    emits: tabNavEmits,
    setup(props, {
      expose,
      emit
    }) {
      const rootTabs = vue.inject(tabsRootContextKey);
      if (!rootTabs)
        throwError(COMPONENT_NAME$3, `<el-tabs><tab-nav /></el-tabs>`);
      const ns = useNamespace("tabs");
      const visibility = useDocumentVisibility();
      const focused = useWindowFocus();
      const navScroll$ = vue.ref();
      const nav$ = vue.ref();
      const el$ = vue.ref();
      const tabRefsMap = vue.ref({});
      const tabBarRef = vue.ref();
      const scrollable = vue.ref(false);
      const navOffset = vue.ref(0);
      const isFocus = vue.ref(false);
      const focusable = vue.ref(true);
      const tracker = vue.shallowRef();
      const isHorizontal = vue.computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition));
      const sizeName = vue.computed(() => isHorizontal.value ? "width" : "height");
      const navStyle = vue.computed(() => {
        const dir = sizeName.value === "width" ? "X" : "Y";
        return {
          transform: `translate${dir}(-${navOffset.value}px)`
        };
      });
      const {
        width: navContainerWidth,
        height: navContainerHeight
      } = useElementSize(navScroll$);
      const {
        width: navWidth,
        height: navHeight
      } = useElementSize(nav$, {
        width: 0,
        height: 0
      }, {
        box: "border-box"
      });
      const navContainerSize = vue.computed(() => isHorizontal.value ? navContainerWidth.value : navContainerHeight.value);
      const navSize = vue.computed(() => isHorizontal.value ? navWidth.value : navHeight.value);
      const {
        onWheel
      } = useWheel$1({
        atStartEdge: vue.computed(() => navOffset.value <= 0),
        atEndEdge: vue.computed(() => navSize.value - navOffset.value <= navContainerSize.value),
        layout: vue.computed(() => isHorizontal.value ? "horizontal" : "vertical")
      }, (offset) => {
        navOffset.value = clamp$1(navOffset.value + offset, 0, navSize.value - navContainerSize.value);
      });
      const scrollPrev = () => {
        if (!navScroll$.value)
          return;
        const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
        const currentOffset = navOffset.value;
        if (!currentOffset)
          return;
        const newOffset = currentOffset > containerSize ? currentOffset - containerSize : 0;
        navOffset.value = newOffset;
      };
      const scrollNext = () => {
        if (!navScroll$.value || !nav$.value)
          return;
        const navSize2 = nav$.value[`offset${capitalize(sizeName.value)}`];
        const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
        const currentOffset = navOffset.value;
        if (navSize2 - currentOffset <= containerSize)
          return;
        const newOffset = navSize2 - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize2 - containerSize;
        navOffset.value = newOffset;
      };
      const scrollToActiveTab = async () => {
        const nav = nav$.value;
        if (!scrollable.value || !el$.value || !navScroll$.value || !nav)
          return;
        await vue.nextTick();
        const activeTab = tabRefsMap.value[props.currentName];
        if (!activeTab)
          return;
        const navScroll = navScroll$.value;
        const activeTabBounding = activeTab.getBoundingClientRect();
        const navScrollBounding = navScroll.getBoundingClientRect();
        const maxOffset = isHorizontal.value ? nav.offsetWidth - navScrollBounding.width : nav.offsetHeight - navScrollBounding.height;
        const currentOffset = navOffset.value;
        let newOffset = currentOffset;
        if (isHorizontal.value) {
          if (activeTabBounding.left < navScrollBounding.left) {
            newOffset = currentOffset - (navScrollBounding.left - activeTabBounding.left);
          }
          if (activeTabBounding.right > navScrollBounding.right) {
            newOffset = currentOffset + activeTabBounding.right - navScrollBounding.right;
          }
        } else {
          if (activeTabBounding.top < navScrollBounding.top) {
            newOffset = currentOffset - (navScrollBounding.top - activeTabBounding.top);
          }
          if (activeTabBounding.bottom > navScrollBounding.bottom) {
            newOffset = currentOffset + (activeTabBounding.bottom - navScrollBounding.bottom);
          }
        }
        newOffset = Math.max(newOffset, 0);
        navOffset.value = Math.min(newOffset, maxOffset);
      };
      const update = () => {
        var _a;
        if (!nav$.value || !navScroll$.value)
          return;
        props.stretch && ((_a = tabBarRef.value) == null ? void 0 : _a.update());
        const navSize2 = nav$.value[`offset${capitalize(sizeName.value)}`];
        const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
        const currentOffset = navOffset.value;
        if (containerSize < navSize2) {
          scrollable.value = scrollable.value || {};
          scrollable.value.prev = currentOffset;
          scrollable.value.next = currentOffset + containerSize < navSize2;
          if (navSize2 - currentOffset < containerSize) {
            navOffset.value = navSize2 - containerSize;
          }
        } else {
          scrollable.value = false;
          if (currentOffset > 0) {
            navOffset.value = 0;
          }
        }
      };
      const changeTab = (event) => {
        const code = getEventCode(event);
        let step = 0;
        switch (code) {
          case EVENT_CODE.left:
          case EVENT_CODE.up:
            step = -1;
            break;
          case EVENT_CODE.right:
          case EVENT_CODE.down:
            step = 1;
            break;
          default:
            return;
        }
        const tabList = Array.from(event.currentTarget.querySelectorAll("[role=tab]:not(.is-disabled)"));
        const currentIndex = tabList.indexOf(event.target);
        let nextIndex = currentIndex + step;
        if (nextIndex < 0) {
          nextIndex = tabList.length - 1;
        } else if (nextIndex >= tabList.length) {
          nextIndex = 0;
        }
        tabList[nextIndex].focus({
          preventScroll: true
        });
        tabList[nextIndex].click();
        setFocus();
      };
      const setFocus = () => {
        if (focusable.value)
          isFocus.value = true;
      };
      const removeFocus = () => isFocus.value = false;
      const setRefs = (el, key) => {
        tabRefsMap.value[key] = el;
      };
      const focusActiveTab = async () => {
        await vue.nextTick();
        const activeTab = tabRefsMap.value[props.currentName];
        activeTab == null ? void 0 : activeTab.focus({
          preventScroll: true
        });
      };
      vue.watch(visibility, (visibility2) => {
        if (visibility2 === "hidden") {
          focusable.value = false;
        } else if (visibility2 === "visible") {
          setTimeout(() => focusable.value = true, 50);
        }
      });
      vue.watch(focused, (focused2) => {
        if (focused2) {
          setTimeout(() => focusable.value = true, 50);
        } else {
          focusable.value = false;
        }
      });
      useResizeObserver(el$, update);
      vue.onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
      vue.onUpdated(() => update());
      expose({
        scrollToActiveTab,
        removeFocus,
        focusActiveTab,
        tabListRef: nav$,
        tabBarRef,
        scheduleRender: () => vue.triggerRef(tracker)
      });
      return () => {
        const scrollBtn = scrollable.value ? [vue.createVNode("span", {
          "class": [ns.e("nav-prev"), ns.is("disabled", !scrollable.value.prev)],
          "onClick": scrollPrev
        }, [vue.createVNode(ElIcon, null, {
          default: () => [vue.createVNode(arrow_left_default, null, null)]
        })]), vue.createVNode("span", {
          "class": [ns.e("nav-next"), ns.is("disabled", !scrollable.value.next)],
          "onClick": scrollNext
        }, [vue.createVNode(ElIcon, null, {
          default: () => [vue.createVNode(arrow_right_default, null, null)]
        })])] : null;
        const tabs = props.panes.map((pane, index) => {
          var _a, _b, _c, _d, _e;
          const uid = pane.uid;
          const disabled = pane.props.disabled;
          const tabName = (_b = (_a = pane.props.name) != null ? _a : pane.index) != null ? _b : `${index}`;
          const closable = !disabled && (pane.isClosable || pane.props.closable !== false && props.editable);
          pane.index = `${index}`;
          const btnClose = closable ? vue.createVNode(ElIcon, {
            "class": "is-icon-close",
            "onClick": (ev) => emit("tabRemove", pane, ev)
          }, {
            default: () => [vue.createVNode(close_default, null, null)]
          }) : null;
          const tabLabelContent = ((_d = (_c = pane.slots).label) == null ? void 0 : _d.call(_c)) || pane.props.label;
          const tabindex = !disabled && pane.active ? (_e = props.tabindex) != null ? _e : rootTabs.props.tabindex : -1;
          return vue.createVNode("div", {
            "ref": (el) => setRefs(el, tabName),
            "class": [ns.e("item"), ns.is(rootTabs.props.tabPosition), ns.is("active", pane.active), ns.is("disabled", disabled), ns.is("closable", closable), ns.is("focus", isFocus.value)],
            "id": `tab-${tabName}`,
            "key": `tab-${uid}`,
            "aria-controls": `pane-${tabName}`,
            "role": "tab",
            "aria-selected": pane.active,
            "tabindex": tabindex,
            "onFocus": () => setFocus(),
            "onBlur": () => removeFocus(),
            "onClick": (ev) => {
              removeFocus();
              emit("tabClick", pane, tabName, ev);
            },
            "onKeydown": (ev) => {
              const code = getEventCode(ev);
              if (closable && (code === EVENT_CODE.delete || code === EVENT_CODE.backspace)) {
                emit("tabRemove", pane, ev);
              }
            }
          }, [...[tabLabelContent, btnClose]]);
        });
        tracker.value;
        return vue.createVNode("div", {
          "ref": el$,
          "class": [ns.e("nav-wrap"), ns.is("scrollable", !!scrollable.value), ns.is(rootTabs.props.tabPosition)]
        }, [scrollBtn, vue.createVNode("div", {
          "class": ns.e("nav-scroll"),
          "ref": navScroll$
        }, [props.panes.length > 0 ? vue.createVNode("div", {
          "class": [ns.e("nav"), ns.is(rootTabs.props.tabPosition), ns.is("stretch", props.stretch && ["top", "bottom"].includes(rootTabs.props.tabPosition))],
          "ref": nav$,
          "style": navStyle.value,
          "role": "tablist",
          "onKeydown": changeTab,
          "onWheel": onWheel
        }, [...[!props.type ? vue.createVNode(TabBar, {
          "ref": tabBarRef,
          "tabs": [...props.panes],
          "tabRefs": tabRefsMap.value
        }, null) : null, tabs]]) : null])]);
      };
    }
  });

  const tabsProps = buildProps({
    type: {
      type: String,
      values: ["card", "border-card", ""],
      default: ""
    },
    closable: Boolean,
    addable: Boolean,
    modelValue: {
      type: [String, Number]
    },
    editable: Boolean,
    tabPosition: {
      type: String,
      values: ["top", "right", "bottom", "left"],
      default: "top"
    },
    beforeLeave: {
      type: definePropType(Function),
      default: () => true
    },
    stretch: Boolean,
    tabindex: {
      type: [String, Number],
      default: 0
    }
  });
  const isPaneName = (value) => isString$1(value) || isNumber(value);
  const tabsEmits = {
    [UPDATE_MODEL_EVENT]: (name) => isPaneName(name),
    tabClick: (pane, ev) => ev instanceof Event,
    tabChange: (name) => isPaneName(name),
    edit: (paneName, action) => ["remove", "add"].includes(action),
    tabRemove: (name) => isPaneName(name),
    tabAdd: () => true
  };
  const Tabs = vue.defineComponent({
    name: "ElTabs",
    props: tabsProps,
    emits: tabsEmits,
    setup(props, {
      emit,
      slots,
      expose
    }) {
      var _a;
      const ns = useNamespace("tabs");
      const isVertical = vue.computed(() => ["left", "right"].includes(props.tabPosition));
      const {
        children: panes,
        addChild: registerPane,
        removeChild: unregisterPane,
        ChildrenSorter: PanesSorter
      } = useOrderedChildren(vue.getCurrentInstance(), "ElTabPane");
      const nav$ = vue.ref();
      const currentName = vue.ref((_a = props.modelValue) != null ? _a : "0");
      const setCurrentName = async (value, trigger = false) => {
        var _a2, _b, _c, _d;
        if (currentName.value === value || isUndefined(value))
          return;
        try {
          let canLeave;
          if (props.beforeLeave) {
            const result = props.beforeLeave(value, currentName.value);
            canLeave = result instanceof Promise ? await result : result;
          } else {
            canLeave = true;
          }
          if (canLeave !== false) {
            const isFocusInsidePane = (_a2 = panes.value.find((item) => item.paneName === currentName.value)) == null ? void 0 : _a2.isFocusInsidePane();
            currentName.value = value;
            if (trigger) {
              emit(UPDATE_MODEL_EVENT, value);
              emit("tabChange", value);
            }
            (_c = (_b = nav$.value) == null ? void 0 : _b.removeFocus) == null ? void 0 : _c.call(_b);
            if (isFocusInsidePane) {
              (_d = nav$.value) == null ? void 0 : _d.focusActiveTab();
            }
          }
        } catch (e) {
        }
      };
      const handleTabClick = (tab, tabName, event) => {
        if (tab.props.disabled)
          return;
        emit("tabClick", tab, event);
        setCurrentName(tabName, true);
      };
      const handleTabRemove = (pane, ev) => {
        if (pane.props.disabled || isUndefined(pane.props.name))
          return;
        ev.stopPropagation();
        emit("edit", pane.props.name, "remove");
        emit("tabRemove", pane.props.name);
      };
      const handleTabAdd = () => {
        emit("edit", void 0, "add");
        emit("tabAdd");
      };
      const handleKeydown = (event) => {
        const code = getEventCode(event);
        if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter].includes(code))
          handleTabAdd();
      };
      const swapChildren = (vnode) => {
        const actualFirstChild = vnode.el.firstChild;
        const firstChild = ["bottom", "right"].includes(props.tabPosition) ? vnode.children[0].el : vnode.children[1].el;
        if (actualFirstChild !== firstChild) {
          actualFirstChild.before(firstChild);
        }
      };
      vue.watch(() => props.modelValue, (modelValue) => setCurrentName(modelValue));
      vue.watch(currentName, async () => {
        var _a2;
        await vue.nextTick();
        (_a2 = nav$.value) == null ? void 0 : _a2.scrollToActiveTab();
      });
      vue.provide(tabsRootContextKey, {
        props,
        currentName,
        registerPane,
        unregisterPane,
        nav$
      });
      expose({
        currentName,
        get tabNavRef() {
          return omit(nav$.value, ["scheduleRender"]);
        }
      });
      return () => {
        const addSlot = slots["add-icon"];
        const newButton = props.editable || props.addable ? vue.createVNode("div", {
          "class": [ns.e("new-tab"), isVertical.value && ns.e("new-tab-vertical")],
          "tabindex": props.tabindex,
          "onClick": handleTabAdd,
          "onKeydown": handleKeydown
        }, [addSlot ? vue.renderSlot(slots, "add-icon") : vue.createVNode(ElIcon, {
          "class": ns.is("icon-plus")
        }, {
          default: () => [vue.createVNode(plus_default, null, null)]
        })]) : null;
        const tabNav = () => vue.createVNode(TabNav, {
          "ref": nav$,
          "currentName": currentName.value,
          "editable": props.editable,
          "type": props.type,
          "panes": panes.value,
          "stretch": props.stretch,
          "onTabClick": handleTabClick,
          "onTabRemove": handleTabRemove
        }, null);
        const header = vue.createVNode("div", {
          "class": [ns.e("header"), isVertical.value && ns.e("header-vertical"), ns.is(props.tabPosition)]
        }, [vue.createVNode(PanesSorter, null, {
          default: tabNav,
          $stable: true
        }), newButton]);
        const panels = vue.createVNode("div", {
          "class": ns.e("content")
        }, [vue.renderSlot(slots, "default")]);
        return vue.createVNode("div", {
          "class": [ns.b(), ns.m(props.tabPosition), {
            [ns.m("card")]: props.type === "card",
            [ns.m("border-card")]: props.type === "border-card"
          }],
          "onVnodeMounted": swapChildren,
          "onVnodeUpdated": swapChildren
        }, [panels, header]);
      };
    }
  });

  const tabPaneProps = buildProps({
    label: {
      type: String,
      default: ""
    },
    name: {
      type: [String, Number]
    },
    closable: {
      type: Boolean,
      default: void 0
    },
    disabled: Boolean,
    lazy: Boolean
  });

  const COMPONENT_NAME$2 = "ElTabPane";
  const __default__$q = vue.defineComponent({
    name: COMPONENT_NAME$2
  });
  const _sfc_main$v = /* @__PURE__ */ vue.defineComponent({
    ...__default__$q,
    props: tabPaneProps,
    setup(__props) {
      const props = __props;
      const instance = vue.getCurrentInstance();
      const slots = vue.useSlots();
      const tabsRoot = vue.inject(tabsRootContextKey);
      if (!tabsRoot)
        throwError(COMPONENT_NAME$2, "usage: <el-tabs><el-tab-pane /></el-tabs/>");
      const ns = useNamespace("tab-pane");
      const paneRef = vue.ref();
      const index = vue.ref();
      const isClosable = vue.computed(() => {
        var _a;
        return (_a = props.closable) != null ? _a : tabsRoot.props.closable;
      });
      const active = computedEager(() => {
        var _a;
        return tabsRoot.currentName.value === ((_a = props.name) != null ? _a : index.value);
      });
      const loaded = vue.ref(active.value);
      const paneName = vue.computed(() => {
        var _a;
        return (_a = props.name) != null ? _a : index.value;
      });
      const shouldBeRender = computedEager(() => !props.lazy || loaded.value || active.value);
      const isFocusInsidePane = () => {
        var _a;
        return (_a = paneRef.value) == null ? void 0 : _a.contains(document.activeElement);
      };
      vue.watch(active, (val) => {
        if (val)
          loaded.value = true;
      });
      const pane = vue.reactive({
        uid: instance.uid,
        getVnode: () => instance.vnode,
        slots,
        props,
        paneName,
        active,
        index,
        isClosable,
        isFocusInsidePane
      });
      tabsRoot.registerPane(pane);
      vue.onBeforeUnmount(() => {
        tabsRoot.unregisterPane(pane);
      });
      vue.onBeforeUpdate(() => {
        var _a;
        if (slots.label)
          (_a = tabsRoot.nav$.value) == null ? void 0 : _a.scheduleRender();
      });
      return (_ctx, _cache) => {
        return vue.unref(shouldBeRender) ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
          key: 0,
          id: `pane-${vue.unref(paneName)}`,
          ref_key: "paneRef",
          ref: paneRef,
          class: vue.normalizeClass(vue.unref(ns).b()),
          role: "tabpanel",
          "aria-hidden": !vue.unref(active),
          "aria-labelledby": `tab-${vue.unref(paneName)}`
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 10, ["id", "aria-hidden", "aria-labelledby"])), [
          [vue.vShow, vue.unref(active)]
        ]) : vue.createCommentVNode("v-if", true);
      };
    }
  });
  var TabPane = /* @__PURE__ */ _export_sfc(_sfc_main$v, [["__file", "tab-pane.vue"]]);

  const ElTabs = withInstall(Tabs, {
    TabPane
  });
  const ElTabPane = withNoopInstall(TabPane);

  const textProps = buildProps({
    type: {
      type: String,
      values: ["primary", "success", "info", "warning", "danger", ""],
      default: ""
    },
    size: {
      type: String,
      values: componentSizes,
      default: ""
    },
    truncated: Boolean,
    lineClamp: {
      type: [String, Number]
    },
    tag: {
      type: String,
      default: "span"
    }
  });

  const __default__$p = vue.defineComponent({
    name: "ElText"
  });
  const _sfc_main$u = /* @__PURE__ */ vue.defineComponent({
    ...__default__$p,
    props: textProps,
    setup(__props) {
      const props = __props;
      const textRef = vue.ref();
      const textSize = useFormSize();
      const ns = useNamespace("text");
      const textKls = vue.computed(() => [
        ns.b(),
        ns.m(props.type),
        ns.m(textSize.value),
        ns.is("truncated", props.truncated),
        ns.is("line-clamp", !isUndefined(props.lineClamp))
      ]);
      const bindTitle = () => {
        var _a, _b, _c, _d, _e, _f, _g;
        const inheritTitle = vue.useAttrs().title;
        if (inheritTitle)
          return;
        let shouldAddTitle = false;
        const text = ((_a = textRef.value) == null ? void 0 : _a.textContent) || "";
        if (props.truncated) {
          const width = (_b = textRef.value) == null ? void 0 : _b.offsetWidth;
          const scrollWidth = (_c = textRef.value) == null ? void 0 : _c.scrollWidth;
          if (width && scrollWidth && scrollWidth > width) {
            shouldAddTitle = true;
          }
        } else if (!isUndefined(props.lineClamp)) {
          const height = (_d = textRef.value) == null ? void 0 : _d.offsetHeight;
          const scrollHeight = (_e = textRef.value) == null ? void 0 : _e.scrollHeight;
          if (height && scrollHeight && scrollHeight > height) {
            shouldAddTitle = true;
          }
        }
        if (shouldAddTitle) {
          (_f = textRef.value) == null ? void 0 : _f.setAttribute("title", text);
        } else {
          (_g = textRef.value) == null ? void 0 : _g.removeAttribute("title");
        }
      };
      vue.onMounted(bindTitle);
      vue.onUpdated(bindTitle);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
          ref_key: "textRef",
          ref: textRef,
          class: vue.normalizeClass(vue.unref(textKls)),
          style: vue.normalizeStyle({ "-webkit-line-clamp": _ctx.lineClamp })
        }, {
          default: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "default")
          ]),
          _: 3
        }, 8, ["class", "style"]);
      };
    }
  });
  var Text = /* @__PURE__ */ _export_sfc(_sfc_main$u, [["__file", "text.vue"]]);

  const ElText = withInstall(Text);

  const timeSelectProps = buildProps({
    format: {
      type: String,
      default: "HH:mm"
    },
    modelValue: {
      type: definePropType(String)
    },
    disabled: Boolean,
    editable: {
      type: Boolean,
      default: true
    },
    effect: {
      type: definePropType(String),
      default: "light"
    },
    clearable: {
      type: Boolean,
      default: true
    },
    size: useSizeProp,
    placeholder: String,
    start: {
      type: String,
      default: "09:00"
    },
    end: {
      type: String,
      default: "18:00"
    },
    step: {
      type: String,
      default: "00:30"
    },
    minTime: {
      type: definePropType(String)
    },
    maxTime: {
      type: definePropType(String)
    },
    includeEndTime: Boolean,
    name: String,
    prefixIcon: {
      type: definePropType([String, Object]),
      default: () => clock_default
    },
    clearIcon: {
      type: definePropType([String, Object]),
      default: () => circle_close_default
    },
    popperClass: {
      type: String,
      default: ""
    },
    popperStyle: {
      type: definePropType([String, Object])
    },
    ...useEmptyValuesProps
  });

  const parseTime = (time) => {
    const values = (time || "").split(":");
    if (values.length >= 2) {
      let hours = Number.parseInt(values[0], 10);
      const minutes = Number.parseInt(values[1], 10);
      const timeUpper = time.toUpperCase();
      if (timeUpper.includes("AM") && hours === 12) {
        hours = 0;
      } else if (timeUpper.includes("PM") && hours !== 12) {
        hours += 12;
      }
      return {
        hours,
        minutes
      };
    }
    return null;
  };
  const compareTime = (time1, time2) => {
    const value1 = parseTime(time1);
    if (!value1)
      return -1;
    const value2 = parseTime(time2);
    if (!value2)
      return -1;
    const minutes1 = value1.minutes + value1.hours * 60;
    const minutes2 = value2.minutes + value2.hours * 60;
    if (minutes1 === minutes2) {
      return 0;
    }
    return minutes1 > minutes2 ? 1 : -1;
  };
  const padTime = (time) => {
    return `${time}`.padStart(2, "0");
  };
  const formatTime = (time) => {
    return `${padTime(time.hours)}:${padTime(time.minutes)}`;
  };
  const nextTime = (time, step) => {
    const timeValue = parseTime(time);
    if (!timeValue)
      return "";
    const stepValue = parseTime(step);
    if (!stepValue)
      return "";
    const next = {
      hours: timeValue.hours,
      minutes: timeValue.minutes
    };
    next.minutes += stepValue.minutes;
    next.hours += stepValue.hours;
    next.hours += Math.floor(next.minutes / 60);
    next.minutes = next.minutes % 60;
    return formatTime(next);
  };

  const __default__$o = vue.defineComponent({
    name: "ElTimeSelect"
  });
  const _sfc_main$t = /* @__PURE__ */ vue.defineComponent({
    ...__default__$o,
    props: timeSelectProps,
    emits: [CHANGE_EVENT, "blur", "focus", "clear", UPDATE_MODEL_EVENT],
    setup(__props, { expose }) {
      const props = __props;
      dayjs.extend(customParseFormat);
      const { Option: ElOption } = ElSelect;
      const nsInput = useNamespace("input");
      const select = vue.ref();
      const _disabled = useFormDisabled();
      const { lang } = useLocale();
      const value = vue.computed(() => props.modelValue);
      const start = vue.computed(() => {
        const time = parseTime(props.start);
        return time ? formatTime(time) : null;
      });
      const end = vue.computed(() => {
        const time = parseTime(props.end);
        return time ? formatTime(time) : null;
      });
      const step = vue.computed(() => {
        const time = parseTime(props.step);
        return time ? formatTime(time) : null;
      });
      const minTime = vue.computed(() => {
        const time = parseTime(props.minTime || "");
        return time ? formatTime(time) : null;
      });
      const maxTime = vue.computed(() => {
        const time = parseTime(props.maxTime || "");
        return time ? formatTime(time) : null;
      });
      const items = vue.computed(() => {
        var _a;
        const result = [];
        const push = (formattedValue, rawValue) => {
          result.push({
            value: formattedValue,
            disabled: compareTime(rawValue, minTime.value || "-1:-1") <= 0 || compareTime(rawValue, maxTime.value || "100:100") >= 0
          });
        };
        if (props.start && props.end && props.step) {
          let current = start.value;
          let currentTime;
          while (current && end.value && compareTime(current, end.value) <= 0) {
            currentTime = dayjs(current, "HH:mm").locale(lang.value).format(props.format);
            push(currentTime, current);
            current = nextTime(current, step.value);
          }
          if (props.includeEndTime && end.value && ((_a = result[result.length - 1]) == null ? void 0 : _a.value) !== end.value) {
            const formattedValue = dayjs(end.value, "HH:mm").locale(lang.value).format(props.format);
            push(formattedValue, end.value);
          }
        }
        return result;
      });
      const blur = () => {
        var _a, _b;
        (_b = (_a = select.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
      };
      const focus = () => {
        var _a, _b;
        (_b = (_a = select.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
      };
      expose({
        blur,
        focus
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.unref(ElSelect), {
          ref_key: "select",
          ref: select,
          "model-value": vue.unref(value),
          disabled: vue.unref(_disabled),
          clearable: _ctx.clearable,
          "clear-icon": _ctx.clearIcon,
          size: _ctx.size,
          effect: _ctx.effect,
          placeholder: _ctx.placeholder,
          "default-first-option": "",
          filterable: _ctx.editable,
          "empty-values": _ctx.emptyValues,
          "value-on-clear": _ctx.valueOnClear,
          "popper-class": _ctx.popperClass,
          "popper-style": _ctx.popperStyle,
          "onUpdate:modelValue": (event) => _ctx.$emit(vue.unref(UPDATE_MODEL_EVENT), event),
          onChange: (event) => _ctx.$emit(vue.unref(CHANGE_EVENT), event),
          onBlur: (event) => _ctx.$emit("blur", event),
          onFocus: (event) => _ctx.$emit("focus", event),
          onClear: () => _ctx.$emit("clear")
        }, {
          prefix: vue.withCtx(() => [
            _ctx.prefixIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 0,
              class: vue.normalizeClass(vue.unref(nsInput).e("prefix-icon"))
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.prefixIcon)))
              ]),
              _: 1
            }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
          ]),
          default: vue.withCtx(() => [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(items), (item) => {
              return vue.openBlock(), vue.createBlock(vue.unref(ElOption), {
                key: item.value,
                label: item.value,
                value: item.value,
                disabled: item.disabled
              }, null, 8, ["label", "value", "disabled"]);
            }), 128))
          ]),
          _: 1
        }, 8, ["model-value", "disabled", "clearable", "clear-icon", "size", "effect", "placeholder", "filterable", "empty-values", "value-on-clear", "popper-class", "popper-style", "onUpdate:modelValue", "onChange", "onBlur", "onFocus", "onClear"]);
      };
    }
  });
  var TimeSelect = /* @__PURE__ */ _export_sfc(_sfc_main$t, [["__file", "time-select.vue"]]);

  const ElTimeSelect = withInstall(TimeSelect);

  const TIMELINE_INJECTION_KEY = "timeline";

  const Timeline = vue.defineComponent({
    name: "ElTimeline",
    setup(_, { slots }) {
      const ns = useNamespace("timeline");
      vue.provide(TIMELINE_INJECTION_KEY, slots);
      return () => {
        return vue.h("ul", { class: [ns.b()] }, [vue.renderSlot(slots, "default")]);
      };
    }
  });
  var Timeline$1 = Timeline;

  const timelineItemProps = buildProps({
    timestamp: {
      type: String,
      default: ""
    },
    hideTimestamp: Boolean,
    center: Boolean,
    placement: {
      type: String,
      values: ["top", "bottom"],
      default: "bottom"
    },
    type: {
      type: String,
      values: ["primary", "success", "warning", "danger", "info"],
      default: ""
    },
    color: {
      type: String,
      default: ""
    },
    size: {
      type: String,
      values: ["normal", "large"],
      default: "normal"
    },
    icon: {
      type: iconPropType
    },
    hollow: Boolean
  });

  const __default__$n = vue.defineComponent({
    name: "ElTimelineItem"
  });
  const _sfc_main$s = /* @__PURE__ */ vue.defineComponent({
    ...__default__$n,
    props: timelineItemProps,
    setup(__props) {
      const props = __props;
      const ns = useNamespace("timeline-item");
      const defaultNodeKls = vue.computed(() => [
        ns.e("node"),
        ns.em("node", props.size || ""),
        ns.em("node", props.type || ""),
        ns.is("hollow", props.hollow)
      ]);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("li", {
          class: vue.normalizeClass([vue.unref(ns).b(), { [vue.unref(ns).e("center")]: _ctx.center }])
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("tail"))
          }, null, 2),
          !_ctx.$slots.dot ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(defaultNodeKls)),
            style: vue.normalizeStyle({
              backgroundColor: _ctx.color
            })
          }, [
            _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("icon"))
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
              ]),
              _: 1
            }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
          ], 6)) : vue.createCommentVNode("v-if", true),
          _ctx.$slots.dot ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("dot"))
          }, [
            vue.renderSlot(_ctx.$slots, "dot")
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("wrapper"))
          }, [
            !_ctx.hideTimestamp && _ctx.placement === "top" ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass([vue.unref(ns).e("timestamp"), vue.unref(ns).is("top")])
            }, vue.toDisplayString(_ctx.timestamp), 3)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("content"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2),
            !_ctx.hideTimestamp && _ctx.placement === "bottom" ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass([vue.unref(ns).e("timestamp"), vue.unref(ns).is("bottom")])
            }, vue.toDisplayString(_ctx.timestamp), 3)) : vue.createCommentVNode("v-if", true)
          ], 2)
        ], 2);
      };
    }
  });
  var TimelineItem = /* @__PURE__ */ _export_sfc(_sfc_main$s, [["__file", "timeline-item.vue"]]);

  const ElTimeline = withInstall(Timeline$1, {
    TimelineItem
  });
  const ElTimelineItem = withNoopInstall(TimelineItem);

  const LEFT_CHECK_CHANGE_EVENT = "left-check-change";
  const RIGHT_CHECK_CHANGE_EVENT = "right-check-change";
  const transferProps = buildProps({
    data: {
      type: definePropType(Array),
      default: () => []
    },
    titles: {
      type: definePropType(Array),
      default: () => []
    },
    buttonTexts: {
      type: definePropType(Array),
      default: () => []
    },
    filterPlaceholder: String,
    filterMethod: {
      type: definePropType(Function)
    },
    leftDefaultChecked: {
      type: definePropType(Array),
      default: () => []
    },
    rightDefaultChecked: {
      type: definePropType(Array),
      default: () => []
    },
    renderContent: {
      type: definePropType(Function)
    },
    modelValue: {
      type: definePropType(Array),
      default: () => []
    },
    format: {
      type: definePropType(Object),
      default: () => ({})
    },
    filterable: Boolean,
    props: {
      type: definePropType(Object),
      default: () => mutable({
        label: "label",
        key: "key",
        disabled: "disabled"
      })
    },
    targetOrder: {
      type: String,
      values: ["original", "push", "unshift"],
      default: "original"
    },
    validateEvent: {
      type: Boolean,
      default: true
    }
  });
  const transferCheckedChangeFn = (value, movedKeys) => [value, movedKeys].every(isArray$1) || isArray$1(value) && isNil(movedKeys);
  const transferEmits = {
    [CHANGE_EVENT]: (value, direction, movedKeys) => [value, movedKeys].every(isArray$1) && ["left", "right"].includes(direction),
    [UPDATE_MODEL_EVENT]: (value) => isArray$1(value),
    [LEFT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn,
    [RIGHT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn
  };

  const CHECKED_CHANGE_EVENT = "checked-change";
  const transferPanelProps = buildProps({
    data: transferProps.data,
    optionRender: {
      type: definePropType(Function)
    },
    placeholder: String,
    title: String,
    filterable: Boolean,
    format: transferProps.format,
    filterMethod: transferProps.filterMethod,
    defaultChecked: transferProps.leftDefaultChecked,
    props: transferProps.props
  });
  const transferPanelEmits = {
    [CHECKED_CHANGE_EVENT]: transferCheckedChangeFn
  };

  const usePropsAlias = (props) => {
    const initProps = {
      label: "label",
      key: "key",
      disabled: "disabled"
    };
    return vue.computed(() => ({
      ...initProps,
      ...props.props
    }));
  };

  const useCheck$1 = (props, panelState, emit) => {
    const propsAlias = usePropsAlias(props);
    const filteredData = vue.computed(() => {
      return props.data.filter((item) => {
        if (isFunction$1(props.filterMethod)) {
          return props.filterMethod(panelState.query, item);
        } else {
          const label = String(item[propsAlias.value.label] || item[propsAlias.value.key]);
          return label.toLowerCase().includes(panelState.query.toLowerCase());
        }
      });
    });
    const checkableData = vue.computed(() => filteredData.value.filter((item) => !item[propsAlias.value.disabled]));
    const checkedSummary = vue.computed(() => {
      const checkedLength = panelState.checked.length;
      const dataLength = props.data.length;
      const { noChecked, hasChecked } = props.format;
      if (noChecked && hasChecked) {
        return checkedLength > 0 ? hasChecked.replace(/\${checked}/g, checkedLength.toString()).replace(/\${total}/g, dataLength.toString()) : noChecked.replace(/\${total}/g, dataLength.toString());
      } else {
        return `${checkedLength}/${dataLength}`;
      }
    });
    const isIndeterminate = vue.computed(() => {
      const checkedLength = panelState.checked.length;
      return checkedLength > 0 && checkedLength < checkableData.value.length;
    });
    const updateAllChecked = () => {
      const checkableDataKeys = checkableData.value.map((item) => item[propsAlias.value.key]);
      panelState.allChecked = checkableDataKeys.length > 0 && checkableDataKeys.every((item) => panelState.checked.includes(item));
    };
    const handleAllCheckedChange = (value) => {
      panelState.checked = value ? checkableData.value.map((item) => item[propsAlias.value.key]) : [];
    };
    vue.watch(() => panelState.checked, (val, oldVal) => {
      updateAllChecked();
      if (panelState.checkChangeByUser) {
        const movedKeys = val.concat(oldVal).filter((v) => !val.includes(v) || !oldVal.includes(v));
        emit(CHECKED_CHANGE_EVENT, val, movedKeys);
      } else {
        emit(CHECKED_CHANGE_EVENT, val);
        panelState.checkChangeByUser = true;
      }
    });
    vue.watch(checkableData, () => {
      updateAllChecked();
    });
    vue.watch(() => props.data, () => {
      const checked = [];
      const filteredDataKeys = filteredData.value.map((item) => item[propsAlias.value.key]);
      panelState.checked.forEach((item) => {
        if (filteredDataKeys.includes(item)) {
          checked.push(item);
        }
      });
      panelState.checkChangeByUser = false;
      panelState.checked = checked;
    });
    vue.watch(() => props.defaultChecked, (val, oldVal) => {
      if (oldVal && val.length === oldVal.length && val.every((item) => oldVal.includes(item)))
        return;
      const checked = [];
      const checkableDataKeys = checkableData.value.map((item) => item[propsAlias.value.key]);
      val.forEach((item) => {
        if (checkableDataKeys.includes(item)) {
          checked.push(item);
        }
      });
      panelState.checkChangeByUser = false;
      panelState.checked = checked;
    }, {
      immediate: true
    });
    return {
      filteredData,
      checkableData,
      checkedSummary,
      isIndeterminate,
      updateAllChecked,
      handleAllCheckedChange
    };
  };

  const useCheckedChange = (checkedState, emit) => {
    const onSourceCheckedChange = (val, movedKeys) => {
      checkedState.leftChecked = val;
      if (!movedKeys)
        return;
      emit(LEFT_CHECK_CHANGE_EVENT, val, movedKeys);
    };
    const onTargetCheckedChange = (val, movedKeys) => {
      checkedState.rightChecked = val;
      if (!movedKeys)
        return;
      emit(RIGHT_CHECK_CHANGE_EVENT, val, movedKeys);
    };
    return {
      onSourceCheckedChange,
      onTargetCheckedChange
    };
  };

  const useComputedData = (props) => {
    const propsAlias = usePropsAlias(props);
    const dataObj = vue.computed(() => props.data.reduce((o, cur) => (o[cur[propsAlias.value.key]] = cur) && o, {}));
    const sourceData = vue.computed(() => props.data.filter((item) => !props.modelValue.includes(item[propsAlias.value.key])));
    const targetData = vue.computed(() => {
      if (props.targetOrder === "original") {
        return props.data.filter((item) => props.modelValue.includes(item[propsAlias.value.key]));
      } else {
        return props.modelValue.reduce((arr, cur) => {
          const val = dataObj.value[cur];
          if (val) {
            arr.push(val);
          }
          return arr;
        }, []);
      }
    });
    return {
      sourceData,
      targetData
    };
  };

  const useMove = (props, checkedState, emit) => {
    const propsAlias = usePropsAlias(props);
    const _emit = (value, direction, movedKeys) => {
      emit(UPDATE_MODEL_EVENT, value);
      emit(CHANGE_EVENT, value, direction, movedKeys);
    };
    const addToLeft = () => {
      const currentValue = props.modelValue.slice();
      checkedState.rightChecked.forEach((item) => {
        const index = currentValue.indexOf(item);
        if (index > -1) {
          currentValue.splice(index, 1);
        }
      });
      _emit(currentValue, "left", checkedState.rightChecked);
    };
    const addToRight = () => {
      let currentValue = props.modelValue.slice();
      const itemsToBeMoved = props.data.filter((item) => {
        const itemKey = item[propsAlias.value.key];
        return checkedState.leftChecked.includes(itemKey) && !props.modelValue.includes(itemKey);
      }).map((item) => item[propsAlias.value.key]);
      currentValue = props.targetOrder === "unshift" ? itemsToBeMoved.concat(currentValue) : currentValue.concat(itemsToBeMoved);
      if (props.targetOrder === "original") {
        currentValue = props.data.filter((item) => currentValue.includes(item[propsAlias.value.key])).map((item) => item[propsAlias.value.key]);
      }
      _emit(currentValue, "right", checkedState.leftChecked);
    };
    return {
      addToLeft,
      addToRight
    };
  };

  const __default__$m = vue.defineComponent({
    name: "ElTransferPanel"
  });
  const _sfc_main$r = /* @__PURE__ */ vue.defineComponent({
    ...__default__$m,
    props: transferPanelProps,
    emits: transferPanelEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const slots = vue.useSlots();
      const OptionContent = ({ option }) => option;
      const { t } = useLocale();
      const ns = useNamespace("transfer");
      const panelState = vue.reactive({
        checked: [],
        allChecked: false,
        query: "",
        checkChangeByUser: true
      });
      const propsAlias = usePropsAlias(props);
      const {
        filteredData,
        checkedSummary,
        isIndeterminate,
        handleAllCheckedChange
      } = useCheck$1(props, panelState, emit);
      const hasNoMatch = vue.computed(() => !isEmpty(panelState.query) && isEmpty(filteredData.value));
      const hasFooter = vue.computed(() => !isEmpty(slots.default()[0].children));
      const { checked, allChecked, query } = vue.toRefs(panelState);
      expose({
        query
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b("panel"))
        }, [
          vue.createElementVNode("p", {
            class: vue.normalizeClass(vue.unref(ns).be("panel", "header"))
          }, [
            vue.createVNode(vue.unref(ElCheckbox), {
              modelValue: vue.unref(allChecked),
              "onUpdate:modelValue": ($event) => vue.isRef(allChecked) ? allChecked.value = $event : null,
              indeterminate: vue.unref(isIndeterminate),
              "validate-event": false,
              onChange: vue.unref(handleAllCheckedChange)
            }, {
              default: vue.withCtx(() => [
                vue.createTextVNode(vue.toDisplayString(_ctx.title) + " ", 1),
                vue.createElementVNode("span", null, vue.toDisplayString(vue.unref(checkedSummary)), 1)
              ]),
              _: 1
            }, 8, ["modelValue", "onUpdate:modelValue", "indeterminate", "onChange"])
          ], 2),
          vue.createElementVNode("div", {
            class: vue.normalizeClass([vue.unref(ns).be("panel", "body"), vue.unref(ns).is("with-footer", vue.unref(hasFooter))])
          }, [
            _ctx.filterable ? (vue.openBlock(), vue.createBlock(vue.unref(ElInput), {
              key: 0,
              modelValue: vue.unref(query),
              "onUpdate:modelValue": ($event) => vue.isRef(query) ? query.value = $event : null,
              class: vue.normalizeClass(vue.unref(ns).be("panel", "filter")),
              size: "default",
              placeholder: _ctx.placeholder,
              "prefix-icon": vue.unref(search_default),
              clearable: "",
              "validate-event": false
            }, null, 8, ["modelValue", "onUpdate:modelValue", "class", "placeholder", "prefix-icon"])) : vue.createCommentVNode("v-if", true),
            vue.withDirectives(vue.createVNode(vue.unref(ElCheckboxGroup$1), {
              modelValue: vue.unref(checked),
              "onUpdate:modelValue": ($event) => vue.isRef(checked) ? checked.value = $event : null,
              "validate-event": false,
              class: vue.normalizeClass([vue.unref(ns).is("filterable", _ctx.filterable), vue.unref(ns).be("panel", "list")])
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(filteredData), (item) => {
                  return vue.openBlock(), vue.createBlock(vue.unref(ElCheckbox), {
                    key: item[vue.unref(propsAlias).key],
                    class: vue.normalizeClass(vue.unref(ns).be("panel", "item")),
                    value: item[vue.unref(propsAlias).key],
                    disabled: item[vue.unref(propsAlias).disabled],
                    "validate-event": false
                  }, {
                    default: vue.withCtx(() => {
                      var _a;
                      return [
                        vue.createVNode(OptionContent, {
                          option: (_a = _ctx.optionRender) == null ? void 0 : _a.call(_ctx, item)
                        }, null, 8, ["option"])
                      ];
                    }),
                    _: 2
                  }, 1032, ["class", "value", "disabled"]);
                }), 128))
              ]),
              _: 1
            }, 8, ["modelValue", "onUpdate:modelValue", "class"]), [
              [vue.vShow, !vue.unref(hasNoMatch) && !vue.unref(isEmpty)(_ctx.data)]
            ]),
            vue.withDirectives(vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).be("panel", "empty"))
            }, [
              vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                vue.createTextVNode(vue.toDisplayString(vue.unref(hasNoMatch) ? vue.unref(t)("el.transfer.noMatch") : vue.unref(t)("el.transfer.noData")), 1)
              ])
            ], 2), [
              [vue.vShow, vue.unref(hasNoMatch) || vue.unref(isEmpty)(_ctx.data)]
            ])
          ], 2),
          vue.unref(hasFooter) ? (vue.openBlock(), vue.createElementBlock("p", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).be("panel", "footer"))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var TransferPanel = /* @__PURE__ */ _export_sfc(_sfc_main$r, [["__file", "transfer-panel.vue"]]);

  const __default__$l = vue.defineComponent({
    name: "ElTransfer"
  });
  const _sfc_main$q = /* @__PURE__ */ vue.defineComponent({
    ...__default__$l,
    props: transferProps,
    emits: transferEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const slots = vue.useSlots();
      const { t } = useLocale();
      const ns = useNamespace("transfer");
      const { formItem } = useFormItem();
      const checkedState = vue.reactive({
        leftChecked: [],
        rightChecked: []
      });
      const propsAlias = usePropsAlias(props);
      const { sourceData, targetData } = useComputedData(props);
      const { onSourceCheckedChange, onTargetCheckedChange } = useCheckedChange(checkedState, emit);
      const { addToLeft, addToRight } = useMove(props, checkedState, emit);
      const leftPanel = vue.ref();
      const rightPanel = vue.ref();
      const clearQuery = (which) => {
        switch (which) {
          case "left":
            leftPanel.value.query = "";
            break;
          case "right":
            rightPanel.value.query = "";
            break;
        }
      };
      const hasButtonTexts = vue.computed(() => props.buttonTexts.length === 2);
      const leftPanelTitle = vue.computed(() => props.titles[0] || t("el.transfer.titles.0"));
      const rightPanelTitle = vue.computed(() => props.titles[1] || t("el.transfer.titles.1"));
      const panelFilterPlaceholder = vue.computed(() => props.filterPlaceholder || t("el.transfer.filterPlaceholder"));
      vue.watch(() => props.modelValue, () => {
        var _a;
        if (props.validateEvent) {
          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
        }
      });
      const optionRender = vue.computed(() => (option) => {
        var _a;
        if (props.renderContent)
          return props.renderContent(vue.h, option);
        const defaultSlotVNodes = (((_a = slots.default) == null ? void 0 : _a.call(slots, { option })) || []).filter((node) => node.type !== vue.Comment);
        if (defaultSlotVNodes.length) {
          return defaultSlotVNodes;
        }
        return vue.h("span", option[propsAlias.value.label] || option[propsAlias.value.key]);
      });
      expose({
        clearQuery,
        leftPanel,
        rightPanel
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.createVNode(TransferPanel, {
            ref_key: "leftPanel",
            ref: leftPanel,
            data: vue.unref(sourceData),
            "option-render": vue.unref(optionRender),
            placeholder: vue.unref(panelFilterPlaceholder),
            title: vue.unref(leftPanelTitle),
            filterable: _ctx.filterable,
            format: _ctx.format,
            "filter-method": _ctx.filterMethod,
            "default-checked": _ctx.leftDefaultChecked,
            props: props.props,
            onCheckedChange: vue.unref(onSourceCheckedChange)
          }, {
            empty: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "left-empty")
            ]),
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "left-footer")
            ]),
            _: 3
          }, 8, ["data", "option-render", "placeholder", "title", "filterable", "format", "filter-method", "default-checked", "props", "onCheckedChange"]),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("buttons"))
          }, [
            vue.createVNode(vue.unref(ElButton), {
              type: "primary",
              class: vue.normalizeClass([vue.unref(ns).e("button"), vue.unref(ns).is("with-texts", vue.unref(hasButtonTexts))]),
              disabled: vue.unref(isEmpty)(checkedState.rightChecked),
              onClick: vue.unref(addToLeft)
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(vue.unref(ElIcon), null, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(arrow_left_default))
                  ]),
                  _: 1
                }),
                !vue.unref(isUndefined)(_ctx.buttonTexts[0]) ? (vue.openBlock(), vue.createElementBlock("span", { key: 0 }, vue.toDisplayString(_ctx.buttonTexts[0]), 1)) : vue.createCommentVNode("v-if", true)
              ]),
              _: 1
            }, 8, ["class", "disabled", "onClick"]),
            vue.createVNode(vue.unref(ElButton), {
              type: "primary",
              class: vue.normalizeClass([vue.unref(ns).e("button"), vue.unref(ns).is("with-texts", vue.unref(hasButtonTexts))]),
              disabled: vue.unref(isEmpty)(checkedState.leftChecked),
              onClick: vue.unref(addToRight)
            }, {
              default: vue.withCtx(() => [
                !vue.unref(isUndefined)(_ctx.buttonTexts[1]) ? (vue.openBlock(), vue.createElementBlock("span", { key: 0 }, vue.toDisplayString(_ctx.buttonTexts[1]), 1)) : vue.createCommentVNode("v-if", true),
                vue.createVNode(vue.unref(ElIcon), null, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(arrow_right_default))
                  ]),
                  _: 1
                })
              ]),
              _: 1
            }, 8, ["class", "disabled", "onClick"])
          ], 2),
          vue.createVNode(TransferPanel, {
            ref_key: "rightPanel",
            ref: rightPanel,
            data: vue.unref(targetData),
            "option-render": vue.unref(optionRender),
            placeholder: vue.unref(panelFilterPlaceholder),
            filterable: _ctx.filterable,
            format: _ctx.format,
            "filter-method": _ctx.filterMethod,
            title: vue.unref(rightPanelTitle),
            "default-checked": _ctx.rightDefaultChecked,
            props: props.props,
            onCheckedChange: vue.unref(onTargetCheckedChange)
          }, {
            empty: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "right-empty")
            ]),
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "right-footer")
            ]),
            _: 3
          }, 8, ["data", "option-render", "placeholder", "filterable", "format", "filter-method", "title", "default-checked", "props", "onCheckedChange"])
        ], 2);
      };
    }
  });
  var Transfer = /* @__PURE__ */ _export_sfc(_sfc_main$q, [["__file", "transfer.vue"]]);

  const ElTransfer = withInstall(Transfer);

  const NODE_KEY = "$treeNodeId";
  const markNodeData = function(node, data) {
    if (!data || data[NODE_KEY])
      return;
    Object.defineProperty(data, NODE_KEY, {
      value: node.id,
      enumerable: false,
      configurable: false,
      writable: false
    });
  };
  const getNodeKey = (key, data) => data == null ? void 0 : data[key || NODE_KEY];
  const handleCurrentChange = (store, emit, setCurrent) => {
    const preCurrentNode = store.value.currentNode;
    setCurrent();
    const currentNode = store.value.currentNode;
    if (preCurrentNode === currentNode)
      return;
    emit("current-change", currentNode ? currentNode.data : null, currentNode);
  };

  const getChildState = (node) => {
    let all = true;
    let none = true;
    let allWithoutDisable = true;
    for (let i = 0, j = node.length; i < j; i++) {
      const n = node[i];
      if (n.checked !== true || n.indeterminate) {
        all = false;
        if (!n.disabled) {
          allWithoutDisable = false;
        }
      }
      if (n.checked !== false || n.indeterminate) {
        none = false;
      }
    }
    return { all, none, allWithoutDisable, half: !all && !none };
  };
  const reInitChecked = function(node) {
    if (node.childNodes.length === 0 || node.loading)
      return;
    const { all, none, half } = getChildState(node.childNodes);
    if (all) {
      node.checked = true;
      node.indeterminate = false;
    } else if (half) {
      node.checked = false;
      node.indeterminate = true;
    } else if (none) {
      node.checked = false;
      node.indeterminate = false;
    }
    const parent = node.parent;
    if (!parent || parent.level === 0)
      return;
    if (!node.store.checkStrictly) {
      reInitChecked(parent);
    }
  };
  const getPropertyFromData = function(node, prop) {
    const props = node.store.props;
    const data = node.data || {};
    const config = props[prop];
    if (isFunction$1(config)) {
      return config(data, node);
    } else if (isString$1(config)) {
      return data[config];
    } else if (isUndefined(config)) {
      const dataProp = data[prop];
      return isUndefined(dataProp) ? "" : dataProp;
    }
  };
  const setCanFocus = function(childNodes, focus) {
    childNodes.forEach((item) => {
      item.canFocus = focus;
      setCanFocus(item.childNodes, focus);
    });
  };
  let nodeIdSeed = 0;
  class Node$1 {
    constructor(options) {
      this.isLeafByUser = void 0;
      this.isLeaf = void 0;
      this.id = nodeIdSeed++;
      this.text = null;
      this.checked = false;
      this.indeterminate = false;
      this.data = null;
      this.expanded = false;
      this.parent = null;
      this.visible = true;
      this.isCurrent = false;
      this.canFocus = false;
      for (const name in options) {
        if (hasOwn(options, name)) {
          this[name] = options[name];
        }
      }
      this.level = 0;
      this.loaded = false;
      this.childNodes = [];
      this.loading = false;
      if (this.parent) {
        this.level = this.parent.level + 1;
      }
    }
    initialize() {
      var _a;
      const store = this.store;
      if (!store) {
        throw new Error("[Node]store is required!");
      }
      store.registerNode(this);
      const props = store.props;
      if (props && typeof props.isLeaf !== "undefined") {
        const isLeaf = getPropertyFromData(this, "isLeaf");
        if (isBoolean(isLeaf)) {
          this.isLeafByUser = isLeaf;
        }
      }
      if (store.lazy !== true && this.data) {
        this.setData(this.data);
        if (store.defaultExpandAll) {
          this.expanded = true;
          this.canFocus = true;
        }
      } else if (this.level > 0 && store.lazy && store.defaultExpandAll && !this.isLeafByUser) {
        this.expand();
      }
      if (!isArray$1(this.data)) {
        markNodeData(this, this.data);
      }
      if (!this.data)
        return;
      const defaultExpandedKeys = store.defaultExpandedKeys;
      const key = store.key;
      if (key && !isNil(this.key) && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
        this.expand(null, store.autoExpandParent);
      }
      if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
        store.currentNode = this;
        store.currentNode.isCurrent = true;
      }
      if (store.lazy) {
        store._initDefaultCheckedNode(this);
      }
      this.updateLeafState();
      if (this.level === 1 || ((_a = this.parent) == null ? void 0 : _a.expanded) === true)
        this.canFocus = true;
    }
    setData(data) {
      if (!isArray$1(data)) {
        markNodeData(this, data);
      }
      this.data = data;
      this.childNodes = [];
      let children;
      if (this.level === 0 && isArray$1(this.data)) {
        children = this.data;
      } else {
        children = getPropertyFromData(this, "children") || [];
      }
      for (let i = 0, j = children.length; i < j; i++) {
        this.insertChild({ data: children[i] });
      }
    }
    get label() {
      return getPropertyFromData(this, "label");
    }
    get key() {
      const nodeKey = this.store.key;
      if (this.data)
        return this.data[nodeKey];
      return null;
    }
    get disabled() {
      return getPropertyFromData(this, "disabled");
    }
    get nextSibling() {
      const parent = this.parent;
      if (parent) {
        const index = parent.childNodes.indexOf(this);
        if (index > -1) {
          return parent.childNodes[index + 1];
        }
      }
      return null;
    }
    get previousSibling() {
      const parent = this.parent;
      if (parent) {
        const index = parent.childNodes.indexOf(this);
        if (index > -1) {
          return index > 0 ? parent.childNodes[index - 1] : null;
        }
      }
      return null;
    }
    contains(target, deep = true) {
      return (this.childNodes || []).some((child) => child === target || deep && child.contains(target));
    }
    remove() {
      const parent = this.parent;
      if (parent) {
        parent.removeChild(this);
      }
    }
    insertChild(child, index, batch) {
      if (!child)
        throw new Error("InsertChild error: child is required.");
      if (!(child instanceof Node$1)) {
        if (!batch) {
          const children = this.getChildren(true);
          if (!(children == null ? void 0 : children.includes(child.data))) {
            if (isUndefined(index) || index < 0) {
              children == null ? void 0 : children.push(child.data);
            } else {
              children == null ? void 0 : children.splice(index, 0, child.data);
            }
          }
        }
        Object.assign(child, {
          parent: this,
          store: this.store
        });
        child = vue.reactive(new Node$1(child));
        if (child instanceof Node$1) {
          child.initialize();
        }
      }
      child.level = this.level + 1;
      if (isUndefined(index) || index < 0) {
        this.childNodes.push(child);
      } else {
        this.childNodes.splice(index, 0, child);
      }
      this.updateLeafState();
    }
    insertBefore(child, ref) {
      let index;
      if (ref) {
        index = this.childNodes.indexOf(ref);
      }
      this.insertChild(child, index);
    }
    insertAfter(child, ref) {
      let index;
      if (ref) {
        index = this.childNodes.indexOf(ref);
        if (index !== -1)
          index += 1;
      }
      this.insertChild(child, index);
    }
    removeChild(child) {
      const children = this.getChildren() || [];
      const dataIndex = children.indexOf(child.data);
      if (dataIndex > -1) {
        children.splice(dataIndex, 1);
      }
      const index = this.childNodes.indexOf(child);
      if (index > -1) {
        this.store && this.store.deregisterNode(child);
        child.parent = null;
        this.childNodes.splice(index, 1);
      }
      this.updateLeafState();
    }
    removeChildByData(data) {
      let targetNode = null;
      for (let i = 0; i < this.childNodes.length; i++) {
        if (this.childNodes[i].data === data) {
          targetNode = this.childNodes[i];
          break;
        }
      }
      if (targetNode) {
        this.removeChild(targetNode);
      }
    }
    expand(callback, expandParent) {
      const done = () => {
        if (expandParent) {
          let parent = this.parent;
          while (parent && parent.level > 0) {
            parent.expanded = true;
            parent = parent.parent;
          }
        }
        this.expanded = true;
        if (callback)
          callback();
        setCanFocus(this.childNodes, true);
      };
      if (this.shouldLoadData()) {
        this.loadData((data) => {
          if (isArray$1(data)) {
            if (this.checked) {
              this.setChecked(true, true);
            } else if (!this.store.checkStrictly) {
              reInitChecked(this);
            }
            done();
          }
        });
      } else {
        done();
      }
    }
    doCreateChildren(array, defaultProps = {}) {
      array.forEach((item) => {
        this.insertChild(Object.assign({ data: item }, defaultProps), void 0, true);
      });
    }
    collapse() {
      this.expanded = false;
      setCanFocus(this.childNodes, false);
    }
    shouldLoadData() {
      return Boolean(this.store.lazy === true && this.store.load && !this.loaded);
    }
    updateLeafState() {
      if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
        this.isLeaf = this.isLeafByUser;
        return;
      }
      const childNodes = this.childNodes;
      if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
        this.isLeaf = !childNodes || childNodes.length === 0;
        return;
      }
      this.isLeaf = false;
    }
    setChecked(value, deep, recursion, passValue) {
      this.indeterminate = value === "half";
      this.checked = value === true;
      if (this.store.checkStrictly)
        return;
      if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
        const { all, allWithoutDisable } = getChildState(this.childNodes);
        if (!this.isLeaf && !all && allWithoutDisable) {
          this.checked = false;
          value = false;
        }
        const handleDescendants = () => {
          if (deep) {
            const childNodes = this.childNodes;
            for (let i = 0, j = childNodes.length; i < j; i++) {
              const child = childNodes[i];
              passValue = passValue || value !== false;
              const isCheck = child.disabled ? child.checked : passValue;
              child.setChecked(isCheck, deep, true, passValue);
            }
            const { half, all: all2 } = getChildState(childNodes);
            if (!all2) {
              this.checked = all2;
              this.indeterminate = half;
            }
          }
        };
        if (this.shouldLoadData()) {
          this.loadData(() => {
            handleDescendants();
            reInitChecked(this);
          }, {
            checked: value !== false
          });
          return;
        } else {
          handleDescendants();
        }
      }
      const parent = this.parent;
      if (!parent || parent.level === 0)
        return;
      if (!recursion) {
        reInitChecked(parent);
      }
    }
    getChildren(forceInit = false) {
      if (this.level === 0)
        return this.data;
      const data = this.data;
      if (!data)
        return null;
      const props = this.store.props;
      let children = "children";
      if (props) {
        children = props.children || "children";
      }
      if (isUndefined(data[children])) {
        data[children] = null;
      }
      if (forceInit && !data[children]) {
        data[children] = [];
      }
      return data[children];
    }
    updateChildren() {
      const newData = this.getChildren() || [];
      const oldData = this.childNodes.map((node) => node.data);
      const newDataMap = {};
      const newNodes = [];
      newData.forEach((item, index) => {
        const key = item[NODE_KEY];
        const isNodeExists = !!key && oldData.some((data) => (data == null ? void 0 : data[NODE_KEY]) === key);
        if (isNodeExists) {
          newDataMap[key] = { index, data: item };
        } else {
          newNodes.push({ index, data: item });
        }
      });
      if (!this.store.lazy) {
        oldData.forEach((item) => {
          if (!newDataMap[item == null ? void 0 : item[NODE_KEY]])
            this.removeChildByData(item);
        });
      }
      newNodes.forEach(({ index, data }) => {
        this.insertChild({ data }, index);
      });
      this.updateLeafState();
    }
    loadData(callback, defaultProps = {}) {
      if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
        this.loading = true;
        const resolve = (children) => {
          this.childNodes = [];
          this.doCreateChildren(children, defaultProps);
          this.loaded = true;
          this.loading = false;
          this.updateLeafState();
          if (callback) {
            callback.call(this, children);
          }
        };
        const reject = () => {
          this.loading = false;
        };
        this.store.load(this, resolve, reject);
      } else {
        if (callback) {
          callback.call(this);
        }
      }
    }
    eachNode(callback) {
      const arr = [this];
      while (arr.length) {
        const node = arr.shift();
        arr.unshift(...node.childNodes);
        callback(node);
      }
    }
    reInitChecked() {
      if (this.store.checkStrictly)
        return;
      reInitChecked(this);
    }
  }
  var Node$2 = Node$1;

  class TreeStore {
    constructor(options) {
      this.lazy = false;
      this.checkStrictly = false;
      this.autoExpandParent = false;
      this.defaultExpandAll = false;
      this.checkDescendants = false;
      this.currentNode = null;
      this.currentNodeKey = null;
      for (const option in options) {
        if (hasOwn(options, option)) {
          this[option] = options[option];
        }
      }
      this.nodesMap = {};
    }
    initialize() {
      this.root = new Node$2({
        data: this.data,
        store: this
      });
      this.root.initialize();
      if (this.lazy && this.load) {
        const loadFn = this.load;
        loadFn(this.root, (data) => {
          this.root.doCreateChildren(data);
          this._initDefaultCheckedNodes();
        }, NOOP);
      } else {
        this._initDefaultCheckedNodes();
      }
    }
    filter(value) {
      const filterNodeMethod = this.filterNodeMethod;
      const lazy = this.lazy;
      const traverse = async function(node) {
        const childNodes = node.root ? node.root.childNodes : node.childNodes;
        for (const [index, child] of childNodes.entries()) {
          child.visible = !!(filterNodeMethod == null ? void 0 : filterNodeMethod.call(child, value, child.data, child));
          if (index % 80 === 0 && index > 0) {
            await vue.nextTick();
          }
          await traverse(child);
        }
        if (!node.visible && childNodes.length) {
          let allHidden = true;
          allHidden = !childNodes.some((child) => child.visible);
          if (node.root) {
            node.root.visible = allHidden === false;
          } else {
            node.visible = allHidden === false;
          }
        }
        if (!value)
          return;
        if (node.visible && !node.isLeaf) {
          if (!lazy || node.loaded) {
            node.expand();
          }
        }
      };
      traverse(this);
    }
    setData(newVal) {
      const instanceChanged = newVal !== this.root.data;
      if (instanceChanged) {
        this.nodesMap = {};
        this.root.setData(newVal);
        this._initDefaultCheckedNodes();
        this.setCurrentNodeKey(this.currentNodeKey);
      } else {
        this.root.updateChildren();
      }
    }
    getNode(data) {
      if (data instanceof Node$2)
        return data;
      const key = isObject$1(data) ? getNodeKey(this.key, data) : data;
      return this.nodesMap[key] || null;
    }
    insertBefore(data, refData) {
      var _a;
      const refNode = this.getNode(refData);
      (_a = refNode.parent) == null ? void 0 : _a.insertBefore({ data }, refNode);
    }
    insertAfter(data, refData) {
      var _a;
      const refNode = this.getNode(refData);
      (_a = refNode.parent) == null ? void 0 : _a.insertAfter({ data }, refNode);
    }
    remove(data) {
      const node = this.getNode(data);
      if (node && node.parent) {
        if (node === this.currentNode) {
          this.currentNode = null;
        }
        node.parent.removeChild(node);
      }
    }
    append(data, parentData) {
      const parentNode = !isPropAbsent(parentData) ? this.getNode(parentData) : this.root;
      if (parentNode) {
        parentNode.insertChild({ data });
      }
    }
    _initDefaultCheckedNodes() {
      const defaultCheckedKeys = this.defaultCheckedKeys || [];
      const nodesMap = this.nodesMap;
      defaultCheckedKeys.forEach((checkedKey) => {
        const node = nodesMap[checkedKey];
        if (node) {
          node.setChecked(true, !this.checkStrictly);
        }
      });
    }
    _initDefaultCheckedNode(node) {
      const defaultCheckedKeys = this.defaultCheckedKeys || [];
      if (!isNil(node.key) && defaultCheckedKeys.includes(node.key)) {
        node.setChecked(true, !this.checkStrictly);
      }
    }
    setDefaultCheckedKey(newVal) {
      if (newVal !== this.defaultCheckedKeys) {
        this.defaultCheckedKeys = newVal;
        this._initDefaultCheckedNodes();
      }
    }
    registerNode(node) {
      const key = this.key;
      if (!node || !node.data)
        return;
      if (!key) {
        this.nodesMap[node.id] = node;
      } else {
        const nodeKey = node.key;
        if (!isNil(nodeKey))
          this.nodesMap[nodeKey] = node;
      }
    }
    deregisterNode(node) {
      const key = this.key;
      if (!key || !node || !node.data)
        return;
      node.childNodes.forEach((child) => {
        this.deregisterNode(child);
      });
      delete this.nodesMap[node.key];
    }
    getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
      const checkedNodes = [];
      const traverse = function(node) {
        const childNodes = node.root ? node.root.childNodes : node.childNodes;
        childNodes.forEach((child) => {
          if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
            checkedNodes.push(child.data);
          }
          traverse(child);
        });
      };
      traverse(this);
      return checkedNodes;
    }
    getCheckedKeys(leafOnly = false) {
      return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
    }
    getHalfCheckedNodes() {
      const nodes = [];
      const traverse = function(node) {
        const childNodes = node.root ? node.root.childNodes : node.childNodes;
        childNodes.forEach((child) => {
          if (child.indeterminate) {
            nodes.push(child.data);
          }
          traverse(child);
        });
      };
      traverse(this);
      return nodes;
    }
    getHalfCheckedKeys() {
      return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
    }
    _getAllNodes() {
      const allNodes = [];
      const nodesMap = this.nodesMap;
      for (const nodeKey in nodesMap) {
        if (hasOwn(nodesMap, nodeKey)) {
          allNodes.push(nodesMap[nodeKey]);
        }
      }
      return allNodes;
    }
    updateChildren(key, data) {
      const node = this.nodesMap[key];
      if (!node)
        return;
      const childNodes = node.childNodes;
      for (let i = childNodes.length - 1; i >= 0; i--) {
        const child = childNodes[i];
        this.remove(child.data);
      }
      for (let i = 0, j = data.length; i < j; i++) {
        const child = data[i];
        this.append(child, node.data);
      }
    }
    _setCheckedKeys(key, leafOnly = false, checkedKeys) {
      const allNodes = this._getAllNodes().sort((a, b) => a.level - b.level);
      const cache = /* @__PURE__ */ Object.create(null);
      const keys = Object.keys(checkedKeys);
      allNodes.forEach((node) => node.setChecked(false, false));
      const cacheCheckedChild = (node) => {
        node.childNodes.forEach((child) => {
          var _a;
          cache[child.data[key]] = true;
          if ((_a = child.childNodes) == null ? void 0 : _a.length) {
            cacheCheckedChild(child);
          }
        });
      };
      for (let i = 0, j = allNodes.length; i < j; i++) {
        const node = allNodes[i];
        const nodeKey = node.data[key].toString();
        const checked = keys.includes(nodeKey);
        if (!checked) {
          if (node.checked && !cache[nodeKey]) {
            node.setChecked(false, false);
          }
          continue;
        }
        if (node.childNodes.length) {
          cacheCheckedChild(node);
        }
        if (node.isLeaf || this.checkStrictly) {
          node.setChecked(true, false);
          continue;
        }
        node.setChecked(true, true);
        if (leafOnly) {
          node.setChecked(false, false);
          const traverse = function(node2) {
            const childNodes = node2.childNodes;
            childNodes.forEach((child) => {
              if (!child.isLeaf) {
                child.setChecked(false, false);
              }
              traverse(child);
            });
          };
          traverse(node);
        }
      }
    }
    setCheckedNodes(array, leafOnly = false) {
      const key = this.key;
      const checkedKeys = {};
      array.forEach((item) => {
        checkedKeys[(item || {})[key]] = true;
      });
      this._setCheckedKeys(key, leafOnly, checkedKeys);
    }
    setCheckedKeys(keys, leafOnly = false) {
      this.defaultCheckedKeys = keys;
      const key = this.key;
      const checkedKeys = {};
      keys.forEach((key2) => {
        checkedKeys[key2] = true;
      });
      this._setCheckedKeys(key, leafOnly, checkedKeys);
    }
    setDefaultExpandedKeys(keys) {
      keys = keys || [];
      this.defaultExpandedKeys = keys;
      keys.forEach((key) => {
        const node = this.getNode(key);
        if (node)
          node.expand(null, this.autoExpandParent);
      });
    }
    setChecked(data, checked, deep) {
      const node = this.getNode(data);
      if (node) {
        node.setChecked(!!checked, deep);
      }
    }
    getCurrentNode() {
      return this.currentNode;
    }
    setCurrentNode(currentNode) {
      const prevCurrentNode = this.currentNode;
      if (prevCurrentNode) {
        prevCurrentNode.isCurrent = false;
      }
      this.currentNode = currentNode;
      this.currentNode.isCurrent = true;
    }
    setUserCurrentNode(node, shouldAutoExpandParent = true) {
      var _a;
      const key = node[this.key];
      const currNode = this.nodesMap[key];
      this.setCurrentNode(currNode);
      if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) {
        (_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
      }
    }
    setCurrentNodeKey(key, shouldAutoExpandParent = true) {
      var _a;
      this.currentNodeKey = key;
      if (isPropAbsent(key)) {
        this.currentNode && (this.currentNode.isCurrent = false);
        this.currentNode = null;
        return;
      }
      const node = this.getNode(key);
      if (node) {
        this.setCurrentNode(node);
        if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) {
          (_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
        }
      }
    }
  }

  const ROOT_TREE_INJECTION_KEY$1 = "RootTree";
  const NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
  const TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";

  const _sfc_main$p = vue.defineComponent({
    name: "ElTreeNodeContent",
    props: {
      node: {
        type: Object,
        required: true
      },
      renderContent: Function
    },
    setup(props) {
      const ns = useNamespace("tree");
      const nodeInstance = vue.inject(NODE_INSTANCE_INJECTION_KEY);
      const tree = vue.inject(ROOT_TREE_INJECTION_KEY$1);
      return () => {
        const node = props.node;
        const { data, store } = node;
        return props.renderContent ? props.renderContent(vue.h, { _self: nodeInstance, node, data, store }) : vue.renderSlot(tree.ctx.slots, "default", { node, data }, () => [
          vue.h(ElText, { tag: "span", truncated: true, class: ns.be("node", "label") }, () => [node.label])
        ]);
      };
    }
  });
  var NodeContent = /* @__PURE__ */ _export_sfc(_sfc_main$p, [["__file", "tree-node-content.vue"]]);

  function useNodeExpandEventBroadcast(props) {
    const parentNodeMap = vue.inject(TREE_NODE_MAP_INJECTION_KEY, null);
    const currentNodeMap = {
      treeNodeExpand: (node) => {
        var _a;
        if (props.node !== node) {
          (_a = props.node) == null ? void 0 : _a.collapse();
        }
      },
      children: []
    };
    if (parentNodeMap) {
      parentNodeMap.children.push(currentNodeMap);
    }
    vue.provide(TREE_NODE_MAP_INJECTION_KEY, currentNodeMap);
    return {
      broadcastExpanded: (node) => {
        if (!props.accordion)
          return;
        for (const childNode of currentNodeMap.children) {
          childNode.treeNodeExpand(node);
        }
      }
    };
  }

  const dragEventsKey = Symbol("dragEvents");
  function useDragNodeHandler({
    props,
    ctx,
    el$,
    dropIndicator$,
    store
  }) {
    const ns = useNamespace("tree");
    const dragState = vue.ref({
      showDropIndicator: false,
      draggingNode: null,
      dropNode: null,
      allowDrop: true,
      dropType: null
    });
    const treeNodeDragStart = ({ event, treeNode }) => {
      if (!event.dataTransfer)
        return;
      if (isFunction$1(props.allowDrag) && !props.allowDrag(treeNode.node)) {
        event.preventDefault();
        return false;
      }
      event.dataTransfer.effectAllowed = "move";
      try {
        event.dataTransfer.setData("text/plain", "");
      } catch (e) {
      }
      dragState.value.draggingNode = treeNode;
      ctx.emit("node-drag-start", treeNode.node, event);
    };
    const treeNodeDragOver = ({ event, treeNode }) => {
      if (!event.dataTransfer)
        return;
      const dropNode = treeNode;
      const oldDropNode = dragState.value.dropNode;
      if (oldDropNode && oldDropNode.node.id !== dropNode.node.id) {
        removeClass(oldDropNode.$el, ns.is("drop-inner"));
      }
      const draggingNode = dragState.value.draggingNode;
      if (!draggingNode || !dropNode)
        return;
      let dropPrev = true;
      let dropInner = true;
      let dropNext = true;
      let userAllowDropInner = true;
      if (isFunction$1(props.allowDrop)) {
        dropPrev = props.allowDrop(draggingNode.node, dropNode.node, "prev");
        userAllowDropInner = dropInner = props.allowDrop(draggingNode.node, dropNode.node, "inner");
        dropNext = props.allowDrop(draggingNode.node, dropNode.node, "next");
      }
      event.dataTransfer.dropEffect = dropInner || dropPrev || dropNext ? "move" : "none";
      if ((dropPrev || dropInner || dropNext) && (oldDropNode == null ? void 0 : oldDropNode.node.id) !== dropNode.node.id) {
        if (oldDropNode) {
          ctx.emit("node-drag-leave", draggingNode.node, oldDropNode.node, event);
        }
        ctx.emit("node-drag-enter", draggingNode.node, dropNode.node, event);
      }
      if (dropPrev || dropInner || dropNext) {
        dragState.value.dropNode = dropNode;
      } else {
        dragState.value.dropNode = null;
      }
      if (dropNode.node.nextSibling === draggingNode.node) {
        dropNext = false;
      }
      if (dropNode.node.previousSibling === draggingNode.node) {
        dropPrev = false;
      }
      if (dropNode.node.contains(draggingNode.node, false)) {
        dropInner = false;
      }
      if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
        dropPrev = false;
        dropInner = false;
        dropNext = false;
      }
      const dropEl = dropNode.$el;
      const targetPosition = dropEl.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
      const treePosition = el$.value.getBoundingClientRect();
      const treeScrollTop = el$.value.scrollTop;
      let dropType;
      const prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : Number.NEGATIVE_INFINITY;
      const nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : Number.POSITIVE_INFINITY;
      let indicatorTop = -9999;
      const distance = event.clientY - targetPosition.top;
      if (distance < targetPosition.height * prevPercent) {
        dropType = "before";
      } else if (distance > targetPosition.height * nextPercent) {
        dropType = "after";
      } else if (dropInner) {
        dropType = "inner";
      } else {
        dropType = "none";
      }
      const iconPosition = dropEl.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
      const dropIndicator = dropIndicator$.value;
      if (dropType === "before") {
        indicatorTop = iconPosition.top - treePosition.top + treeScrollTop;
      } else if (dropType === "after") {
        indicatorTop = iconPosition.bottom - treePosition.top + treeScrollTop;
      }
      dropIndicator.style.top = `${indicatorTop}px`;
      dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
      if (dropType === "inner") {
        addClass(dropEl, ns.is("drop-inner"));
      } else {
        removeClass(dropEl, ns.is("drop-inner"));
      }
      dragState.value.showDropIndicator = dropType === "before" || dropType === "after";
      dragState.value.allowDrop = dragState.value.showDropIndicator || userAllowDropInner;
      dragState.value.dropType = dropType;
      ctx.emit("node-drag-over", draggingNode.node, dropNode.node, event);
    };
    const treeNodeDragEnd = (event) => {
      var _a, _b;
      const { draggingNode, dropType, dropNode } = dragState.value;
      event.preventDefault();
      if (event.dataTransfer) {
        event.dataTransfer.dropEffect = "move";
      }
      if ((draggingNode == null ? void 0 : draggingNode.node.data) && dropNode) {
        const draggingNodeCopy = { data: draggingNode.node.data };
        if (dropType !== "none") {
          draggingNode.node.remove();
        }
        if (dropType === "before") {
          (_a = dropNode.node.parent) == null ? void 0 : _a.insertBefore(draggingNodeCopy, dropNode.node);
        } else if (dropType === "after") {
          (_b = dropNode.node.parent) == null ? void 0 : _b.insertAfter(draggingNodeCopy, dropNode.node);
        } else if (dropType === "inner") {
          dropNode.node.insertChild(draggingNodeCopy);
        }
        if (dropType !== "none") {
          store.value.registerNode(draggingNodeCopy);
          if (store.value.key) {
            draggingNode.node.eachNode((node) => {
              var _a2;
              (_a2 = store.value.nodesMap[node.data[store.value.key]]) == null ? void 0 : _a2.setChecked(node.checked, !store.value.checkStrictly);
            });
          }
        }
        removeClass(dropNode.$el, ns.is("drop-inner"));
        ctx.emit("node-drag-end", draggingNode.node, dropNode.node, dropType, event);
        if (dropType !== "none") {
          ctx.emit("node-drop", draggingNode.node, dropNode.node, dropType, event);
        }
      }
      if (draggingNode && !dropNode) {
        ctx.emit("node-drag-end", draggingNode.node, null, dropType, event);
      }
      dragState.value.showDropIndicator = false;
      dragState.value.draggingNode = null;
      dragState.value.dropNode = null;
      dragState.value.allowDrop = true;
    };
    vue.provide(dragEventsKey, {
      treeNodeDragStart,
      treeNodeDragOver,
      treeNodeDragEnd
    });
    return {
      dragState
    };
  }

  const _sfc_main$o = vue.defineComponent({
    name: "ElTreeNode",
    components: {
      ElCollapseTransition,
      ElCheckbox,
      NodeContent,
      ElIcon,
      Loading: loading_default
    },
    props: {
      node: {
        type: Node$2,
        default: () => ({})
      },
      props: {
        type: Object,
        default: () => ({})
      },
      accordion: Boolean,
      renderContent: Function,
      renderAfterExpand: Boolean,
      showCheckbox: Boolean
    },
    emits: ["node-expand"],
    setup(props, ctx) {
      const ns = useNamespace("tree");
      const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
      const tree = vue.inject(ROOT_TREE_INJECTION_KEY$1);
      const expanded = vue.ref(false);
      const childNodeRendered = vue.ref(false);
      const oldChecked = vue.ref();
      const oldIndeterminate = vue.ref();
      const node$ = vue.ref();
      const dragEvents = vue.inject(dragEventsKey);
      const instance = vue.getCurrentInstance();
      vue.provide(NODE_INSTANCE_INJECTION_KEY, instance);
      if (!tree) {
        debugWarn("Tree", "Can not find node's tree.");
      }
      if (props.node.expanded) {
        expanded.value = true;
        childNodeRendered.value = true;
      }
      const childrenKey = tree.props.props["children"] || "children";
      vue.watch(() => {
        var _a;
        const children = (_a = props.node.data) == null ? void 0 : _a[childrenKey];
        return children && [...children];
      }, () => {
        props.node.updateChildren();
      });
      vue.watch(() => props.node.indeterminate, (val) => {
        handleSelectChange(props.node.checked, val);
      });
      vue.watch(() => props.node.checked, (val) => {
        handleSelectChange(val, props.node.indeterminate);
      });
      vue.watch(() => props.node.childNodes.length, () => props.node.reInitChecked());
      vue.watch(() => props.node.expanded, (val) => {
        vue.nextTick(() => expanded.value = val);
        if (val) {
          childNodeRendered.value = true;
        }
      });
      const getNodeKey$1 = (node) => {
        return getNodeKey(tree.props.nodeKey, node.data);
      };
      const getNodeClass = (node) => {
        const nodeClassFunc = props.props.class;
        if (!nodeClassFunc) {
          return {};
        }
        let className;
        if (isFunction$1(nodeClassFunc)) {
          const { data } = node;
          className = nodeClassFunc(data, node);
        } else {
          className = nodeClassFunc;
        }
        if (isString$1(className)) {
          return { [className]: true };
        } else {
          return className;
        }
      };
      const handleSelectChange = (checked, indeterminate) => {
        if (oldChecked.value !== checked || oldIndeterminate.value !== indeterminate) {
          tree.ctx.emit("check-change", props.node.data, checked, indeterminate);
        }
        oldChecked.value = checked;
        oldIndeterminate.value = indeterminate;
      };
      const handleClick = (e) => {
        handleCurrentChange(tree.store, tree.ctx.emit, () => {
          var _a;
          const nodeKeyProp = (_a = tree == null ? void 0 : tree.props) == null ? void 0 : _a.nodeKey;
          if (nodeKeyProp) {
            const curNodeKey = getNodeKey$1(props.node);
            tree.store.value.setCurrentNodeKey(curNodeKey);
          } else {
            tree.store.value.setCurrentNode(props.node);
          }
        });
        tree.currentNode.value = props.node;
        if (tree.props.expandOnClickNode) {
          handleExpandIconClick();
        }
        if ((tree.props.checkOnClickNode || props.node.isLeaf && tree.props.checkOnClickLeaf && props.showCheckbox) && !props.node.disabled) {
          handleCheckChange(!props.node.checked);
        }
        tree.ctx.emit("node-click", props.node.data, props.node, instance, e);
      };
      const handleContextMenu = (event) => {
        var _a;
        if ((_a = tree.instance.vnode.props) == null ? void 0 : _a["onNodeContextmenu"]) {
          event.stopPropagation();
          event.preventDefault();
        }
        tree.ctx.emit("node-contextmenu", event, props.node.data, props.node, instance);
      };
      const handleExpandIconClick = () => {
        if (props.node.isLeaf)
          return;
        if (expanded.value) {
          tree.ctx.emit("node-collapse", props.node.data, props.node, instance);
          props.node.collapse();
        } else {
          props.node.expand(() => {
            ctx.emit("node-expand", props.node.data, props.node, instance);
          });
        }
      };
      const handleCheckChange = (value) => {
        props.node.setChecked(value, !(tree == null ? void 0 : tree.props.checkStrictly));
        vue.nextTick(() => {
          const store = tree.store.value;
          tree.ctx.emit("check", props.node.data, {
            checkedNodes: store.getCheckedNodes(),
            checkedKeys: store.getCheckedKeys(),
            halfCheckedNodes: store.getHalfCheckedNodes(),
            halfCheckedKeys: store.getHalfCheckedKeys()
          });
        });
      };
      const handleChildNodeExpand = (nodeData, node, instance2) => {
        broadcastExpanded(node);
        tree.ctx.emit("node-expand", nodeData, node, instance2);
      };
      const handleDragStart = (event) => {
        if (!tree.props.draggable)
          return;
        dragEvents.treeNodeDragStart({ event, treeNode: props });
      };
      const handleDragOver = (event) => {
        event.preventDefault();
        if (!tree.props.draggable)
          return;
        dragEvents.treeNodeDragOver({
          event,
          treeNode: { $el: node$.value, node: props.node }
        });
      };
      const handleDrop = (event) => {
        event.preventDefault();
      };
      const handleDragEnd = (event) => {
        if (!tree.props.draggable)
          return;
        dragEvents.treeNodeDragEnd(event);
      };
      return {
        ns,
        node$,
        tree,
        expanded,
        childNodeRendered,
        oldChecked,
        oldIndeterminate,
        getNodeKey: getNodeKey$1,
        getNodeClass,
        handleSelectChange,
        handleClick,
        handleContextMenu,
        handleExpandIconClick,
        handleCheckChange,
        handleChildNodeExpand,
        handleDragStart,
        handleDragOver,
        handleDrop,
        handleDragEnd,
        CaretRight: caret_right_default
      };
    }
  });
  function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_icon = vue.resolveComponent("el-icon");
    const _component_el_checkbox = vue.resolveComponent("el-checkbox");
    const _component_loading = vue.resolveComponent("loading");
    const _component_node_content = vue.resolveComponent("node-content");
    const _component_el_tree_node = vue.resolveComponent("el-tree-node");
    const _component_el_collapse_transition = vue.resolveComponent("el-collapse-transition");
    return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
      ref: "node$",
      class: vue.normalizeClass([
        _ctx.ns.b("node"),
        _ctx.ns.is("expanded", _ctx.expanded),
        _ctx.ns.is("current", _ctx.node.isCurrent),
        _ctx.ns.is("hidden", !_ctx.node.visible),
        _ctx.ns.is("focusable", !_ctx.node.disabled),
        _ctx.ns.is("checked", !_ctx.node.disabled && _ctx.node.checked),
        _ctx.getNodeClass(_ctx.node)
      ]),
      role: "treeitem",
      tabindex: "-1",
      "aria-expanded": _ctx.expanded,
      "aria-disabled": _ctx.node.disabled,
      "aria-checked": _ctx.node.checked,
      draggable: _ctx.tree.props.draggable,
      "data-key": _ctx.getNodeKey(_ctx.node),
      onClick: vue.withModifiers(_ctx.handleClick, ["stop"]),
      onContextmenu: _ctx.handleContextMenu,
      onDragstart: vue.withModifiers(_ctx.handleDragStart, ["stop"]),
      onDragover: vue.withModifiers(_ctx.handleDragOver, ["stop"]),
      onDragend: vue.withModifiers(_ctx.handleDragEnd, ["stop"]),
      onDrop: vue.withModifiers(_ctx.handleDrop, ["stop"])
    }, [
      vue.createElementVNode("div", {
        class: vue.normalizeClass(_ctx.ns.be("node", "content")),
        style: vue.normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
      }, [
        _ctx.tree.props.icon || _ctx.CaretRight ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
          key: 0,
          class: vue.normalizeClass([
            _ctx.ns.be("node", "expand-icon"),
            _ctx.ns.is("leaf", _ctx.node.isLeaf),
            {
              expanded: !_ctx.node.isLeaf && _ctx.expanded
            }
          ]),
          onClick: vue.withModifiers(_ctx.handleExpandIconClick, ["stop"])
        }, {
          default: vue.withCtx(() => [
            (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))
          ]),
          _: 1
        }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
        _ctx.showCheckbox ? (vue.openBlock(), vue.createBlock(_component_el_checkbox, {
          key: 1,
          "model-value": _ctx.node.checked,
          indeterminate: _ctx.node.indeterminate,
          disabled: !!_ctx.node.disabled,
          onClick: vue.withModifiers(() => {
          }, ["stop"]),
          onChange: _ctx.handleCheckChange
        }, null, 8, ["model-value", "indeterminate", "disabled", "onClick", "onChange"])) : vue.createCommentVNode("v-if", true),
        _ctx.node.loading ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
          key: 2,
          class: vue.normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
        }, {
          default: vue.withCtx(() => [
            vue.createVNode(_component_loading)
          ]),
          _: 1
        }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
        vue.createVNode(_component_node_content, {
          node: _ctx.node,
          "render-content": _ctx.renderContent
        }, null, 8, ["node", "render-content"])
      ], 6),
      vue.createVNode(_component_el_collapse_transition, null, {
        default: vue.withCtx(() => [
          !_ctx.renderAfterExpand || _ctx.childNodeRendered ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(_ctx.ns.be("node", "children")),
            role: "group",
            "aria-expanded": _ctx.expanded,
            onClick: vue.withModifiers(() => {
            }, ["stop"])
          }, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.node.childNodes, (child) => {
              return vue.openBlock(), vue.createBlock(_component_el_tree_node, {
                key: _ctx.getNodeKey(child),
                "render-content": _ctx.renderContent,
                "render-after-expand": _ctx.renderAfterExpand,
                "show-checkbox": _ctx.showCheckbox,
                node: child,
                accordion: _ctx.accordion,
                props: _ctx.props,
                onNodeExpand: _ctx.handleChildNodeExpand
              }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]);
            }), 128))
          ], 10, ["aria-expanded", "onClick"])), [
            [vue.vShow, _ctx.expanded]
          ]) : vue.createCommentVNode("v-if", true)
        ]),
        _: 1
      })
    ], 42, ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key", "onClick", "onContextmenu", "onDragstart", "onDragover", "onDragend", "onDrop"])), [
      [vue.vShow, _ctx.node.visible]
    ]);
  }
  var ElTreeNode$1 = /* @__PURE__ */ _export_sfc(_sfc_main$o, [["render", _sfc_render$2], ["__file", "tree-node.vue"]]);

  function useKeydown({ el$ }, store) {
    const ns = useNamespace("tree");
    vue.onMounted(() => {
      initTabIndex();
    });
    vue.onUpdated(() => {
      const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
      checkboxItems.forEach((checkbox) => {
        checkbox.setAttribute("tabindex", "-1");
      });
    });
    function canNodeFocus(treeItems, nextIndex) {
      var _a, _b;
      const currentNode = store.value.getNode(treeItems[nextIndex].dataset.key);
      return currentNode.canFocus && currentNode.visible && (((_a = currentNode.parent) == null ? void 0 : _a.expanded) || ((_b = currentNode.parent) == null ? void 0 : _b.level) === 0);
    }
    const handleKeydown = (ev) => {
      const currentItem = ev.target;
      if (!currentItem.className.includes(ns.b("node")))
        return;
      const code = getEventCode(ev);
      const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
      const currentIndex = treeItems.indexOf(currentItem);
      let nextIndex;
      if ([EVENT_CODE.up, EVENT_CODE.down].includes(code)) {
        ev.preventDefault();
        if (code === EVENT_CODE.up) {
          nextIndex = currentIndex === -1 ? 0 : currentIndex !== 0 ? currentIndex - 1 : treeItems.length - 1;
          const startIndex = nextIndex;
          while (true) {
            if (canNodeFocus(treeItems, nextIndex)) {
              break;
            }
            nextIndex--;
            if (nextIndex === startIndex) {
              nextIndex = -1;
              break;
            }
            if (nextIndex < 0) {
              nextIndex = treeItems.length - 1;
            }
          }
        } else {
          nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.length - 1 ? currentIndex + 1 : 0;
          const startIndex = nextIndex;
          while (true) {
            if (canNodeFocus(treeItems, nextIndex)) {
              break;
            }
            nextIndex++;
            if (nextIndex === startIndex) {
              nextIndex = -1;
              break;
            }
            if (nextIndex >= treeItems.length) {
              nextIndex = 0;
            }
          }
        }
        nextIndex !== -1 && treeItems[nextIndex].focus();
      }
      if ([EVENT_CODE.left, EVENT_CODE.right].includes(code)) {
        ev.preventDefault();
        currentItem.click();
      }
      const hasInput = currentItem.querySelector('[type="checkbox"]');
      if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space].includes(code) && hasInput) {
        ev.preventDefault();
        hasInput.click();
      }
    };
    useEventListener(el$, "keydown", handleKeydown);
    const initTabIndex = () => {
      var _a;
      if (!el$.value)
        return;
      const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
      const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
      checkboxItems.forEach((checkbox) => {
        checkbox.setAttribute("tabindex", "-1");
      });
      const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
      if (checkedItem.length) {
        checkedItem[0].setAttribute("tabindex", "0");
        return;
      }
      (_a = treeItems[0]) == null ? void 0 : _a.setAttribute("tabindex", "0");
    };
  }

  const treeEmits$1 = {
    "check-change": (data, checked, indeterminate) => data && isBoolean(checked) && isBoolean(indeterminate),
    "current-change": (data, node) => true,
    "node-click": (data, node, nodeInstance, evt) => data && node && evt instanceof Event,
    "node-contextmenu": (evt, data, node, nodeInstance) => evt instanceof Event && data && node,
    "node-collapse": (data, node, nodeInstance) => data && node,
    "node-expand": (data, node, nodeInstance) => data && node,
    check: (data, checkedInfo) => data && checkedInfo,
    "node-drag-start": (node, evt) => node && evt,
    "node-drag-end": (draggingNode, dropNode, dropType, evt) => draggingNode && evt,
    "node-drop": (draggingNode, dropNode, dropType, evt) => draggingNode && dropNode && evt,
    "node-drag-leave": (draggingNode, oldDropNode, evt) => draggingNode && oldDropNode && evt,
    "node-drag-enter": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt,
    "node-drag-over": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt
  };

  const _sfc_main$n = vue.defineComponent({
    name: "ElTree",
    components: { ElTreeNode: ElTreeNode$1 },
    props: {
      data: {
        type: definePropType(Array),
        default: () => []
      },
      emptyText: {
        type: String
      },
      renderAfterExpand: {
        type: Boolean,
        default: true
      },
      nodeKey: String,
      checkStrictly: Boolean,
      defaultExpandAll: Boolean,
      expandOnClickNode: {
        type: Boolean,
        default: true
      },
      checkOnClickNode: Boolean,
      checkOnClickLeaf: {
        type: Boolean,
        default: true
      },
      checkDescendants: Boolean,
      autoExpandParent: {
        type: Boolean,
        default: true
      },
      defaultCheckedKeys: Array,
      defaultExpandedKeys: Array,
      currentNodeKey: [String, Number],
      renderContent: {
        type: definePropType(Function)
      },
      showCheckbox: Boolean,
      draggable: Boolean,
      allowDrag: {
        type: definePropType(Function)
      },
      allowDrop: {
        type: definePropType(Function)
      },
      props: {
        type: Object,
        default: () => ({
          children: "children",
          label: "label",
          disabled: "disabled"
        })
      },
      lazy: Boolean,
      highlightCurrent: Boolean,
      load: Function,
      filterNodeMethod: Function,
      accordion: Boolean,
      indent: {
        type: Number,
        default: 18
      },
      icon: {
        type: iconPropType
      }
    },
    emits: treeEmits$1,
    setup(props, ctx) {
      const { t } = useLocale();
      const ns = useNamespace("tree");
      const store = vue.ref(new TreeStore({
        key: props.nodeKey,
        data: props.data,
        lazy: props.lazy,
        props: props.props,
        load: props.load,
        currentNodeKey: props.currentNodeKey,
        checkStrictly: props.checkStrictly,
        checkDescendants: props.checkDescendants,
        defaultCheckedKeys: props.defaultCheckedKeys,
        defaultExpandedKeys: props.defaultExpandedKeys,
        autoExpandParent: props.autoExpandParent,
        defaultExpandAll: props.defaultExpandAll,
        filterNodeMethod: props.filterNodeMethod
      }));
      store.value.initialize();
      const root = vue.ref(store.value.root);
      const currentNode = vue.ref(null);
      const el$ = vue.ref(null);
      const dropIndicator$ = vue.ref(null);
      const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
      const { dragState } = useDragNodeHandler({
        props,
        ctx,
        el$,
        dropIndicator$,
        store
      });
      useKeydown({ el$ }, store);
      const instance = vue.getCurrentInstance();
      const isSelectTree = vue.computed(() => {
        let parent = instance == null ? void 0 : instance.parent;
        while (parent) {
          if (parent.type.name === "ElTreeSelect") {
            return true;
          }
          parent = parent.parent;
        }
        return false;
      });
      const isEmpty = vue.computed(() => {
        const { childNodes } = root.value;
        return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
      });
      vue.watch(() => props.currentNodeKey, (newVal) => {
        store.value.setCurrentNodeKey(newVal != null ? newVal : null);
      });
      vue.watch(() => props.defaultCheckedKeys, (newVal, oldVal) => {
        if (isEqual$1(newVal, oldVal))
          return;
        store.value.setDefaultCheckedKey(newVal != null ? newVal : []);
      });
      vue.watch(() => props.defaultExpandedKeys, (newVal) => {
        store.value.setDefaultExpandedKeys(newVal != null ? newVal : []);
      });
      vue.watch(() => props.data, (newVal) => {
        store.value.setData(newVal);
      }, { deep: true });
      vue.watch(() => props.checkStrictly, (newVal) => {
        store.value.checkStrictly = newVal;
      });
      const filter = (value) => {
        if (!props.filterNodeMethod)
          throw new Error("[Tree] filterNodeMethod is required when filter");
        store.value.filter(value);
      };
      const getNodeKey$1 = (node) => {
        return getNodeKey(props.nodeKey, node.data);
      };
      const getNodePath = (data) => {
        if (!props.nodeKey)
          throw new Error("[Tree] nodeKey is required in getNodePath");
        const node = store.value.getNode(data);
        if (!node)
          return [];
        const path = [node.data];
        let parent = node.parent;
        while (parent && parent !== root.value) {
          path.push(parent.data);
          parent = parent.parent;
        }
        return path.reverse();
      };
      const getCheckedNodes = (leafOnly, includeHalfChecked) => {
        return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
      };
      const getCheckedKeys = (leafOnly) => {
        return store.value.getCheckedKeys(leafOnly);
      };
      const getCurrentNode = () => {
        const currentNode2 = store.value.getCurrentNode();
        return currentNode2 ? currentNode2.data : null;
      };
      const getCurrentKey = () => {
        if (!props.nodeKey)
          throw new Error("[Tree] nodeKey is required in getCurrentKey");
        const currentNode2 = getCurrentNode();
        return currentNode2 ? currentNode2[props.nodeKey] : null;
      };
      const setCheckedNodes = (nodes, leafOnly) => {
        if (!props.nodeKey)
          throw new Error("[Tree] nodeKey is required in setCheckedNodes");
        store.value.setCheckedNodes(nodes, leafOnly);
      };
      const setCheckedKeys = (keys, leafOnly) => {
        if (!props.nodeKey)
          throw new Error("[Tree] nodeKey is required in setCheckedKeys");
        store.value.setCheckedKeys(keys, leafOnly);
      };
      const setChecked = (data, checked, deep) => {
        store.value.setChecked(data, checked, deep);
      };
      const getHalfCheckedNodes = () => {
        return store.value.getHalfCheckedNodes();
      };
      const getHalfCheckedKeys = () => {
        return store.value.getHalfCheckedKeys();
      };
      const setCurrentNode = (node, shouldAutoExpandParent = true) => {
        if (!props.nodeKey)
          throw new Error("[Tree] nodeKey is required in setCurrentNode");
        handleCurrentChange(store, ctx.emit, () => {
          broadcastExpanded(node);
          store.value.setUserCurrentNode(node, shouldAutoExpandParent);
        });
      };
      const setCurrentKey = (key = null, shouldAutoExpandParent = true) => {
        if (!props.nodeKey)
          throw new Error("[Tree] nodeKey is required in setCurrentKey");
        handleCurrentChange(store, ctx.emit, () => {
          broadcastExpanded();
          store.value.setCurrentNodeKey(key, shouldAutoExpandParent);
        });
      };
      const getNode = (data) => {
        return store.value.getNode(data);
      };
      const remove = (data) => {
        store.value.remove(data);
      };
      const append = (data, parentNode) => {
        store.value.append(data, parentNode);
      };
      const insertBefore = (data, refNode) => {
        store.value.insertBefore(data, refNode);
      };
      const insertAfter = (data, refNode) => {
        store.value.insertAfter(data, refNode);
      };
      const handleNodeExpand = (nodeData, node, instance2) => {
        broadcastExpanded(node);
        ctx.emit("node-expand", nodeData, node, instance2);
      };
      const updateKeyChildren = (key, data) => {
        if (!props.nodeKey)
          throw new Error("[Tree] nodeKey is required in updateKeyChild");
        store.value.updateChildren(key, data);
      };
      vue.provide(ROOT_TREE_INJECTION_KEY$1, {
        ctx,
        props,
        store,
        root,
        currentNode,
        instance
      });
      vue.provide(formItemContextKey, void 0);
      return {
        ns,
        store,
        root,
        currentNode,
        dragState,
        el$,
        dropIndicator$,
        isEmpty,
        filter,
        getNodeKey: getNodeKey$1,
        getNodePath,
        getCheckedNodes,
        getCheckedKeys,
        getCurrentNode,
        getCurrentKey,
        setCheckedNodes,
        setCheckedKeys,
        setChecked,
        getHalfCheckedNodes,
        getHalfCheckedKeys,
        setCurrentNode,
        setCurrentKey,
        t,
        getNode,
        remove,
        append,
        insertBefore,
        insertAfter,
        handleNodeExpand,
        updateKeyChildren
      };
    }
  });
  function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_tree_node = vue.resolveComponent("el-tree-node");
    return vue.openBlock(), vue.createElementBlock("div", {
      ref: "el$",
      class: vue.normalizeClass([
        _ctx.ns.b(),
        _ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
        _ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
        _ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
        { [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
      ]),
      role: "tree"
    }, [
      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.root.childNodes, (child) => {
        return vue.openBlock(), vue.createBlock(_component_el_tree_node, {
          key: _ctx.getNodeKey(child),
          node: child,
          props: _ctx.props,
          accordion: _ctx.accordion,
          "render-after-expand": _ctx.renderAfterExpand,
          "show-checkbox": _ctx.showCheckbox,
          "render-content": _ctx.renderContent,
          onNodeExpand: _ctx.handleNodeExpand
        }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]);
      }), 128)),
      _ctx.isEmpty ? (vue.openBlock(), vue.createElementBlock("div", {
        key: 0,
        class: vue.normalizeClass(_ctx.ns.e("empty-block"))
      }, [
        vue.renderSlot(_ctx.$slots, "empty", {}, () => {
          var _a;
          return [
            vue.createElementVNode("span", {
              class: vue.normalizeClass(_ctx.ns.e("empty-text"))
            }, vue.toDisplayString((_a = _ctx.emptyText) != null ? _a : _ctx.t("el.tree.emptyText")), 3)
          ];
        })
      ], 2)) : vue.createCommentVNode("v-if", true),
      vue.withDirectives(vue.createElementVNode("div", {
        ref: "dropIndicator$",
        class: vue.normalizeClass(_ctx.ns.e("drop-indicator"))
      }, null, 2), [
        [vue.vShow, _ctx.dragState.showDropIndicator]
      ])
    ], 2);
  }
  var Tree = /* @__PURE__ */ _export_sfc(_sfc_main$n, [["render", _sfc_render$1], ["__file", "tree.vue"]]);

  const ElTree = withInstall(Tree);

  const useSelect = (props, { attrs, emit }, {
    select,
    tree,
    key
  }) => {
    const ns = useNamespace("tree-select");
    vue.watch(() => props.data, () => {
      if (props.filterable) {
        vue.nextTick(() => {
          var _a, _b;
          (_b = tree.value) == null ? void 0 : _b.filter((_a = select.value) == null ? void 0 : _a.states.inputValue);
        });
      }
    }, { flush: "post" });
    const result = {
      ...pick(vue.toRefs(props), Object.keys(ElSelect.props)),
      ...attrs,
      class: vue.computed(() => attrs.class),
      style: vue.computed(() => attrs.style),
      "onUpdate:modelValue": (value) => emit(UPDATE_MODEL_EVENT, value),
      valueKey: key,
      popperClass: vue.computed(() => {
        const classes = [ns.e("popper")];
        if (props.popperClass)
          classes.push(props.popperClass);
        return classes.join(" ");
      }),
      filterMethod: (keyword = "") => {
        var _a;
        if (props.filterMethod) {
          props.filterMethod(keyword);
        } else if (props.remoteMethod) {
          props.remoteMethod(keyword);
        } else {
          (_a = tree.value) == null ? void 0 : _a.filter(keyword);
        }
      }
    };
    return result;
  };

  const component = vue.defineComponent({
    extends: ElOption,
    setup(props, ctx) {
      const result = ElOption.setup(props, ctx);
      delete result.selectOptionClick;
      const vm = vue.getCurrentInstance().proxy;
      vue.nextTick(() => {
        if (!result.select.states.cachedOptions.get(vm.value)) {
          result.select.onOptionCreate(vm);
        }
      });
      vue.watch(() => ctx.attrs.visible, (val) => {
        vue.nextTick(() => {
          result.states.visible = val;
        });
      }, {
        immediate: true
      });
      return result;
    },
    methods: {
      selectOptionClick() {
        this.$el.parentElement.click();
      }
    }
  });
  var TreeSelectOption = component;

  function isValidValue(val) {
    return val || val === 0;
  }
  function isValidArray(val) {
    return isArray$1(val) && val.length;
  }
  function toValidArray(val) {
    return isArray$1(val) ? val : isValidValue(val) ? [val] : [];
  }
  function treeFind(treeData, findCallback, getChildren, resultCallback, parent) {
    for (let i = 0; i < treeData.length; i++) {
      const data = treeData[i];
      if (findCallback(data, i, treeData, parent)) {
        return resultCallback ? resultCallback(data, i, treeData, parent) : data;
      } else {
        const children = getChildren(data);
        if (isValidArray(children)) {
          const find = treeFind(children, findCallback, getChildren, resultCallback, data);
          if (find)
            return find;
        }
      }
    }
  }
  function treeEach(treeData, callback, getChildren, parent) {
    for (let i = 0; i < treeData.length; i++) {
      const data = treeData[i];
      callback(data, i, treeData, parent);
      const children = getChildren(data);
      if (isValidArray(children)) {
        treeEach(children, callback, getChildren, data);
      }
    }
  }

  const useTree$1 = (props, { attrs, slots, emit }, {
    select,
    tree,
    key
  }) => {
    vue.watch([() => props.modelValue, tree], () => {
      if (props.showCheckbox) {
        vue.nextTick(() => {
          const treeInstance = tree.value;
          if (treeInstance && !isEqual$1(treeInstance.getCheckedKeys(), toValidArray(props.modelValue))) {
            treeInstance.setCheckedKeys(toValidArray(props.modelValue));
          }
        });
      }
    }, {
      immediate: true,
      deep: true
    });
    const propsMap = vue.computed(() => ({
      value: key.value,
      label: "label",
      children: "children",
      disabled: "disabled",
      isLeaf: "isLeaf",
      ...props.props
    }));
    const getNodeValByProp = (prop, data) => {
      var _a;
      const propVal = propsMap.value[prop];
      if (isFunction$1(propVal)) {
        return propVal(data, (_a = tree.value) == null ? void 0 : _a.getNode(getNodeValByProp("value", data)));
      } else {
        return data[propVal];
      }
    };
    const defaultExpandedParentKeys = toValidArray(props.modelValue).map((value) => {
      return treeFind(props.data || [], (data) => getNodeValByProp("value", data) === value, (data) => getNodeValByProp("children", data), (data, index, array, parent) => parent && getNodeValByProp("value", parent));
    }).filter((item) => isValidValue(item));
    const cacheOptions = vue.computed(() => {
      if (!props.renderAfterExpand && !props.lazy)
        return [];
      const options = [];
      treeEach(props.data.concat(props.cacheData), (node) => {
        const value = getNodeValByProp("value", node);
        options.push({
          value,
          currentLabel: getNodeValByProp("label", node),
          isDisabled: getNodeValByProp("disabled", node)
        });
      }, (data) => getNodeValByProp("children", data));
      return options;
    });
    const getChildCheckedKeys = () => {
      var _a;
      return (_a = tree.value) == null ? void 0 : _a.getCheckedKeys().filter((checkedKey) => {
        var _a2;
        const node = (_a2 = tree.value) == null ? void 0 : _a2.getNode(checkedKey);
        return !isNil(node) && isEmpty(node.childNodes);
      });
    };
    return {
      ...pick(vue.toRefs(props), Object.keys(ElTree.props)),
      ...attrs,
      nodeKey: key,
      expandOnClickNode: vue.computed(() => {
        return !props.checkStrictly && props.expandOnClickNode;
      }),
      defaultExpandedKeys: vue.computed(() => {
        return props.defaultExpandedKeys ? props.defaultExpandedKeys.concat(defaultExpandedParentKeys) : defaultExpandedParentKeys;
      }),
      renderContent: (h, { node, data, store }) => {
        return h(TreeSelectOption, {
          value: getNodeValByProp("value", data),
          label: getNodeValByProp("label", data),
          disabled: getNodeValByProp("disabled", data),
          visible: node.visible
        }, props.renderContent ? () => props.renderContent(h, { node, data, store }) : slots.default ? () => slots.default({ node, data, store }) : void 0);
      },
      filterNodeMethod: (value, data, node) => {
        if (props.filterNodeMethod)
          return props.filterNodeMethod(value, data, node);
        if (!value)
          return true;
        const regexp = new RegExp(escapeStringRegexp(value), "i");
        return regexp.test(getNodeValByProp("label", data) || "");
      },
      onNodeClick: (data, node, e) => {
        var _a, _b, _c, _d;
        (_a = attrs.onNodeClick) == null ? void 0 : _a.call(attrs, data, node, e);
        if (props.showCheckbox && props.checkOnClickNode)
          return;
        if (!props.showCheckbox && (props.checkStrictly || node.isLeaf)) {
          if (!getNodeValByProp("disabled", data)) {
            const option = (_b = select.value) == null ? void 0 : _b.states.options.get(getNodeValByProp("value", data));
            (_c = select.value) == null ? void 0 : _c.handleOptionSelect(option);
          }
        } else if (props.expandOnClickNode) {
          e.proxy.handleExpandIconClick();
        }
        (_d = select.value) == null ? void 0 : _d.focus();
      },
      onCheck: (data, params) => {
        var _a;
        if (!props.showCheckbox)
          return;
        const dataValue = getNodeValByProp("value", data);
        const dataMap = {};
        treeEach([tree.value.store.root], (node) => dataMap[node.key] = node, (node) => node.childNodes);
        const uncachedCheckedKeys = params.checkedKeys;
        const cachedKeys = props.multiple ? toValidArray(props.modelValue).filter((item) => !(item in dataMap) && !uncachedCheckedKeys.includes(item)) : [];
        const checkedKeys = cachedKeys.concat(uncachedCheckedKeys);
        if (props.checkStrictly) {
          emit(UPDATE_MODEL_EVENT, props.multiple ? checkedKeys : checkedKeys.includes(dataValue) ? dataValue : void 0);
        } else {
          if (props.multiple) {
            const childKeys = getChildCheckedKeys();
            emit(UPDATE_MODEL_EVENT, cachedKeys.concat(childKeys));
          } else {
            const firstLeaf = treeFind([data], (data2) => !isValidArray(getNodeValByProp("children", data2)) && !getNodeValByProp("disabled", data2), (data2) => getNodeValByProp("children", data2));
            const firstLeafKey = firstLeaf ? getNodeValByProp("value", firstLeaf) : void 0;
            const hasCheckedChild = isValidValue(props.modelValue) && !!treeFind([data], (data2) => getNodeValByProp("value", data2) === props.modelValue, (data2) => getNodeValByProp("children", data2));
            emit(UPDATE_MODEL_EVENT, firstLeafKey === props.modelValue || hasCheckedChild ? void 0 : firstLeafKey);
          }
        }
        vue.nextTick(() => {
          var _a2;
          const checkedKeys2 = toValidArray(props.modelValue);
          tree.value.setCheckedKeys(checkedKeys2);
          (_a2 = attrs.onCheck) == null ? void 0 : _a2.call(attrs, data, {
            checkedKeys: tree.value.getCheckedKeys(),
            checkedNodes: tree.value.getCheckedNodes(),
            halfCheckedKeys: tree.value.getHalfCheckedKeys(),
            halfCheckedNodes: tree.value.getHalfCheckedNodes()
          });
        });
        (_a = select.value) == null ? void 0 : _a.focus();
      },
      onNodeExpand: (data, node, e) => {
        var _a;
        (_a = attrs.onNodeExpand) == null ? void 0 : _a.call(attrs, data, node, e);
        vue.nextTick(() => {
          if (!props.checkStrictly && props.lazy && props.multiple && node.checked) {
            const dataMap = {};
            const uncachedCheckedKeys = tree.value.getCheckedKeys();
            treeEach([tree.value.store.root], (node2) => dataMap[node2.key] = node2, (node2) => node2.childNodes);
            const cachedKeys = toValidArray(props.modelValue).filter((item) => !(item in dataMap) && !uncachedCheckedKeys.includes(item));
            const childKeys = getChildCheckedKeys();
            emit(UPDATE_MODEL_EVENT, cachedKeys.concat(childKeys));
          }
        });
      },
      cacheOptions
    };
  };

  var CacheOptions = vue.defineComponent({
    props: {
      data: {
        type: Array,
        default: () => []
      }
    },
    setup(props) {
      const select = vue.inject(selectKey);
      vue.watch(() => props.data, () => {
        var _a;
        props.data.forEach((item) => {
          if (!select.states.cachedOptions.has(item.value)) {
            select.states.cachedOptions.set(item.value, item);
          }
        });
        const inputs = ((_a = select.selectRef) == null ? void 0 : _a.querySelectorAll("input")) || [];
        if (isClient && !Array.from(inputs).includes(document.activeElement)) {
          select.setSelected();
        }
      }, { flush: "post", immediate: true });
      return () => void 0;
    }
  });

  const _sfc_main$m = vue.defineComponent({
    name: "ElTreeSelect",
    inheritAttrs: false,
    props: {
      ...ElSelect.props,
      ...ElTree.props,
      cacheData: {
        type: Array,
        default: () => []
      }
    },
    setup(props, context) {
      const { slots, expose } = context;
      const select = vue.ref();
      const tree = vue.ref();
      const key = vue.computed(() => props.nodeKey || props.valueKey || "value");
      const selectProps = useSelect(props, context, { select, tree, key });
      const { cacheOptions, ...treeProps } = useTree$1(props, context, {
        select,
        tree,
        key
      });
      const methods = vue.reactive({});
      expose(methods);
      vue.onMounted(() => {
        Object.assign(methods, {
          ...pick(tree.value, [
            "filter",
            "updateKeyChildren",
            "getCheckedNodes",
            "setCheckedNodes",
            "getCheckedKeys",
            "setCheckedKeys",
            "setChecked",
            "getHalfCheckedNodes",
            "getHalfCheckedKeys",
            "getCurrentKey",
            "getCurrentNode",
            "setCurrentKey",
            "setCurrentNode",
            "getNode",
            "remove",
            "append",
            "insertBefore",
            "insertAfter"
          ]),
          ...pick(select.value, ["focus", "blur", "selectedLabel"]),
          treeRef: tree.value,
          selectRef: select.value
        });
      });
      return () => vue.h(ElSelect, vue.reactive({
        ...selectProps,
        ref: (ref2) => select.value = ref2
      }), {
        ...slots,
        default: () => [
          vue.h(CacheOptions, { data: cacheOptions.value }),
          vue.h(ElTree, vue.reactive({
            ...treeProps,
            ref: (ref2) => tree.value = ref2
          }))
        ]
      });
    }
  });
  var TreeSelect = /* @__PURE__ */ _export_sfc(_sfc_main$m, [["__file", "tree-select.vue"]]);

  const ElTreeSelect = withInstall(TreeSelect);

  const ROOT_TREE_INJECTION_KEY = Symbol();
  const EMPTY_NODE = {
    key: -1,
    level: -1,
    data: {}
  };
  var TreeOptionsEnum = /* @__PURE__ */ ((TreeOptionsEnum2) => {
    TreeOptionsEnum2["KEY"] = "id";
    TreeOptionsEnum2["LABEL"] = "label";
    TreeOptionsEnum2["CHILDREN"] = "children";
    TreeOptionsEnum2["DISABLED"] = "disabled";
    TreeOptionsEnum2["CLASS"] = "";
    return TreeOptionsEnum2;
  })(TreeOptionsEnum || {});
  var SetOperationEnum = /* @__PURE__ */ ((SetOperationEnum2) => {
    SetOperationEnum2["ADD"] = "add";
    SetOperationEnum2["DELETE"] = "delete";
    return SetOperationEnum2;
  })(SetOperationEnum || {});
  const itemSize = {
    type: Number,
    default: 26
  };
  const treeProps = buildProps({
    data: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    emptyText: {
      type: String
    },
    height: {
      type: Number,
      default: 200
    },
    props: {
      type: definePropType(Object),
      default: () => mutable({
        children: "children" /* CHILDREN */,
        label: "label" /* LABEL */,
        disabled: "disabled" /* DISABLED */,
        value: "id" /* KEY */,
        class: "" /* CLASS */
      })
    },
    highlightCurrent: Boolean,
    showCheckbox: Boolean,
    defaultCheckedKeys: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    checkStrictly: Boolean,
    defaultExpandedKeys: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    indent: {
      type: Number,
      default: 16
    },
    itemSize,
    icon: {
      type: iconPropType
    },
    expandOnClickNode: {
      type: Boolean,
      default: true
    },
    checkOnClickNode: Boolean,
    checkOnClickLeaf: {
      type: Boolean,
      default: true
    },
    currentNodeKey: {
      type: definePropType([String, Number])
    },
    accordion: Boolean,
    filterMethod: {
      type: definePropType(Function)
    },
    perfMode: {
      type: Boolean,
      default: true
    },
    scrollbarAlwaysOn: Boolean
  });
  const treeNodeProps = buildProps({
    node: {
      type: definePropType(Object),
      default: () => mutable(EMPTY_NODE)
    },
    expanded: Boolean,
    checked: Boolean,
    indeterminate: Boolean,
    showCheckbox: Boolean,
    disabled: Boolean,
    current: Boolean,
    hiddenExpandIcon: Boolean,
    itemSize
  });
  const treeNodeContentProps = buildProps({
    node: {
      type: definePropType(Object),
      required: true
    }
  });
  const NODE_CLICK = "node-click";
  const NODE_DROP = "node-drop";
  const NODE_EXPAND = "node-expand";
  const NODE_COLLAPSE = "node-collapse";
  const CURRENT_CHANGE = "current-change";
  const NODE_CHECK = "check";
  const NODE_CHECK_CHANGE = "check-change";
  const NODE_CONTEXTMENU = "node-contextmenu";
  const treeEmits = {
    [NODE_CLICK]: (data, node, e) => data && node && e,
    [NODE_DROP]: (data, node, e) => data && node && e,
    [NODE_EXPAND]: (data, node) => data && node,
    [NODE_COLLAPSE]: (data, node) => data && node,
    [CURRENT_CHANGE]: (data, node) => data && node,
    [NODE_CHECK]: (data, checkedInfo) => data && checkedInfo,
    [NODE_CHECK_CHANGE]: (data, checked) => data && isBoolean(checked),
    [NODE_CONTEXTMENU]: (evt, data, node) => evt && data && node
  };
  const treeNodeEmits = {
    click: (node, e) => !!(node && e),
    drop: (node, e) => !!(node && e),
    toggle: (node) => !!node,
    check: (node, checked) => node && isBoolean(checked)
  };

  function useCheck(props, tree) {
    const checkedKeys = vue.ref(/* @__PURE__ */ new Set());
    const indeterminateKeys = vue.ref(/* @__PURE__ */ new Set());
    const { emit } = vue.getCurrentInstance();
    vue.watch([() => tree.value, () => props.defaultCheckedKeys], () => {
      return vue.nextTick(() => {
        _setCheckedKeys(props.defaultCheckedKeys);
      });
    }, {
      immediate: true
    });
    const updateCheckedKeys = () => {
      if (!tree.value || !props.showCheckbox || props.checkStrictly) {
        return;
      }
      const { levelTreeNodeMap, maxLevel } = tree.value;
      const checkedKeySet = checkedKeys.value;
      const indeterminateKeySet = /* @__PURE__ */ new Set();
      for (let level = maxLevel - 1; level >= 1; --level) {
        const nodes = levelTreeNodeMap.get(level);
        if (!nodes)
          continue;
        nodes.forEach((node) => {
          const children = node.children;
          if (children) {
            let allChecked = true;
            let hasChecked = false;
            for (const childNode of children) {
              const key = childNode.key;
              if (checkedKeySet.has(key)) {
                hasChecked = true;
              } else if (indeterminateKeySet.has(key)) {
                allChecked = false;
                hasChecked = true;
                break;
              } else {
                allChecked = false;
              }
            }
            if (allChecked) {
              checkedKeySet.add(node.key);
            } else if (hasChecked) {
              indeterminateKeySet.add(node.key);
              checkedKeySet.delete(node.key);
            } else {
              checkedKeySet.delete(node.key);
              indeterminateKeySet.delete(node.key);
            }
          }
        });
      }
      indeterminateKeys.value = indeterminateKeySet;
    };
    const isChecked = (node) => checkedKeys.value.has(node.key);
    const isIndeterminate = (node) => indeterminateKeys.value.has(node.key);
    const toggleCheckbox = (node, isChecked2, nodeClick = true, immediateUpdate = true) => {
      const checkedKeySet = checkedKeys.value;
      const toggle = (node2, checked) => {
        checkedKeySet[checked ? SetOperationEnum.ADD : SetOperationEnum.DELETE](node2.key);
        const children = node2.children;
        if (!props.checkStrictly && children) {
          children.forEach((childNode) => {
            if (!childNode.disabled) {
              toggle(childNode, checked);
            }
          });
        }
      };
      toggle(node, isChecked2);
      if (immediateUpdate) {
        updateCheckedKeys();
      }
      if (nodeClick) {
        afterNodeCheck(node, isChecked2);
      }
    };
    const afterNodeCheck = (node, checked) => {
      const { checkedNodes, checkedKeys: checkedKeys2 } = getChecked();
      const { halfCheckedNodes, halfCheckedKeys } = getHalfChecked();
      emit(NODE_CHECK, node.data, {
        checkedKeys: checkedKeys2,
        checkedNodes,
        halfCheckedKeys,
        halfCheckedNodes
      });
      emit(NODE_CHECK_CHANGE, node.data, checked);
    };
    function getCheckedKeys(leafOnly = false) {
      return getChecked(leafOnly).checkedKeys;
    }
    function getCheckedNodes(leafOnly = false) {
      return getChecked(leafOnly).checkedNodes;
    }
    function getHalfCheckedKeys() {
      return getHalfChecked().halfCheckedKeys;
    }
    function getHalfCheckedNodes() {
      return getHalfChecked().halfCheckedNodes;
    }
    function getChecked(leafOnly = false) {
      const checkedNodes = [];
      const keys = [];
      if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
        const { treeNodeMap } = tree.value;
        checkedKeys.value.forEach((key) => {
          const node = treeNodeMap.get(key);
          if (node && (!leafOnly || leafOnly && node.isLeaf)) {
            keys.push(key);
            checkedNodes.push(node.data);
          }
        });
      }
      return {
        checkedKeys: keys,
        checkedNodes
      };
    }
    function getHalfChecked() {
      const halfCheckedNodes = [];
      const halfCheckedKeys = [];
      if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
        const { treeNodeMap } = tree.value;
        indeterminateKeys.value.forEach((key) => {
          const node = treeNodeMap.get(key);
          if (node) {
            halfCheckedKeys.push(key);
            halfCheckedNodes.push(node.data);
          }
        });
      }
      return {
        halfCheckedNodes,
        halfCheckedKeys
      };
    }
    function setCheckedKeys(keys) {
      checkedKeys.value.clear();
      indeterminateKeys.value.clear();
      vue.nextTick(() => {
        _setCheckedKeys(keys);
      });
    }
    function setChecked(key, isChecked2) {
      if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
        const node = tree.value.treeNodeMap.get(key);
        if (node) {
          toggleCheckbox(node, isChecked2, false);
        }
      }
    }
    function _setCheckedKeys(keys) {
      if (tree == null ? void 0 : tree.value) {
        const { treeNodeMap } = tree.value;
        if (props.showCheckbox && treeNodeMap && (keys == null ? void 0 : keys.length) > 0) {
          for (const key of keys) {
            const node = treeNodeMap.get(key);
            if (node && !isChecked(node)) {
              toggleCheckbox(node, true, false, false);
            }
          }
          updateCheckedKeys();
        }
      }
    }
    return {
      updateCheckedKeys,
      toggleCheckbox,
      isChecked,
      isIndeterminate,
      getCheckedKeys,
      getCheckedNodes,
      getHalfCheckedKeys,
      getHalfCheckedNodes,
      setChecked,
      setCheckedKeys
    };
  }

  function useFilter(props, tree) {
    const hiddenNodeKeySet = vue.ref(/* @__PURE__ */ new Set([]));
    const hiddenExpandIconKeySet = vue.ref(/* @__PURE__ */ new Set([]));
    const filterable = vue.computed(() => {
      return isFunction$1(props.filterMethod);
    });
    function doFilter(query) {
      var _a;
      if (!filterable.value) {
        return;
      }
      const expandKeySet = /* @__PURE__ */ new Set();
      const hiddenExpandIconKeys = hiddenExpandIconKeySet.value;
      const hiddenKeys = hiddenNodeKeySet.value;
      const family = [];
      const nodes = ((_a = tree.value) == null ? void 0 : _a.treeNodes) || [];
      const filter = props.filterMethod;
      hiddenKeys.clear();
      function traverse(nodes2) {
        nodes2.forEach((node) => {
          family.push(node);
          if (filter == null ? void 0 : filter(query, node.data, node)) {
            family.forEach((member) => {
              expandKeySet.add(member.key);
              member.expanded = true;
            });
          } else {
            node.expanded = false;
            if (node.isLeaf) {
              hiddenKeys.add(node.key);
            }
          }
          const children = node.children;
          if (children) {
            traverse(children);
          }
          if (!node.isLeaf) {
            if (!expandKeySet.has(node.key)) {
              hiddenKeys.add(node.key);
            } else if (children) {
              let allHidden = true;
              for (const childNode of children) {
                if (!hiddenKeys.has(childNode.key)) {
                  allHidden = false;
                  break;
                }
              }
              if (allHidden) {
                hiddenExpandIconKeys.add(node.key);
              } else {
                hiddenExpandIconKeys.delete(node.key);
              }
            }
          }
          family.pop();
        });
      }
      traverse(nodes);
      return expandKeySet;
    }
    function isForceHiddenExpandIcon(node) {
      return hiddenExpandIconKeySet.value.has(node.key);
    }
    return {
      hiddenExpandIconKeySet,
      hiddenNodeKeySet,
      doFilter,
      isForceHiddenExpandIcon
    };
  }

  function useTree(props, emit) {
    const expandedKeySet = vue.ref(/* @__PURE__ */ new Set());
    const currentKey = vue.ref();
    const tree = vue.shallowRef();
    const listRef = vue.ref();
    const {
      isIndeterminate,
      isChecked,
      toggleCheckbox,
      getCheckedKeys,
      getCheckedNodes,
      getHalfCheckedKeys,
      getHalfCheckedNodes,
      setChecked,
      setCheckedKeys
    } = useCheck(props, tree);
    const { doFilter, hiddenNodeKeySet, isForceHiddenExpandIcon } = useFilter(props, tree);
    const valueKey = vue.computed(() => {
      var _a;
      return ((_a = props.props) == null ? void 0 : _a.value) || TreeOptionsEnum.KEY;
    });
    const childrenKey = vue.computed(() => {
      var _a;
      return ((_a = props.props) == null ? void 0 : _a.children) || TreeOptionsEnum.CHILDREN;
    });
    const disabledKey = vue.computed(() => {
      var _a;
      return ((_a = props.props) == null ? void 0 : _a.disabled) || TreeOptionsEnum.DISABLED;
    });
    const labelKey = vue.computed(() => {
      var _a;
      return ((_a = props.props) == null ? void 0 : _a.label) || TreeOptionsEnum.LABEL;
    });
    const flattenTree = vue.computed(() => {
      var _a;
      const expandedKeys = expandedKeySet.value;
      const hiddenKeys = hiddenNodeKeySet.value;
      const flattenNodes = [];
      const nodes = ((_a = tree.value) == null ? void 0 : _a.treeNodes) || [];
      const stack = [];
      for (let i = nodes.length - 1; i >= 0; --i) {
        stack.push(nodes[i]);
      }
      while (stack.length) {
        const node = stack.pop();
        if (hiddenKeys.has(node.key))
          continue;
        flattenNodes.push(node);
        if (node.children && expandedKeys.has(node.key)) {
          for (let i = node.children.length - 1; i >= 0; --i) {
            stack.push(node.children[i]);
          }
        }
      }
      return flattenNodes;
    });
    const isNotEmpty = vue.computed(() => {
      return flattenTree.value.length > 0;
    });
    function createTree(data) {
      const treeNodeMap = /* @__PURE__ */ new Map();
      const levelTreeNodeMap = /* @__PURE__ */ new Map();
      let maxLevel = 1;
      function traverse(nodes, level = 1, parent = void 0) {
        var _a;
        const siblings = [];
        for (const rawNode of nodes) {
          const value = getKey(rawNode);
          const node = {
            level,
            key: value,
            data: rawNode
          };
          node.label = getLabel(rawNode);
          node.parent = parent;
          const children = getChildren(rawNode);
          node.disabled = getDisabled(rawNode);
          node.isLeaf = !children || children.length === 0;
          node.expanded = expandedKeySet.value.has(value);
          if (children && children.length) {
            node.children = traverse(children, level + 1, node);
          }
          siblings.push(node);
          treeNodeMap.set(value, node);
          if (!levelTreeNodeMap.has(level)) {
            levelTreeNodeMap.set(level, []);
          }
          (_a = levelTreeNodeMap.get(level)) == null ? void 0 : _a.push(node);
        }
        if (level > maxLevel) {
          maxLevel = level;
        }
        return siblings;
      }
      const treeNodes = traverse(data);
      return {
        treeNodeMap,
        levelTreeNodeMap,
        maxLevel,
        treeNodes
      };
    }
    function filter(query) {
      const keys = doFilter(query);
      if (keys) {
        expandedKeySet.value = keys;
      }
    }
    function getChildren(node) {
      return node[childrenKey.value];
    }
    function getKey(node) {
      if (!node) {
        return "";
      }
      return node[valueKey.value];
    }
    function getDisabled(node) {
      return node[disabledKey.value];
    }
    function getLabel(node) {
      return node[labelKey.value];
    }
    function toggleExpand(node) {
      const expandedKeys = expandedKeySet.value;
      if (expandedKeys.has(node.key)) {
        collapseNode(node);
      } else {
        expandNode(node);
      }
    }
    function setExpandedKeys(keys) {
      const expandedKeys = /* @__PURE__ */ new Set();
      const nodeMap = tree.value.treeNodeMap;
      expandedKeySet.value.forEach((key) => {
        const node = nodeMap.get(key);
        expandedKeySet.value.delete(node.key);
        node.expanded = false;
      });
      keys.forEach((k) => {
        let node = nodeMap.get(k);
        while (node && !expandedKeys.has(node.key)) {
          expandedKeys.add(node.key);
          node.expanded = true;
          node = node.parent;
        }
      });
      expandedKeySet.value = expandedKeys;
    }
    function handleNodeClick(node, e) {
      emit(NODE_CLICK, node.data, node, e);
      handleCurrentChange(node);
      if (props.expandOnClickNode) {
        toggleExpand(node);
      }
      if (props.showCheckbox && (props.checkOnClickNode || node.isLeaf && props.checkOnClickLeaf) && !node.disabled) {
        toggleCheckbox(node, !isChecked(node), true);
      }
    }
    function handleNodeDrop(node, e) {
      emit(NODE_DROP, node.data, node, e);
    }
    function handleCurrentChange(node) {
      if (!isCurrent(node)) {
        currentKey.value = node.key;
        emit(CURRENT_CHANGE, node.data, node);
      }
    }
    function handleNodeCheck(node, checked) {
      toggleCheckbox(node, checked);
    }
    function expandNode(node) {
      const keySet = expandedKeySet.value;
      if (tree.value && props.accordion) {
        const { treeNodeMap } = tree.value;
        keySet.forEach((key) => {
          const treeNode = treeNodeMap.get(key);
          if (node && node.level === (treeNode == null ? void 0 : treeNode.level)) {
            keySet.delete(key);
            treeNode.expanded = false;
          }
        });
      }
      keySet.add(node.key);
      const _node = getNode(node.key);
      if (_node) {
        _node.expanded = true;
        emit(NODE_EXPAND, _node.data, _node);
      }
    }
    function collapseNode(node) {
      expandedKeySet.value.delete(node.key);
      const _node = getNode(node.key);
      if (_node) {
        _node.expanded = false;
        emit(NODE_COLLAPSE, _node.data, _node);
      }
    }
    function isDisabled(node) {
      return !!node.disabled;
    }
    function isCurrent(node) {
      const current = currentKey.value;
      return current !== void 0 && current === node.key;
    }
    function getCurrentNode() {
      var _a, _b;
      if (!currentKey.value)
        return void 0;
      return (_b = (_a = tree.value) == null ? void 0 : _a.treeNodeMap.get(currentKey.value)) == null ? void 0 : _b.data;
    }
    function getCurrentKey() {
      return currentKey.value;
    }
    function setCurrentKey(key) {
      currentKey.value = key;
    }
    function setData(data) {
      tree.value = createTree(data);
    }
    function getNode(data) {
      var _a;
      const key = isObject$1(data) ? getKey(data) : data;
      return (_a = tree.value) == null ? void 0 : _a.treeNodeMap.get(key);
    }
    function scrollToNode(key, strategy = "auto") {
      const node = getNode(key);
      if (node && listRef.value) {
        listRef.value.scrollToItem(flattenTree.value.indexOf(node), strategy);
      }
    }
    function scrollTo(offset) {
      var _a;
      (_a = listRef.value) == null ? void 0 : _a.scrollTo(offset);
    }
    vue.watch(() => props.currentNodeKey, (key) => {
      currentKey.value = key;
    }, {
      immediate: true
    });
    vue.watch(() => props.defaultExpandedKeys, (key) => {
      expandedKeySet.value = new Set(key);
    }, {
      immediate: true
    });
    vue.watch(() => props.data, (data) => {
      setData(data);
    }, {
      immediate: true
    });
    return {
      tree,
      flattenTree,
      isNotEmpty,
      listRef,
      getKey,
      getChildren,
      toggleExpand,
      toggleCheckbox,
      isChecked,
      isIndeterminate,
      isDisabled,
      isCurrent,
      isForceHiddenExpandIcon,
      handleNodeClick,
      handleNodeDrop,
      handleNodeCheck,
      getCurrentNode,
      getCurrentKey,
      setCurrentKey,
      getCheckedKeys,
      getCheckedNodes,
      getHalfCheckedKeys,
      getHalfCheckedNodes,
      setChecked,
      setCheckedKeys,
      filter,
      setData,
      getNode,
      expandNode,
      collapseNode,
      setExpandedKeys,
      scrollToNode,
      scrollTo
    };
  }

  var ElNodeContent = vue.defineComponent({
    name: "ElTreeNodeContent",
    props: treeNodeContentProps,
    setup(props) {
      const tree = vue.inject(ROOT_TREE_INJECTION_KEY);
      const ns = useNamespace("tree");
      return () => {
        const node = props.node;
        const { data } = node;
        return (tree == null ? void 0 : tree.ctx.slots.default) ? tree.ctx.slots.default({ node, data }) : vue.h(ElText, { tag: "span", truncated: true, class: ns.be("node", "label") }, () => [node == null ? void 0 : node.label]);
      };
    }
  });

  const __default__$k = vue.defineComponent({
    name: "ElTreeNode"
  });
  const _sfc_main$l = /* @__PURE__ */ vue.defineComponent({
    ...__default__$k,
    props: treeNodeProps,
    emits: treeNodeEmits,
    setup(__props, { emit }) {
      const props = __props;
      const tree = vue.inject(ROOT_TREE_INJECTION_KEY);
      const ns = useNamespace("tree");
      const indent = vue.computed(() => {
        var _a;
        return (_a = tree == null ? void 0 : tree.props.indent) != null ? _a : 16;
      });
      const icon = vue.computed(() => {
        var _a;
        return (_a = tree == null ? void 0 : tree.props.icon) != null ? _a : caret_right_default;
      });
      const getNodeClass = (node) => {
        const nodeClassFunc = tree == null ? void 0 : tree.props.props.class;
        if (!nodeClassFunc)
          return {};
        let className;
        if (isFunction$1(nodeClassFunc)) {
          const { data } = node;
          className = nodeClassFunc(data, node);
        } else {
          className = nodeClassFunc;
        }
        return isString$1(className) ? { [className]: true } : className;
      };
      const handleClick = (e) => {
        emit("click", props.node, e);
      };
      const handleDrop = (e) => {
        emit("drop", props.node, e);
      };
      const handleExpandIconClick = () => {
        emit("toggle", props.node);
      };
      const handleCheckChange = (value) => {
        emit("check", props.node, value);
      };
      const handleContextMenu = (event) => {
        var _a, _b, _c, _d;
        if ((_c = (_b = (_a = tree == null ? void 0 : tree.instance) == null ? void 0 : _a.vnode) == null ? void 0 : _b.props) == null ? void 0 : _c["onNodeContextmenu"]) {
          event.stopPropagation();
          event.preventDefault();
        }
        tree == null ? void 0 : tree.ctx.emit(NODE_CONTEXTMENU, event, (_d = props.node) == null ? void 0 : _d.data, props.node);
      };
      return (_ctx, _cache) => {
        var _a, _b, _c;
        return vue.openBlock(), vue.createElementBlock("div", {
          ref: "node$",
          class: vue.normalizeClass([
            vue.unref(ns).b("node"),
            vue.unref(ns).is("expanded", _ctx.expanded),
            vue.unref(ns).is("current", _ctx.current),
            vue.unref(ns).is("focusable", !_ctx.disabled),
            vue.unref(ns).is("checked", !_ctx.disabled && _ctx.checked),
            getNodeClass(_ctx.node)
          ]),
          role: "treeitem",
          tabindex: "-1",
          "aria-expanded": _ctx.expanded,
          "aria-disabled": _ctx.disabled,
          "aria-checked": _ctx.checked,
          "data-key": (_a = _ctx.node) == null ? void 0 : _a.key,
          onClick: vue.withModifiers(handleClick, ["stop"]),
          onContextmenu: handleContextMenu,
          onDragover: vue.withModifiers(() => {
          }, ["prevent"]),
          onDragenter: vue.withModifiers(() => {
          }, ["prevent"]),
          onDrop: vue.withModifiers(handleDrop, ["stop"])
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).be("node", "content")),
            style: vue.normalizeStyle({
              paddingLeft: `${(_ctx.node.level - 1) * vue.unref(indent)}px`,
              height: _ctx.itemSize + "px"
            })
          }, [
            vue.unref(icon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 0,
              class: vue.normalizeClass([
                vue.unref(ns).is("leaf", !!((_b = _ctx.node) == null ? void 0 : _b.isLeaf)),
                vue.unref(ns).is("hidden", _ctx.hiddenExpandIcon),
                {
                  expanded: !((_c = _ctx.node) == null ? void 0 : _c.isLeaf) && _ctx.expanded
                },
                vue.unref(ns).be("node", "expand-icon")
              ]),
              onClick: vue.withModifiers(handleExpandIconClick, ["stop"])
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(icon))))
              ]),
              _: 1
            }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
            _ctx.showCheckbox ? (vue.openBlock(), vue.createBlock(vue.unref(ElCheckbox), {
              key: 1,
              "model-value": _ctx.checked,
              indeterminate: _ctx.indeterminate,
              disabled: _ctx.disabled,
              onChange: handleCheckChange,
              onClick: vue.withModifiers(() => {
              }, ["stop"])
            }, null, 8, ["model-value", "indeterminate", "disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
            vue.createVNode(vue.unref(ElNodeContent), {
              node: { ..._ctx.node, expanded: _ctx.expanded }
            }, null, 8, ["node"])
          ], 6)
        ], 42, ["aria-expanded", "aria-disabled", "aria-checked", "data-key", "onClick", "onDragover", "onDragenter", "onDrop"]);
      };
    }
  });
  var ElTreeNode = /* @__PURE__ */ _export_sfc(_sfc_main$l, [["__file", "tree-node.vue"]]);

  const __default__$j = vue.defineComponent({
    name: "ElTreeV2"
  });
  const _sfc_main$k = /* @__PURE__ */ vue.defineComponent({
    ...__default__$j,
    props: treeProps,
    emits: treeEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const slots = vue.useSlots();
      const treeNodeSize = vue.computed(() => props.itemSize);
      vue.provide(ROOT_TREE_INJECTION_KEY, {
        ctx: {
          emit,
          slots
        },
        props,
        instance: vue.getCurrentInstance()
      });
      vue.provide(formItemContextKey, void 0);
      const { t } = useLocale();
      const ns = useNamespace("tree");
      const {
        flattenTree,
        isNotEmpty,
        listRef,
        toggleExpand,
        isIndeterminate,
        isChecked,
        isDisabled,
        isCurrent,
        isForceHiddenExpandIcon,
        handleNodeClick,
        handleNodeDrop,
        handleNodeCheck,
        toggleCheckbox,
        getCurrentNode,
        getCurrentKey,
        setCurrentKey,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked,
        setCheckedKeys,
        filter,
        setData,
        getNode,
        expandNode,
        collapseNode,
        setExpandedKeys,
        scrollToNode,
        scrollTo
      } = useTree(props, emit);
      expose({
        toggleCheckbox,
        getCurrentNode,
        getCurrentKey,
        setCurrentKey,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked,
        setCheckedKeys,
        filter,
        setData,
        getNode,
        expandNode,
        collapseNode,
        setExpandedKeys,
        scrollToNode,
        scrollTo
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b(), { [vue.unref(ns).m("highlight-current")]: _ctx.highlightCurrent }]),
          role: "tree"
        }, [
          vue.unref(isNotEmpty) ? (vue.openBlock(), vue.createBlock(vue.unref(FixedSizeList$1), {
            key: 0,
            ref_key: "listRef",
            ref: listRef,
            "class-name": vue.unref(ns).b("virtual-list"),
            data: vue.unref(flattenTree),
            total: vue.unref(flattenTree).length,
            height: _ctx.height,
            "item-size": vue.unref(treeNodeSize),
            "perf-mode": _ctx.perfMode,
            "scrollbar-always-on": _ctx.scrollbarAlwaysOn
          }, {
            default: vue.withCtx(({ data, index, style }) => [
              (vue.openBlock(), vue.createBlock(ElTreeNode, {
                key: data[index].key,
                style: vue.normalizeStyle(style),
                node: data[index],
                expanded: data[index].expanded,
                "show-checkbox": _ctx.showCheckbox,
                checked: vue.unref(isChecked)(data[index]),
                indeterminate: vue.unref(isIndeterminate)(data[index]),
                "item-size": vue.unref(treeNodeSize),
                disabled: vue.unref(isDisabled)(data[index]),
                current: vue.unref(isCurrent)(data[index]),
                "hidden-expand-icon": vue.unref(isForceHiddenExpandIcon)(data[index]),
                onClick: vue.unref(handleNodeClick),
                onToggle: vue.unref(toggleExpand),
                onCheck: vue.unref(handleNodeCheck),
                onDrop: vue.unref(handleNodeDrop)
              }, null, 8, ["style", "node", "expanded", "show-checkbox", "checked", "indeterminate", "item-size", "disabled", "current", "hidden-expand-icon", "onClick", "onToggle", "onCheck", "onDrop"]))
            ]),
            _: 1
          }, 8, ["class-name", "data", "total", "height", "item-size", "perf-mode", "scrollbar-always-on"])) : (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("empty-block"))
          }, [
            vue.renderSlot(_ctx.$slots, "empty", {}, () => {
              var _a;
              return [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(ns).e("empty-text"))
                }, vue.toDisplayString((_a = _ctx.emptyText) != null ? _a : vue.unref(t)("el.tree.emptyText")), 3)
              ];
            })
          ], 2))
        ], 2);
      };
    }
  });
  var TreeV2 = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["__file", "tree.vue"]]);

  const ElTreeV2 = withInstall(TreeV2);

  const uploadContextKey = Symbol("uploadContextKey");

  const SCOPE$2 = "ElUpload";
  class UploadAjaxError extends Error {
    constructor(message, status, method, url) {
      super(message);
      this.name = "UploadAjaxError";
      this.status = status;
      this.method = method;
      this.url = url;
    }
  }
  function getError(action, option, xhr) {
    let msg;
    if (xhr.response) {
      msg = `${xhr.response.error || xhr.response}`;
    } else if (xhr.responseText) {
      msg = `${xhr.responseText}`;
    } else {
      msg = `fail to ${option.method} ${action} ${xhr.status}`;
    }
    return new UploadAjaxError(msg, xhr.status, option.method, action);
  }
  function getBody(xhr) {
    const text = xhr.responseText || xhr.response;
    if (!text) {
      return text;
    }
    try {
      return JSON.parse(text);
    } catch (e) {
      return text;
    }
  }
  const ajaxUpload = (option) => {
    if (typeof XMLHttpRequest === "undefined")
      throwError(SCOPE$2, "XMLHttpRequest is undefined");
    const xhr = new XMLHttpRequest();
    const action = option.action;
    if (xhr.upload) {
      xhr.upload.addEventListener("progress", (evt) => {
        const progressEvt = evt;
        progressEvt.percent = evt.total > 0 ? evt.loaded / evt.total * 100 : 0;
        option.onProgress(progressEvt);
      });
    }
    const formData = new FormData();
    if (option.data) {
      for (const [key, value] of Object.entries(option.data)) {
        if (isArray$1(value) && value.length)
          formData.append(key, ...value);
        else
          formData.append(key, value);
      }
    }
    formData.append(option.filename, option.file, option.file.name);
    xhr.addEventListener("error", () => {
      option.onError(getError(action, option, xhr));
    });
    xhr.addEventListener("load", () => {
      if (xhr.status < 200 || xhr.status >= 300) {
        return option.onError(getError(action, option, xhr));
      }
      option.onSuccess(getBody(xhr));
    });
    xhr.open(option.method, action, true);
    if (option.withCredentials && "withCredentials" in xhr) {
      xhr.withCredentials = true;
    }
    const headers = option.headers || {};
    if (headers instanceof Headers) {
      headers.forEach((value, key) => xhr.setRequestHeader(key, value));
    } else {
      for (const [key, value] of Object.entries(headers)) {
        if (isNil(value))
          continue;
        xhr.setRequestHeader(key, String(value));
      }
    }
    xhr.send(formData);
    return xhr;
  };

  const uploadListTypes = ["text", "picture", "picture-card"];
  let fileId = 1;
  const genFileId = () => Date.now() + fileId++;
  const uploadBaseProps = buildProps({
    action: {
      type: String,
      default: "#"
    },
    headers: {
      type: definePropType(Object)
    },
    method: {
      type: String,
      default: "post"
    },
    data: {
      type: definePropType([Object, Function, Promise]),
      default: () => mutable({})
    },
    multiple: Boolean,
    name: {
      type: String,
      default: "file"
    },
    drag: Boolean,
    withCredentials: Boolean,
    showFileList: {
      type: Boolean,
      default: true
    },
    accept: {
      type: String,
      default: ""
    },
    fileList: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    autoUpload: {
      type: Boolean,
      default: true
    },
    listType: {
      type: String,
      values: uploadListTypes,
      default: "text"
    },
    httpRequest: {
      type: definePropType(Function),
      default: ajaxUpload
    },
    disabled: Boolean,
    limit: Number
  });
  const uploadProps = buildProps({
    ...uploadBaseProps,
    beforeUpload: {
      type: definePropType(Function),
      default: NOOP
    },
    beforeRemove: {
      type: definePropType(Function)
    },
    onRemove: {
      type: definePropType(Function),
      default: NOOP
    },
    onChange: {
      type: definePropType(Function),
      default: NOOP
    },
    onPreview: {
      type: definePropType(Function),
      default: NOOP
    },
    onSuccess: {
      type: definePropType(Function),
      default: NOOP
    },
    onProgress: {
      type: definePropType(Function),
      default: NOOP
    },
    onError: {
      type: definePropType(Function),
      default: NOOP
    },
    onExceed: {
      type: definePropType(Function),
      default: NOOP
    },
    crossorigin: {
      type: definePropType(String)
    }
  });

  const uploadListProps = buildProps({
    files: {
      type: definePropType(Array),
      default: () => mutable([])
    },
    disabled: Boolean,
    handlePreview: {
      type: definePropType(Function),
      default: NOOP
    },
    listType: {
      type: String,
      values: uploadListTypes,
      default: "text"
    },
    crossorigin: {
      type: definePropType(String)
    }
  });
  const uploadListEmits = {
    remove: (file) => !!file
  };

  const __default__$i = vue.defineComponent({
    name: "ElUploadList"
  });
  const _sfc_main$j = /* @__PURE__ */ vue.defineComponent({
    ...__default__$i,
    props: uploadListProps,
    emits: uploadListEmits,
    setup(__props, { emit }) {
      const props = __props;
      const { t } = useLocale();
      const nsUpload = useNamespace("upload");
      const nsIcon = useNamespace("icon");
      const nsList = useNamespace("list");
      const disabled = useFormDisabled();
      const focusing = vue.ref(false);
      const containerKls = vue.computed(() => [
        nsUpload.b("list"),
        nsUpload.bm("list", props.listType),
        nsUpload.is("disabled", props.disabled)
      ]);
      const handleRemove = (file) => {
        emit("remove", file);
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.TransitionGroup, {
          tag: "ul",
          class: vue.normalizeClass(vue.unref(containerKls)),
          name: vue.unref(nsList).b()
        }, {
          default: vue.withCtx(() => [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.files, (file, index) => {
              return vue.openBlock(), vue.createElementBlock("li", {
                key: file.uid || file.name,
                class: vue.normalizeClass([
                  vue.unref(nsUpload).be("list", "item"),
                  vue.unref(nsUpload).is(file.status),
                  { focusing: focusing.value }
                ]),
                tabindex: vue.unref(disabled) ? void 0 : 0,
                "aria-disabled": vue.unref(disabled),
                role: "button",
                onKeydown: vue.withKeys(($event) => !vue.unref(disabled) && handleRemove(file), ["delete"]),
                onFocus: ($event) => focusing.value = true,
                onBlur: ($event) => focusing.value = false,
                onClick: ($event) => focusing.value = false
              }, [
                vue.renderSlot(_ctx.$slots, "default", {
                  file,
                  index
                }, () => [
                  _ctx.listType === "picture" || file.status !== "uploading" && _ctx.listType === "picture-card" ? (vue.openBlock(), vue.createElementBlock("img", {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-thumbnail")),
                    src: file.url,
                    crossorigin: _ctx.crossorigin,
                    alt: ""
                  }, null, 10, ["src", "crossorigin"])) : vue.createCommentVNode("v-if", true),
                  file.status === "uploading" || _ctx.listType !== "picture-card" ? (vue.openBlock(), vue.createElementBlock("div", {
                    key: 1,
                    class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-info"))
                  }, [
                    vue.createElementVNode("a", {
                      class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-name")),
                      onClick: vue.withModifiers(($event) => _ctx.handlePreview(file), ["prevent"])
                    }, [
                      vue.createVNode(vue.unref(ElIcon), {
                        class: vue.normalizeClass(vue.unref(nsIcon).m("document"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(document_default))
                        ]),
                        _: 1
                      }, 8, ["class"]),
                      vue.createElementVNode("span", {
                        class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-file-name")),
                        title: file.name
                      }, vue.toDisplayString(file.name), 11, ["title"])
                    ], 10, ["onClick"]),
                    file.status === "uploading" ? (vue.openBlock(), vue.createBlock(vue.unref(ElProgress), {
                      key: 0,
                      type: _ctx.listType === "picture-card" ? "circle" : "line",
                      "stroke-width": _ctx.listType === "picture-card" ? 6 : 2,
                      percentage: Number(file.percentage),
                      style: vue.normalizeStyle(_ctx.listType === "picture-card" ? "" : "margin-top: 0.5rem")
                    }, null, 8, ["type", "stroke-width", "percentage", "style"])) : vue.createCommentVNode("v-if", true)
                  ], 2)) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("label", {
                    class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-status-label"))
                  }, [
                    _ctx.listType === "text" ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 0,
                      class: vue.normalizeClass([vue.unref(nsIcon).m("upload-success"), vue.unref(nsIcon).m("circle-check")])
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(circle_check_default))
                      ]),
                      _: 1
                    }, 8, ["class"])) : ["picture-card", "picture"].includes(_ctx.listType) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 1,
                      class: vue.normalizeClass([vue.unref(nsIcon).m("upload-success"), vue.unref(nsIcon).m("check")])
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(check_default))
                      ]),
                      _: 1
                    }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                  ], 2),
                  !vue.unref(disabled) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 2,
                    class: vue.normalizeClass(vue.unref(nsIcon).m("close")),
                    onClick: ($event) => handleRemove(file)
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(close_default))
                    ]),
                    _: 2
                  }, 1032, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
                  vue.createCommentVNode(" Due to close btn only appears when li gets focused disappears after li gets blurred, thus keyboard navigation can never reach close btn"),
                  vue.createCommentVNode(" This is a bug which needs to be fixed "),
                  vue.createCommentVNode(" TODO: Fix the incorrect navigation interaction "),
                  !vue.unref(disabled) ? (vue.openBlock(), vue.createElementBlock("i", {
                    key: 3,
                    class: vue.normalizeClass(vue.unref(nsIcon).m("close-tip"))
                  }, vue.toDisplayString(vue.unref(t)("el.upload.deleteTip")), 3)) : vue.createCommentVNode("v-if", true),
                  _ctx.listType === "picture-card" ? (vue.openBlock(), vue.createElementBlock("span", {
                    key: 4,
                    class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-actions"))
                  }, [
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-preview")),
                      onClick: ($event) => _ctx.handlePreview(file)
                    }, [
                      vue.createVNode(vue.unref(ElIcon), {
                        class: vue.normalizeClass(vue.unref(nsIcon).m("zoom-in"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(zoom_in_default))
                        ]),
                        _: 1
                      }, 8, ["class"])
                    ], 10, ["onClick"]),
                    !vue.unref(disabled) ? (vue.openBlock(), vue.createElementBlock("span", {
                      key: 0,
                      class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-delete")),
                      onClick: ($event) => handleRemove(file)
                    }, [
                      vue.createVNode(vue.unref(ElIcon), {
                        class: vue.normalizeClass(vue.unref(nsIcon).m("delete"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(delete_default))
                        ]),
                        _: 1
                      }, 8, ["class"])
                    ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true)
                  ], 2)) : vue.createCommentVNode("v-if", true)
                ])
              ], 42, ["tabindex", "aria-disabled", "onKeydown", "onFocus", "onBlur", "onClick"]);
            }), 128)),
            vue.renderSlot(_ctx.$slots, "append")
          ]),
          _: 3
        }, 8, ["class", "name"]);
      };
    }
  });
  var UploadList = /* @__PURE__ */ _export_sfc(_sfc_main$j, [["__file", "upload-list.vue"]]);

  const uploadDraggerProps = buildProps({
    disabled: Boolean
  });
  const uploadDraggerEmits = {
    file: (file) => isArray$1(file)
  };

  const COMPONENT_NAME$1 = "ElUploadDrag";
  const __default__$h = vue.defineComponent({
    name: COMPONENT_NAME$1
  });
  const _sfc_main$i = /* @__PURE__ */ vue.defineComponent({
    ...__default__$h,
    props: uploadDraggerProps,
    emits: uploadDraggerEmits,
    setup(__props, { emit }) {
      const uploaderContext = vue.inject(uploadContextKey);
      if (!uploaderContext) {
        throwError(COMPONENT_NAME$1, "usage: <el-upload><el-upload-dragger /></el-upload>");
      }
      const ns = useNamespace("upload");
      const dragover = vue.ref(false);
      const disabled = useFormDisabled();
      const onDrop = (e) => {
        if (disabled.value)
          return;
        dragover.value = false;
        e.stopPropagation();
        const files = Array.from(e.dataTransfer.files);
        const items = e.dataTransfer.items || [];
        files.forEach((file, index) => {
          var _a;
          const item = items[index];
          const entry = (_a = item == null ? void 0 : item.webkitGetAsEntry) == null ? void 0 : _a.call(item);
          if (entry) {
            file.isDirectory = entry.isDirectory;
          }
        });
        emit("file", files);
      };
      const onDragover = () => {
        if (!disabled.value)
          dragover.value = true;
      };
      const onDragleave = (e) => {
        if (!e.currentTarget.contains(e.relatedTarget))
          dragover.value = false;
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b("dragger"), vue.unref(ns).is("dragover", dragover.value)]),
          onDrop: vue.withModifiers(onDrop, ["prevent"]),
          onDragover: vue.withModifiers(onDragover, ["prevent"]),
          onDragleave: vue.withModifiers(onDragleave, ["prevent"])
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 42, ["onDrop", "onDragover", "onDragleave"]);
      };
    }
  });
  var UploadDragger = /* @__PURE__ */ _export_sfc(_sfc_main$i, [["__file", "upload-dragger.vue"]]);

  const uploadContentProps = buildProps({
    ...uploadBaseProps,
    beforeUpload: {
      type: definePropType(Function),
      default: NOOP
    },
    onRemove: {
      type: definePropType(Function),
      default: NOOP
    },
    onStart: {
      type: definePropType(Function),
      default: NOOP
    },
    onSuccess: {
      type: definePropType(Function),
      default: NOOP
    },
    onProgress: {
      type: definePropType(Function),
      default: NOOP
    },
    onError: {
      type: definePropType(Function),
      default: NOOP
    },
    onExceed: {
      type: definePropType(Function),
      default: NOOP
    }
  });

  const __default__$g = vue.defineComponent({
    name: "ElUploadContent",
    inheritAttrs: false
  });
  const _sfc_main$h = /* @__PURE__ */ vue.defineComponent({
    ...__default__$g,
    props: uploadContentProps,
    setup(__props, { expose }) {
      const props = __props;
      const ns = useNamespace("upload");
      const disabled = useFormDisabled();
      const requests = vue.shallowRef({});
      const inputRef = vue.shallowRef();
      const uploadFiles = (files) => {
        if (files.length === 0)
          return;
        const { autoUpload, limit, fileList, multiple, onStart, onExceed } = props;
        if (limit && fileList.length + files.length > limit) {
          onExceed(files, fileList);
          return;
        }
        if (!multiple) {
          files = files.slice(0, 1);
        }
        for (const file of files) {
          const rawFile = file;
          rawFile.uid = genFileId();
          onStart(rawFile);
          if (autoUpload)
            upload(rawFile);
        }
      };
      const upload = async (rawFile) => {
        inputRef.value.value = "";
        if (!props.beforeUpload) {
          return doUpload(rawFile);
        }
        let hookResult;
        let beforeData = {};
        try {
          const originData = props.data;
          const beforeUploadPromise = props.beforeUpload(rawFile);
          beforeData = isPlainObject$1(props.data) ? cloneDeep(props.data) : props.data;
          hookResult = await beforeUploadPromise;
          if (isPlainObject$1(props.data) && isEqual$1(originData, beforeData)) {
            beforeData = cloneDeep(props.data);
          }
        } catch (e) {
          hookResult = false;
        }
        if (hookResult === false) {
          props.onRemove(rawFile);
          return;
        }
        let file = rawFile;
        if (hookResult instanceof Blob) {
          if (hookResult instanceof File) {
            file = hookResult;
          } else {
            file = new File([hookResult], rawFile.name, {
              type: rawFile.type
            });
          }
        }
        doUpload(Object.assign(file, {
          uid: rawFile.uid
        }), beforeData);
      };
      const resolveData = async (data, rawFile) => {
        if (isFunction$1(data)) {
          return data(rawFile);
        }
        return data;
      };
      const doUpload = async (rawFile, beforeData) => {
        const {
          headers,
          data,
          method,
          withCredentials,
          name: filename,
          action,
          onProgress,
          onSuccess,
          onError,
          httpRequest
        } = props;
        try {
          beforeData = await resolveData(beforeData != null ? beforeData : data, rawFile);
        } catch (e) {
          props.onRemove(rawFile);
          return;
        }
        const { uid } = rawFile;
        const options = {
          headers: headers || {},
          withCredentials,
          file: rawFile,
          data: beforeData,
          method,
          filename,
          action,
          onProgress: (evt) => {
            onProgress(evt, rawFile);
          },
          onSuccess: (res) => {
            onSuccess(res, rawFile);
            delete requests.value[uid];
          },
          onError: (err) => {
            onError(err, rawFile);
            delete requests.value[uid];
          }
        };
        const request = httpRequest(options);
        requests.value[uid] = request;
        if (request instanceof Promise) {
          request.then(options.onSuccess, options.onError);
        }
      };
      const handleChange = (e) => {
        const files = e.target.files;
        if (!files)
          return;
        uploadFiles(Array.from(files));
      };
      const handleClick = () => {
        if (!disabled.value) {
          inputRef.value.value = "";
          inputRef.value.click();
        }
      };
      const handleKeydown = () => {
        handleClick();
      };
      const abort = (file) => {
        const _reqs = entriesOf(requests.value).filter(file ? ([uid]) => String(file.uid) === uid : () => true);
        _reqs.forEach(([uid, req]) => {
          if (req instanceof XMLHttpRequest)
            req.abort();
          delete requests.value[uid];
        });
      };
      expose({
        abort,
        upload
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([
            vue.unref(ns).b(),
            vue.unref(ns).m(_ctx.listType),
            vue.unref(ns).is("drag", _ctx.drag),
            vue.unref(ns).is("disabled", vue.unref(disabled))
          ]),
          tabindex: vue.unref(disabled) ? void 0 : 0,
          "aria-disabled": vue.unref(disabled),
          role: "button",
          onClick: handleClick,
          onKeydown: vue.withKeys(vue.withModifiers(handleKeydown, ["self"]), ["enter", "space"])
        }, [
          _ctx.drag ? (vue.openBlock(), vue.createBlock(UploadDragger, {
            key: 0,
            disabled: vue.unref(disabled),
            onFile: uploadFiles
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["disabled"])) : vue.renderSlot(_ctx.$slots, "default", { key: 1 }),
          vue.createElementVNode("input", {
            ref_key: "inputRef",
            ref: inputRef,
            class: vue.normalizeClass(vue.unref(ns).e("input")),
            name: _ctx.name,
            disabled: vue.unref(disabled),
            multiple: _ctx.multiple,
            accept: _ctx.accept,
            type: "file",
            onChange: handleChange,
            onClick: vue.withModifiers(() => {
            }, ["stop"])
          }, null, 42, ["name", "disabled", "multiple", "accept", "onClick"])
        ], 42, ["tabindex", "aria-disabled", "onKeydown"]);
      };
    }
  });
  var UploadContent = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__file", "upload-content.vue"]]);

  const SCOPE$1 = "ElUpload";
  const revokeFileObjectURL = (file) => {
    var _a;
    if ((_a = file.url) == null ? void 0 : _a.startsWith("blob:")) {
      URL.revokeObjectURL(file.url);
    }
  };
  const useHandlers = (props, uploadRef) => {
    const uploadFiles = useVModel(props, "fileList", void 0, { passive: true });
    const getFile = (rawFile) => uploadFiles.value.find((file) => file.uid === rawFile.uid);
    function abort(file) {
      var _a;
      (_a = uploadRef.value) == null ? void 0 : _a.abort(file);
    }
    function clearFiles(states = ["ready", "uploading", "success", "fail"]) {
      uploadFiles.value = uploadFiles.value.filter((row) => !states.includes(row.status));
    }
    function removeFile(file) {
      uploadFiles.value = uploadFiles.value.filter((uploadFile) => uploadFile.uid !== file.uid);
    }
    const handleError = (err, rawFile) => {
      const file = getFile(rawFile);
      if (!file)
        return;
      console.error(err);
      file.status = "fail";
      removeFile(file);
      props.onError(err, file, uploadFiles.value);
      props.onChange(file, uploadFiles.value);
    };
    const handleProgress = (evt, rawFile) => {
      const file = getFile(rawFile);
      if (!file)
        return;
      props.onProgress(evt, file, uploadFiles.value);
      file.status = "uploading";
      file.percentage = Math.round(evt.percent);
    };
    const handleSuccess = (response, rawFile) => {
      const file = getFile(rawFile);
      if (!file)
        return;
      file.status = "success";
      file.response = response;
      props.onSuccess(response, file, uploadFiles.value);
      props.onChange(file, uploadFiles.value);
    };
    const handleStart = (file) => {
      if (isNil(file.uid))
        file.uid = genFileId();
      const uploadFile = {
        name: file.name,
        percentage: 0,
        status: "ready",
        size: file.size,
        raw: file,
        uid: file.uid
      };
      if (props.listType === "picture-card" || props.listType === "picture") {
        try {
          uploadFile.url = URL.createObjectURL(file);
        } catch (err) {
          debugWarn(SCOPE$1, err.message);
          props.onError(err, uploadFile, uploadFiles.value);
        }
      }
      uploadFiles.value = [...uploadFiles.value, uploadFile];
      props.onChange(uploadFile, uploadFiles.value);
    };
    const handleRemove = async (file) => {
      const uploadFile = file instanceof File ? getFile(file) : file;
      if (!uploadFile)
        throwError(SCOPE$1, "file to be removed not found");
      const doRemove = (file2) => {
        abort(file2);
        removeFile(file2);
        props.onRemove(file2, uploadFiles.value);
        revokeFileObjectURL(file2);
      };
      if (props.beforeRemove) {
        const before = await props.beforeRemove(uploadFile, uploadFiles.value);
        if (before !== false)
          doRemove(uploadFile);
      } else {
        doRemove(uploadFile);
      }
    };
    function submit() {
      uploadFiles.value.filter(({ status }) => status === "ready").forEach(({ raw }) => {
        var _a;
        return raw && ((_a = uploadRef.value) == null ? void 0 : _a.upload(raw));
      });
    }
    vue.watch(() => props.listType, (val) => {
      if (val !== "picture-card" && val !== "picture") {
        return;
      }
      uploadFiles.value = uploadFiles.value.map((file) => {
        const { raw, url } = file;
        if (!url && raw) {
          try {
            file.url = URL.createObjectURL(raw);
          } catch (err) {
            props.onError(err, file, uploadFiles.value);
          }
        }
        return file;
      });
    });
    vue.watch(uploadFiles, (files) => {
      for (const file of files) {
        file.uid || (file.uid = genFileId());
        file.status || (file.status = "success");
      }
    }, { immediate: true, deep: true });
    return {
      uploadFiles,
      abort,
      clearFiles,
      handleError,
      handleProgress,
      handleStart,
      handleSuccess,
      handleRemove,
      submit,
      revokeFileObjectURL
    };
  };

  const __default__$f = vue.defineComponent({
    name: "ElUpload"
  });
  const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
    ...__default__$f,
    props: uploadProps,
    setup(__props, { expose }) {
      const props = __props;
      const disabled = useFormDisabled();
      const uploadRef = vue.shallowRef();
      const {
        abort,
        submit,
        clearFiles,
        uploadFiles,
        handleStart,
        handleError,
        handleRemove,
        handleSuccess,
        handleProgress,
        revokeFileObjectURL
      } = useHandlers(props, uploadRef);
      const isPictureCard = vue.computed(() => props.listType === "picture-card");
      const uploadContentProps = vue.computed(() => ({
        ...props,
        fileList: uploadFiles.value,
        onStart: handleStart,
        onProgress: handleProgress,
        onSuccess: handleSuccess,
        onError: handleError,
        onRemove: handleRemove
      }));
      vue.onBeforeUnmount(() => {
        uploadFiles.value.forEach(revokeFileObjectURL);
      });
      vue.provide(uploadContextKey, {
        accept: vue.toRef(props, "accept")
      });
      expose({
        abort,
        submit,
        clearFiles,
        handleStart,
        handleRemove
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", null, [
          vue.unref(isPictureCard) && _ctx.showFileList ? (vue.openBlock(), vue.createBlock(UploadList, {
            key: 0,
            disabled: vue.unref(disabled),
            "list-type": _ctx.listType,
            files: vue.unref(uploadFiles),
            crossorigin: _ctx.crossorigin,
            "handle-preview": _ctx.onPreview,
            onRemove: vue.unref(handleRemove)
          }, vue.createSlots({
            append: vue.withCtx(() => [
              vue.createVNode(UploadContent, vue.mergeProps({
                ref_key: "uploadRef",
                ref: uploadRef
              }, vue.unref(uploadContentProps)), {
                default: vue.withCtx(() => [
                  _ctx.$slots.trigger ? vue.renderSlot(_ctx.$slots, "trigger", { key: 0 }) : vue.createCommentVNode("v-if", true),
                  !_ctx.$slots.trigger && _ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 1 }) : vue.createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 16)
            ]),
            _: 2
          }, [
            _ctx.$slots.file ? {
              name: "default",
              fn: vue.withCtx(({ file, index }) => [
                vue.renderSlot(_ctx.$slots, "file", {
                  file,
                  index
                })
              ])
            } : void 0
          ]), 1032, ["disabled", "list-type", "files", "crossorigin", "handle-preview", "onRemove"])) : vue.createCommentVNode("v-if", true),
          !vue.unref(isPictureCard) || vue.unref(isPictureCard) && !_ctx.showFileList ? (vue.openBlock(), vue.createBlock(UploadContent, vue.mergeProps({
            key: 1,
            ref_key: "uploadRef",
            ref: uploadRef
          }, vue.unref(uploadContentProps)), {
            default: vue.withCtx(() => [
              _ctx.$slots.trigger ? vue.renderSlot(_ctx.$slots, "trigger", { key: 0 }) : vue.createCommentVNode("v-if", true),
              !_ctx.$slots.trigger && _ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 1 }) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 16)) : vue.createCommentVNode("v-if", true),
          _ctx.$slots.trigger ? vue.renderSlot(_ctx.$slots, "default", { key: 2 }) : vue.createCommentVNode("v-if", true),
          vue.renderSlot(_ctx.$slots, "tip"),
          !vue.unref(isPictureCard) && _ctx.showFileList ? (vue.openBlock(), vue.createBlock(UploadList, {
            key: 3,
            disabled: vue.unref(disabled),
            "list-type": _ctx.listType,
            files: vue.unref(uploadFiles),
            crossorigin: _ctx.crossorigin,
            "handle-preview": _ctx.onPreview,
            onRemove: vue.unref(handleRemove)
          }, vue.createSlots({
            _: 2
          }, [
            _ctx.$slots.file ? {
              name: "default",
              fn: vue.withCtx(({ file, index }) => [
                vue.renderSlot(_ctx.$slots, "file", {
                  file,
                  index
                })
              ])
            } : void 0
          ]), 1032, ["disabled", "list-type", "files", "crossorigin", "handle-preview", "onRemove"])) : vue.createCommentVNode("v-if", true)
        ]);
      };
    }
  });
  var Upload = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["__file", "upload.vue"]]);

  const ElUpload = withInstall(Upload);

  const watermarkProps = buildProps({
    zIndex: {
      type: Number,
      default: 9
    },
    rotate: {
      type: Number,
      default: -22
    },
    width: Number,
    height: Number,
    image: String,
    content: {
      type: definePropType([String, Array]),
      default: "Element Plus"
    },
    font: {
      type: definePropType(Object)
    },
    gap: {
      type: definePropType(Array),
      default: () => [100, 100]
    },
    offset: {
      type: definePropType(Array)
    }
  });

  function toLowercaseSeparator(key) {
    return key.replace(/([A-Z])/g, "-$1").toLowerCase();
  }
  function getStyleStr(style) {
    return Object.keys(style).map((key) => `${toLowercaseSeparator(key)}: ${style[key]};`).join(" ");
  }
  function getPixelRatio() {
    return window.devicePixelRatio || 1;
  }
  const reRendering = (mutation, watermarkElement) => {
    let flag = false;
    if (mutation.removedNodes.length && watermarkElement) {
      flag = Array.from(mutation.removedNodes).includes(watermarkElement);
    }
    if (mutation.type === "attributes" && mutation.target === watermarkElement) {
      flag = true;
    }
    return flag;
  };

  const TEXT_ALIGN_RATIO_MAP = {
    left: [0, 0.5],
    start: [0, 0.5],
    center: [0.5, 0],
    right: [1, -0.5],
    end: [1, -0.5]
  };
  function prepareCanvas(width, height, ratio = 1) {
    const canvas = document.createElement("canvas");
    const ctx = canvas.getContext("2d");
    const realWidth = width * ratio;
    const realHeight = height * ratio;
    canvas.setAttribute("width", `${realWidth}px`);
    canvas.setAttribute("height", `${realHeight}px`);
    ctx.save();
    return [ctx, canvas, realWidth, realHeight];
  }
  function useClips() {
    function getClips(content, rotate, ratio, width, height, font, gapX, gapY, space) {
      const [ctx, canvas, contentWidth, contentHeight] = prepareCanvas(width, height, ratio);
      if (content instanceof HTMLImageElement) {
        ctx.drawImage(content, 0, 0, contentWidth, contentHeight);
      } else {
        const {
          color,
          fontSize,
          fontStyle,
          fontWeight,
          fontFamily,
          textAlign,
          textBaseline
        } = font;
        const mergedFontSize = Number(fontSize) * ratio;
        ctx.font = `${fontStyle} normal ${fontWeight} ${mergedFontSize}px/${height}px ${fontFamily}`;
        ctx.fillStyle = color;
        ctx.textAlign = textAlign;
        ctx.textBaseline = textBaseline;
        const contents = isArray$1(content) ? content : [content];
        contents == null ? void 0 : contents.forEach((item, index) => {
          const [alignRatio, spaceRatio] = TEXT_ALIGN_RATIO_MAP[textAlign];
          ctx.fillText(item != null ? item : "", contentWidth * alignRatio + space * spaceRatio, index * (mergedFontSize + font.fontGap * ratio));
        });
      }
      const angle = Math.PI / 180 * Number(rotate);
      const maxSize = Math.max(width, height);
      const [rCtx, rCanvas, realMaxSize] = prepareCanvas(maxSize, maxSize, ratio);
      rCtx.translate(realMaxSize / 2, realMaxSize / 2);
      rCtx.rotate(angle);
      if (contentWidth > 0 && contentHeight > 0) {
        rCtx.drawImage(canvas, -contentWidth / 2, -contentHeight / 2);
      }
      function getRotatePos(x, y) {
        const targetX = x * Math.cos(angle) - y * Math.sin(angle);
        const targetY = x * Math.sin(angle) + y * Math.cos(angle);
        return [targetX, targetY];
      }
      let left = 0;
      let right = 0;
      let top = 0;
      let bottom = 0;
      const halfWidth = contentWidth / 2;
      const halfHeight = contentHeight / 2;
      const points = [
        [0 - halfWidth, 0 - halfHeight],
        [0 + halfWidth, 0 - halfHeight],
        [0 + halfWidth, 0 + halfHeight],
        [0 - halfWidth, 0 + halfHeight]
      ];
      points.forEach(([x, y]) => {
        const [targetX, targetY] = getRotatePos(x, y);
        left = Math.min(left, targetX);
        right = Math.max(right, targetX);
        top = Math.min(top, targetY);
        bottom = Math.max(bottom, targetY);
      });
      const cutLeft = left + realMaxSize / 2;
      const cutTop = top + realMaxSize / 2;
      const cutWidth = right - left;
      const cutHeight = bottom - top;
      const realGapX = gapX * ratio;
      const realGapY = gapY * ratio;
      const filledWidth = (cutWidth + realGapX) * 2;
      const filledHeight = cutHeight + realGapY;
      const [fCtx, fCanvas] = prepareCanvas(filledWidth, filledHeight);
      function drawImg(targetX = 0, targetY = 0) {
        fCtx.drawImage(rCanvas, cutLeft, cutTop, cutWidth, cutHeight, targetX, targetY, cutWidth, cutHeight);
      }
      drawImg();
      drawImg(cutWidth + realGapX, -cutHeight / 2 - realGapY / 2);
      drawImg(cutWidth + realGapX, +cutHeight / 2 + realGapY / 2);
      return [fCanvas.toDataURL(), filledWidth / ratio, filledHeight / ratio];
    }
    return getClips;
  }

  const __default__$e = vue.defineComponent({
    name: "ElWatermark"
  });
  const _sfc_main$f = /* @__PURE__ */ vue.defineComponent({
    ...__default__$e,
    props: watermarkProps,
    setup(__props) {
      const props = __props;
      const style = {
        position: "relative"
      };
      const fontGap = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.fontGap) != null ? _b : 3;
      });
      const color = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.color) != null ? _b : "rgba(0,0,0,.15)";
      });
      const fontSize = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.fontSize) != null ? _b : 16;
      });
      const fontWeight = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.fontWeight) != null ? _b : "normal";
      });
      const fontStyle = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.fontStyle) != null ? _b : "normal";
      });
      const fontFamily = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.fontFamily) != null ? _b : "sans-serif";
      });
      const textAlign = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.textAlign) != null ? _b : "center";
      });
      const textBaseline = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.font) == null ? void 0 : _a.textBaseline) != null ? _b : "hanging";
      });
      const gapX = vue.computed(() => props.gap[0]);
      const gapY = vue.computed(() => props.gap[1]);
      const gapXCenter = vue.computed(() => gapX.value / 2);
      const gapYCenter = vue.computed(() => gapY.value / 2);
      const offsetLeft = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.offset) == null ? void 0 : _a[0]) != null ? _b : gapXCenter.value;
      });
      const offsetTop = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.offset) == null ? void 0 : _a[1]) != null ? _b : gapYCenter.value;
      });
      const getMarkStyle = () => {
        const markStyle = {
          zIndex: props.zIndex,
          position: "absolute",
          left: 0,
          top: 0,
          width: "100%",
          height: "100%",
          pointerEvents: "none",
          backgroundRepeat: "repeat"
        };
        let positionLeft = offsetLeft.value - gapXCenter.value;
        let positionTop = offsetTop.value - gapYCenter.value;
        if (positionLeft > 0) {
          markStyle.left = `${positionLeft}px`;
          markStyle.width = `calc(100% - ${positionLeft}px)`;
          positionLeft = 0;
        }
        if (positionTop > 0) {
          markStyle.top = `${positionTop}px`;
          markStyle.height = `calc(100% - ${positionTop}px)`;
          positionTop = 0;
        }
        markStyle.backgroundPosition = `${positionLeft}px ${positionTop}px`;
        return markStyle;
      };
      const containerRef = vue.shallowRef(null);
      const watermarkRef = vue.shallowRef();
      const stopObservation = vue.ref(false);
      const destroyWatermark = () => {
        if (watermarkRef.value) {
          watermarkRef.value.remove();
          watermarkRef.value = void 0;
        }
      };
      const appendWatermark = (base64Url, markWidth) => {
        var _a;
        if (containerRef.value && watermarkRef.value) {
          stopObservation.value = true;
          watermarkRef.value.setAttribute("style", getStyleStr({
            ...getMarkStyle(),
            backgroundImage: `url('${base64Url}')`,
            backgroundSize: `${Math.floor(markWidth)}px`
          }));
          (_a = containerRef.value) == null ? void 0 : _a.append(watermarkRef.value);
          setTimeout(() => {
            stopObservation.value = false;
          });
        }
      };
      const getMarkSize = (ctx) => {
        let defaultWidth = 120;
        let defaultHeight = 64;
        let space = 0;
        const { image, content, width, height, rotate } = props;
        if (!image && ctx.measureText) {
          ctx.font = `${Number(fontSize.value)}px ${fontFamily.value}`;
          const contents = isArray$1(content) ? content : [content];
          let maxWidth = 0;
          let maxHeight = 0;
          contents.forEach((item) => {
            const {
              width: width2,
              fontBoundingBoxAscent,
              fontBoundingBoxDescent,
              actualBoundingBoxAscent,
              actualBoundingBoxDescent
            } = ctx.measureText(item);
            const height2 = isUndefined(fontBoundingBoxAscent) ? actualBoundingBoxAscent + actualBoundingBoxDescent : fontBoundingBoxAscent + fontBoundingBoxDescent;
            if (width2 > maxWidth)
              maxWidth = Math.ceil(width2);
            if (height2 > maxHeight)
              maxHeight = Math.ceil(height2);
          });
          defaultWidth = maxWidth;
          defaultHeight = maxHeight * contents.length + (contents.length - 1) * fontGap.value;
          const angle = Math.PI / 180 * Number(rotate);
          space = Math.ceil(Math.abs(Math.sin(angle) * defaultHeight) / 2);
          defaultWidth += space;
        }
        return [width != null ? width : defaultWidth, height != null ? height : defaultHeight, space];
      };
      const getClips = useClips();
      const renderWatermark = () => {
        const canvas = document.createElement("canvas");
        const ctx = canvas.getContext("2d");
        const image = props.image;
        const content = props.content;
        const rotate = props.rotate;
        if (ctx) {
          if (!watermarkRef.value) {
            watermarkRef.value = document.createElement("div");
          }
          const ratio = getPixelRatio();
          const [markWidth, markHeight, space] = getMarkSize(ctx);
          const drawCanvas = (drawContent) => {
            const [textClips, clipWidth] = getClips(drawContent || "", rotate, ratio, markWidth, markHeight, {
              color: color.value,
              fontSize: fontSize.value,
              fontStyle: fontStyle.value,
              fontWeight: fontWeight.value,
              fontFamily: fontFamily.value,
              fontGap: fontGap.value,
              textAlign: textAlign.value,
              textBaseline: textBaseline.value
            }, gapX.value, gapY.value, space);
            appendWatermark(textClips, clipWidth);
          };
          if (image) {
            const img = new Image();
            img.onload = () => {
              drawCanvas(img);
            };
            img.onerror = () => {
              drawCanvas(content);
            };
            img.crossOrigin = "anonymous";
            img.referrerPolicy = "no-referrer";
            img.src = image;
          } else {
            drawCanvas(content);
          }
        }
      };
      vue.onMounted(() => {
        renderWatermark();
      });
      vue.watch(() => props, () => {
        renderWatermark();
      }, {
        deep: true,
        flush: "post"
      });
      vue.onBeforeUnmount(() => {
        destroyWatermark();
      });
      const onMutate = (mutations) => {
        if (stopObservation.value) {
          return;
        }
        mutations.forEach((mutation) => {
          if (reRendering(mutation, watermarkRef.value)) {
            destroyWatermark();
            renderWatermark();
          }
        });
      };
      useMutationObserver(containerRef, onMutate, {
        attributes: true,
        subtree: true,
        childList: true
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "containerRef",
          ref: containerRef,
          style: vue.normalizeStyle([style])
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 4);
      };
    }
  });
  var Watermark = /* @__PURE__ */ _export_sfc(_sfc_main$f, [["__file", "watermark.vue"]]);

  const ElWatermark = withInstall(Watermark);

  const maskProps = buildProps({
    zIndex: {
      type: Number,
      default: 1001
    },
    visible: Boolean,
    fill: {
      type: String,
      default: "rgba(0,0,0,0.5)"
    },
    pos: {
      type: definePropType(Object)
    },
    targetAreaClickable: {
      type: Boolean,
      default: true
    }
  });

  function getSide(placement) {
    return placement.split('-')[0];
  }

  function getAlignment(placement) {
    return placement.split('-')[1];
  }

  function getMainAxisFromPlacement(placement) {
    return ['top', 'bottom'].includes(getSide(placement)) ? 'x' : 'y';
  }

  function getLengthFromAxis(axis) {
    return axis === 'y' ? 'height' : 'width';
  }

  function computeCoordsFromPlacement(_ref, placement, rtl) {
    let {
      reference,
      floating
    } = _ref;
    const commonX = reference.x + reference.width / 2 - floating.width / 2;
    const commonY = reference.y + reference.height / 2 - floating.height / 2;
    const mainAxis = getMainAxisFromPlacement(placement);
    const length = getLengthFromAxis(mainAxis);
    const commonAlign = reference[length] / 2 - floating[length] / 2;
    const side = getSide(placement);
    const isVertical = mainAxis === 'x';
    let coords;

    switch (side) {
      case 'top':
        coords = {
          x: commonX,
          y: reference.y - floating.height
        };
        break;

      case 'bottom':
        coords = {
          x: commonX,
          y: reference.y + reference.height
        };
        break;

      case 'right':
        coords = {
          x: reference.x + reference.width,
          y: commonY
        };
        break;

      case 'left':
        coords = {
          x: reference.x - floating.width,
          y: commonY
        };
        break;

      default:
        coords = {
          x: reference.x,
          y: reference.y
        };
    }

    switch (getAlignment(placement)) {
      case 'start':
        coords[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
        break;

      case 'end':
        coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
        break;
    }

    return coords;
  }

  /**
   * Computes the `x` and `y` coordinates that will place the floating element
   * next to a reference element when it is given a certain positioning strategy.
   *
   * This export does not have any `platform` interface logic. You will need to
   * write one for the platform you are using Floating UI with.
   */

  const computePosition$1 = async (reference, floating, config) => {
    const {
      placement = 'bottom',
      strategy = 'absolute',
      middleware = [],
      platform
    } = config;
    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));

    let rects = await platform.getElementRects({
      reference,
      floating,
      strategy
    });
    let {
      x,
      y
    } = computeCoordsFromPlacement(rects, placement, rtl);
    let statefulPlacement = placement;
    let middlewareData = {};
    let resetCount = 0;

    for (let i = 0; i < middleware.length; i++) {
      const {
        name,
        fn
      } = middleware[i];
      const {
        x: nextX,
        y: nextY,
        data,
        reset
      } = await fn({
        x,
        y,
        initialPlacement: placement,
        placement: statefulPlacement,
        strategy,
        middlewareData,
        rects,
        platform,
        elements: {
          reference,
          floating
        }
      });
      x = nextX != null ? nextX : x;
      y = nextY != null ? nextY : y;
      middlewareData = { ...middlewareData,
        [name]: { ...middlewareData[name],
          ...data
        }
      };

      if (reset && resetCount <= 50) {
        resetCount++;

        if (typeof reset === 'object') {
          if (reset.placement) {
            statefulPlacement = reset.placement;
          }

          if (reset.rects) {
            rects = reset.rects === true ? await platform.getElementRects({
              reference,
              floating,
              strategy
            }) : reset.rects;
          }

          ({
            x,
            y
          } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
        }

        i = -1;
        continue;
      }
    }

    return {
      x,
      y,
      placement: statefulPlacement,
      strategy,
      middlewareData
    };
  };

  function expandPaddingObject(padding) {
    return {
      top: 0,
      right: 0,
      bottom: 0,
      left: 0,
      ...padding
    };
  }

  function getSideObjectFromPadding(padding) {
    return typeof padding !== 'number' ? expandPaddingObject(padding) : {
      top: padding,
      right: padding,
      bottom: padding,
      left: padding
    };
  }

  function rectToClientRect(rect) {
    return { ...rect,
      top: rect.y,
      left: rect.x,
      right: rect.x + rect.width,
      bottom: rect.y + rect.height
    };
  }

  /**
   * Resolves with an object of overflow side offsets that determine how much the
   * element is overflowing a given clipping boundary.
   * - positive = overflowing the boundary by that number of pixels
   * - negative = how many pixels left before it will overflow
   * - 0 = lies flush with the boundary
   * @see https://floating-ui.com/docs/detectOverflow
   */
  async function detectOverflow(middlewareArguments, options) {
    var _await$platform$isEle;

    if (options === void 0) {
      options = {};
    }

    const {
      x,
      y,
      platform,
      rects,
      elements,
      strategy
    } = middlewareArguments;
    const {
      boundary = 'clippingAncestors',
      rootBoundary = 'viewport',
      elementContext = 'floating',
      altBoundary = false,
      padding = 0
    } = options;
    const paddingObject = getSideObjectFromPadding(padding);
    const altContext = elementContext === 'floating' ? 'reference' : 'floating';
    const element = elements[altBoundary ? altContext : elementContext];
    const clippingClientRect = rectToClientRect(await platform.getClippingRect({
      element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
      boundary,
      rootBoundary,
      strategy
    }));
    const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
      rect: elementContext === 'floating' ? { ...rects.floating,
        x,
        y
      } : rects.reference,
      offsetParent: await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating)),
      strategy
    }) : rects[elementContext]);
    return {
      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
    };
  }

  const min$1 = Math.min;
  const max$1 = Math.max;

  function within(min$1$1, value, max$1$1) {
    return max$1(min$1$1, min$1(value, max$1$1));
  }

  /**
   * Positions an inner element of the floating element such that it is centered
   * to the reference element.
   * @see https://floating-ui.com/docs/arrow
   */
  const arrow = options => ({
    name: 'arrow',
    options,

    async fn(middlewareArguments) {
      // Since `element` is required, we don't Partial<> the type
      const {
        element,
        padding = 0
      } = options != null ? options : {};
      const {
        x,
        y,
        placement,
        rects,
        platform
      } = middlewareArguments;

      if (element == null) {

        return {};
      }

      const paddingObject = getSideObjectFromPadding(padding);
      const coords = {
        x,
        y
      };
      const axis = getMainAxisFromPlacement(placement);
      const alignment = getAlignment(placement);
      const length = getLengthFromAxis(axis);
      const arrowDimensions = await platform.getDimensions(element);
      const minProp = axis === 'y' ? 'top' : 'left';
      const maxProp = axis === 'y' ? 'bottom' : 'right';
      const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
      const startDiff = coords[axis] - rects.reference[axis];
      const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
      let clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;

      if (clientSize === 0) {
        clientSize = rects.floating[length];
      }

      const centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the floating element if the center
      // point is outside the floating element's bounds

      const min = paddingObject[minProp];
      const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];
      const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
      const offset = within(min, center, max); // Make sure that arrow points at the reference

      const alignmentPadding = alignment === 'start' ? paddingObject[minProp] : paddingObject[maxProp];
      const shouldAddOffset = alignmentPadding > 0 && center !== offset && rects.reference[length] <= rects.floating[length];
      const alignmentOffset = shouldAddOffset ? center < min ? min - center : max - center : 0;
      return {
        [axis]: coords[axis] - alignmentOffset,
        data: {
          [axis]: offset,
          centerOffset: center - offset
        }
      };
    }

  });

  const hash$1 = {
    left: 'right',
    right: 'left',
    bottom: 'top',
    top: 'bottom'
  };
  function getOppositePlacement(placement) {
    return placement.replace(/left|right|bottom|top/g, matched => hash$1[matched]);
  }

  function getAlignmentSides(placement, rects, rtl) {
    if (rtl === void 0) {
      rtl = false;
    }

    const alignment = getAlignment(placement);
    const mainAxis = getMainAxisFromPlacement(placement);
    const length = getLengthFromAxis(mainAxis);
    let mainAlignmentSide = mainAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';

    if (rects.reference[length] > rects.floating[length]) {
      mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
    }

    return {
      main: mainAlignmentSide,
      cross: getOppositePlacement(mainAlignmentSide)
    };
  }

  const hash = {
    start: 'end',
    end: 'start'
  };
  function getOppositeAlignmentPlacement(placement) {
    return placement.replace(/start|end/g, matched => hash[matched]);
  }

  function getExpandedPlacements(placement) {
    const oppositePlacement = getOppositePlacement(placement);
    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
  }

  /**
   * Changes the placement of the floating element to one that will fit if the
   * initially specified `placement` does not.
   * @see https://floating-ui.com/docs/flip
   */
  const flip = function (options) {
    if (options === void 0) {
      options = {};
    }

    return {
      name: 'flip',
      options,

      async fn(middlewareArguments) {
        var _middlewareData$flip;

        const {
          placement,
          middlewareData,
          rects,
          initialPlacement,
          platform,
          elements
        } = middlewareArguments;
        const {
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = true,
          fallbackPlacements: specifiedFallbackPlacements,
          fallbackStrategy = 'bestFit',
          flipAlignment = true,
          ...detectOverflowOptions
        } = options;
        const side = getSide(placement);
        const isBasePlacement = side === initialPlacement;
        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
        const placements = [initialPlacement, ...fallbackPlacements];
        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
        const overflows = [];
        let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];

        if (checkMainAxis) {
          overflows.push(overflow[side]);
        }

        if (checkCrossAxis) {
          const {
            main,
            cross
          } = getAlignmentSides(placement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
          overflows.push(overflow[main], overflow[cross]);
        }

        overflowsData = [...overflowsData, {
          placement,
          overflows
        }]; // One or more sides is overflowing

        if (!overflows.every(side => side <= 0)) {
          var _middlewareData$flip$, _middlewareData$flip2;

          const nextIndex = ((_middlewareData$flip$ = (_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) != null ? _middlewareData$flip$ : 0) + 1;
          const nextPlacement = placements[nextIndex];

          if (nextPlacement) {
            // Try next placement and re-run the lifecycle
            return {
              data: {
                index: nextIndex,
                overflows: overflowsData
              },
              reset: {
                placement: nextPlacement
              }
            };
          }

          let resetPlacement = 'bottom';

          switch (fallbackStrategy) {
            case 'bestFit':
              {
                var _overflowsData$map$so;

                const placement = (_overflowsData$map$so = overflowsData.map(d => [d, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement;

                if (placement) {
                  resetPlacement = placement;
                }

                break;
              }

            case 'initialPlacement':
              resetPlacement = initialPlacement;
              break;
          }

          if (placement !== resetPlacement) {
            return {
              reset: {
                placement: resetPlacement
              }
            };
          }
        }

        return {};
      }

    };
  };

  async function convertValueToCoords(middlewareArguments, value) {
    const {
      placement,
      platform,
      elements
    } = middlewareArguments;
    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
    const side = getSide(placement);
    const alignment = getAlignment(placement);
    const isVertical = getMainAxisFromPlacement(placement) === 'x';
    const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
    const crossAxisMulti = rtl && isVertical ? -1 : 1;
    const rawValue = typeof value === 'function' ? value(middlewareArguments) : value; // eslint-disable-next-line prefer-const

    let {
      mainAxis,
      crossAxis,
      alignmentAxis
    } = typeof rawValue === 'number' ? {
      mainAxis: rawValue,
      crossAxis: 0,
      alignmentAxis: null
    } : {
      mainAxis: 0,
      crossAxis: 0,
      alignmentAxis: null,
      ...rawValue
    };

    if (alignment && typeof alignmentAxis === 'number') {
      crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
    }

    return isVertical ? {
      x: crossAxis * crossAxisMulti,
      y: mainAxis * mainAxisMulti
    } : {
      x: mainAxis * mainAxisMulti,
      y: crossAxis * crossAxisMulti
    };
  }
  /**
   * Displaces the floating element from its reference element.
   * @see https://floating-ui.com/docs/offset
   */

  const offset = function (value) {
    if (value === void 0) {
      value = 0;
    }

    return {
      name: 'offset',
      options: value,

      async fn(middlewareArguments) {
        const {
          x,
          y
        } = middlewareArguments;
        const diffCoords = await convertValueToCoords(middlewareArguments, value);
        return {
          x: x + diffCoords.x,
          y: y + diffCoords.y,
          data: diffCoords
        };
      }

    };
  };

  function getCrossAxis(axis) {
    return axis === 'x' ? 'y' : 'x';
  }

  /**
   * Shifts the floating element in order to keep it in view when it will overflow
   * a clipping boundary.
   * @see https://floating-ui.com/docs/shift
   */
  const shift = function (options) {
    if (options === void 0) {
      options = {};
    }

    return {
      name: 'shift',
      options,

      async fn(middlewareArguments) {
        const {
          x,
          y,
          placement
        } = middlewareArguments;
        const {
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = false,
          limiter = {
            fn: _ref => {
              let {
                x,
                y
              } = _ref;
              return {
                x,
                y
              };
            }
          },
          ...detectOverflowOptions
        } = options;
        const coords = {
          x,
          y
        };
        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
        const mainAxis = getMainAxisFromPlacement(getSide(placement));
        const crossAxis = getCrossAxis(mainAxis);
        let mainAxisCoord = coords[mainAxis];
        let crossAxisCoord = coords[crossAxis];

        if (checkMainAxis) {
          const minSide = mainAxis === 'y' ? 'top' : 'left';
          const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
          const min = mainAxisCoord + overflow[minSide];
          const max = mainAxisCoord - overflow[maxSide];
          mainAxisCoord = within(min, mainAxisCoord, max);
        }

        if (checkCrossAxis) {
          const minSide = crossAxis === 'y' ? 'top' : 'left';
          const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
          const min = crossAxisCoord + overflow[minSide];
          const max = crossAxisCoord - overflow[maxSide];
          crossAxisCoord = within(min, crossAxisCoord, max);
        }

        const limitedCoords = limiter.fn({ ...middlewareArguments,
          [mainAxis]: mainAxisCoord,
          [crossAxis]: crossAxisCoord
        });
        return { ...limitedCoords,
          data: {
            x: limitedCoords.x - x,
            y: limitedCoords.y - y
          }
        };
      }

    };
  };

  function isWindow(value) {
    return value && value.document && value.location && value.alert && value.setInterval;
  }
  function getWindow(node) {
    if (node == null) {
      return window;
    }

    if (!isWindow(node)) {
      const ownerDocument = node.ownerDocument;
      return ownerDocument ? ownerDocument.defaultView || window : window;
    }

    return node;
  }

  function getComputedStyle$1(element) {
    return getWindow(element).getComputedStyle(element);
  }

  function getNodeName(node) {
    return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';
  }

  function getUAString() {
    const uaData = navigator.userAgentData;

    if (uaData != null && uaData.brands) {
      return uaData.brands.map(item => item.brand + "/" + item.version).join(' ');
    }

    return navigator.userAgent;
  }

  function isHTMLElement(value) {
    return value instanceof getWindow(value).HTMLElement;
  }
  function isElement(value) {
    return value instanceof getWindow(value).Element;
  }
  function isNode(value) {
    return value instanceof getWindow(value).Node;
  }
  function isShadowRoot(node) {
    // Browsers without `ShadowRoot` support
    if (typeof ShadowRoot === 'undefined') {
      return false;
    }

    const OwnElement = getWindow(node).ShadowRoot;
    return node instanceof OwnElement || node instanceof ShadowRoot;
  }
  function isOverflowElement(element) {
    // Firefox wants us to check `-x` and `-y` variations as well
    const {
      overflow,
      overflowX,
      overflowY
    } = getComputedStyle$1(element);
    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
  }
  function isTableElement(element) {
    return ['table', 'td', 'th'].includes(getNodeName(element));
  }
  function isContainingBlock(element) {
    // TODO: Try and use feature detection here instead
    const isFirefox = /firefox/i.test(getUAString());
    const css = getComputedStyle$1(element); // This is non-exhaustive but covers the most common CSS properties that
    // create a containing block.
    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block

    return css.transform !== 'none' || css.perspective !== 'none' || // @ts-ignore (TS 4.1 compat)
    css.contain === 'paint' || ['transform', 'perspective'].includes(css.willChange) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false);
  }
  function isLayoutViewport() {
    // Not Safari
    return !/^((?!chrome|android).)*safari/i.test(getUAString()); // Feature detection for this fails in various ways
    // • Always-visible scrollbar or not
    // • Width of <html>, etc.
    // const vV = win.visualViewport;
    // return vV ? Math.abs(win.innerWidth / vV.scale - vV.width) < 0.5 : true;
  }

  const min = Math.min;
  const max = Math.max;
  const round = Math.round;

  function getBoundingClientRect(element, includeScale, isFixedStrategy) {
    var _win$visualViewport$o, _win$visualViewport, _win$visualViewport$o2, _win$visualViewport2;

    if (includeScale === void 0) {
      includeScale = false;
    }

    if (isFixedStrategy === void 0) {
      isFixedStrategy = false;
    }

    const clientRect = element.getBoundingClientRect();
    let scaleX = 1;
    let scaleY = 1;

    if (includeScale && isHTMLElement(element)) {
      scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
      scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
    }

    const win = isElement(element) ? getWindow(element) : window;
    const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
    const x = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX;
    const y = (clientRect.top + (addVisualOffsets ? (_win$visualViewport$o2 = (_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) != null ? _win$visualViewport$o2 : 0 : 0)) / scaleY;
    const width = clientRect.width / scaleX;
    const height = clientRect.height / scaleY;
    return {
      width,
      height,
      top: y,
      right: x + width,
      bottom: y + height,
      left: x,
      x,
      y
    };
  }

  function getDocumentElement(node) {
    return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
  }

  function getNodeScroll(element) {
    if (isElement(element)) {
      return {
        scrollLeft: element.scrollLeft,
        scrollTop: element.scrollTop
      };
    }

    return {
      scrollLeft: element.pageXOffset,
      scrollTop: element.pageYOffset
    };
  }

  function getWindowScrollBarX(element) {
    // If <html> has a CSS width greater than the viewport, then this will be
    // incorrect for RTL.
    return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
  }

  function isScaled(element) {
    const rect = getBoundingClientRect(element);
    return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;
  }

  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
    const isOffsetParentAnElement = isHTMLElement(offsetParent);
    const documentElement = getDocumentElement(offsetParent);
    const rect = getBoundingClientRect(element, // @ts-ignore - checked above (TS 4.1 compat)
    isOffsetParentAnElement && isScaled(offsetParent), strategy === 'fixed');
    let scroll = {
      scrollLeft: 0,
      scrollTop: 0
    };
    const offsets = {
      x: 0,
      y: 0
    };

    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
        scroll = getNodeScroll(offsetParent);
      }

      if (isHTMLElement(offsetParent)) {
        const offsetRect = getBoundingClientRect(offsetParent, true);
        offsets.x = offsetRect.x + offsetParent.clientLeft;
        offsets.y = offsetRect.y + offsetParent.clientTop;
      } else if (documentElement) {
        offsets.x = getWindowScrollBarX(documentElement);
      }
    }

    return {
      x: rect.left + scroll.scrollLeft - offsets.x,
      y: rect.top + scroll.scrollTop - offsets.y,
      width: rect.width,
      height: rect.height
    };
  }

  function getParentNode(node) {
    if (getNodeName(node) === 'html') {
      return node;
    }

    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
      // @ts-ignore
      node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
      node.parentNode || ( // DOM Element detected
      isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
      getDocumentElement(node) // fallback

    );
  }

  function getTrueOffsetParent(element) {
    if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
      return null;
    }

    return composedOffsetParent(element);
  }
  /**
   * Polyfills the old offsetParent behavior from before the spec was changed:
   * https://github.com/w3c/csswg-drafts/issues/159
   */


  function composedOffsetParent(element) {
    let {
      offsetParent
    } = element;
    let ancestor = element;
    let foundInsideSlot = false;

    while (ancestor && ancestor !== offsetParent) {
      const {
        assignedSlot
      } = ancestor;

      if (assignedSlot) {
        let newOffsetParent = assignedSlot.offsetParent;

        if (getComputedStyle$1(assignedSlot).display === 'contents') {
          const hadStyleAttribute = assignedSlot.hasAttribute('style');
          const oldDisplay = assignedSlot.style.display;
          assignedSlot.style.display = getComputedStyle$1(ancestor).display;
          newOffsetParent = assignedSlot.offsetParent;
          assignedSlot.style.display = oldDisplay;

          if (!hadStyleAttribute) {
            assignedSlot.removeAttribute('style');
          }
        }

        ancestor = assignedSlot;

        if (offsetParent !== newOffsetParent) {
          offsetParent = newOffsetParent;
          foundInsideSlot = true;
        }
      } else if (isShadowRoot(ancestor) && ancestor.host && foundInsideSlot) {
        break;
      }

      ancestor = isShadowRoot(ancestor) && ancestor.host || ancestor.parentNode;
    }

    return offsetParent;
  }

  function getContainingBlock(element) {
    let currentNode = getParentNode(element);

    if (isShadowRoot(currentNode)) {
      currentNode = currentNode.host;
    }

    while (isHTMLElement(currentNode) && !['html', 'body'].includes(getNodeName(currentNode))) {
      if (isContainingBlock(currentNode)) {
        return currentNode;
      } else {
        const parent = currentNode.parentNode;
        currentNode = isShadowRoot(parent) ? parent.host : parent;
      }
    }

    return null;
  } // Gets the closest ancestor positioned element. Handles some edge cases,
  // such as table ancestors and cross browser bugs.


  function getOffsetParent(element) {
    const window = getWindow(element);
    let offsetParent = getTrueOffsetParent(element);

    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
      offsetParent = getTrueOffsetParent(offsetParent);
    }

    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
      return window;
    }

    return offsetParent || getContainingBlock(element) || window;
  }

  function getDimensions(element) {
    if (isHTMLElement(element)) {
      return {
        width: element.offsetWidth,
        height: element.offsetHeight
      };
    }

    const rect = getBoundingClientRect(element);
    return {
      width: rect.width,
      height: rect.height
    };
  }

  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
    let {
      rect,
      offsetParent,
      strategy
    } = _ref;
    const isOffsetParentAnElement = isHTMLElement(offsetParent);
    const documentElement = getDocumentElement(offsetParent);

    if (offsetParent === documentElement) {
      return rect;
    }

    let scroll = {
      scrollLeft: 0,
      scrollTop: 0
    };
    const offsets = {
      x: 0,
      y: 0
    };

    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
        scroll = getNodeScroll(offsetParent);
      }

      if (isHTMLElement(offsetParent)) {
        const offsetRect = getBoundingClientRect(offsetParent, true);
        offsets.x = offsetRect.x + offsetParent.clientLeft;
        offsets.y = offsetRect.y + offsetParent.clientTop;
      } // This doesn't appear to be need to be negated.
      // else if (documentElement) {
      //   offsets.x = getWindowScrollBarX(documentElement);
      // }

    }

    return { ...rect,
      x: rect.x - scroll.scrollLeft + offsets.x,
      y: rect.y - scroll.scrollTop + offsets.y
    };
  }

  function getViewportRect(element, strategy) {
    const win = getWindow(element);
    const html = getDocumentElement(element);
    const visualViewport = win.visualViewport;
    let width = html.clientWidth;
    let height = html.clientHeight;
    let x = 0;
    let y = 0;

    if (visualViewport) {
      width = visualViewport.width;
      height = visualViewport.height;
      const layoutViewport = isLayoutViewport();

      if (layoutViewport || !layoutViewport && strategy === 'fixed') {
        x = visualViewport.offsetLeft;
        y = visualViewport.offsetTop;
      }
    }

    return {
      width,
      height,
      x,
      y
    };
  }

  // of the `<html>` and `<body>` rect bounds if horizontally scrollable

  function getDocumentRect(element) {
    var _element$ownerDocumen;

    const html = getDocumentElement(element);
    const scroll = getNodeScroll(element);
    const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
    const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
    const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
    const y = -scroll.scrollTop;

    if (getComputedStyle$1(body || html).direction === 'rtl') {
      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
    }

    return {
      width,
      height,
      x,
      y
    };
  }

  function getNearestOverflowAncestor(node) {
    const parentNode = getParentNode(node);

    if (['html', 'body', '#document'].includes(getNodeName(parentNode))) {
      // @ts-ignore assume body is always available
      return node.ownerDocument.body;
    }

    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
      return parentNode;
    }

    return getNearestOverflowAncestor(parentNode);
  }

  function getOverflowAncestors(node, list) {
    var _node$ownerDocument;

    if (list === void 0) {
      list = [];
    }

    const scrollableAncestor = getNearestOverflowAncestor(node);
    const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
    const win = getWindow(scrollableAncestor);
    const target = isBody ? [win].concat(win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []) : scrollableAncestor;
    const updatedList = list.concat(target);
    return isBody ? updatedList : // @ts-ignore: isBody tells us target will be an HTMLElement here
    updatedList.concat(getOverflowAncestors(target));
  }

  function contains(parent, child) {
    const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method

    if (parent.contains(child)) {
      return true;
    } // then fallback to custom implementation with Shadow DOM support
    else if (rootNode && isShadowRoot(rootNode)) {
      let next = child;

      do {
        // use `===` replace node.isSameNode()
        if (next && parent === next) {
          return true;
        } // @ts-ignore: need a better way to handle this...


        next = next.parentNode || next.host;
      } while (next);
    }

    return false;
  }

  function getInnerBoundingClientRect(element, strategy) {
    const clientRect = getBoundingClientRect(element, false, strategy === 'fixed');
    const top = clientRect.top + element.clientTop;
    const left = clientRect.left + element.clientLeft;
    return {
      top,
      left,
      x: left,
      y: top,
      right: left + element.clientWidth,
      bottom: top + element.clientHeight,
      width: element.clientWidth,
      height: element.clientHeight
    };
  }

  function getClientRectFromClippingAncestor(element, clippingParent, strategy) {
    if (clippingParent === 'viewport') {
      return rectToClientRect(getViewportRect(element, strategy));
    }

    if (isElement(clippingParent)) {
      return getInnerBoundingClientRect(clippingParent, strategy);
    }

    return rectToClientRect(getDocumentRect(getDocumentElement(element)));
  } // A "clipping ancestor" is an overflowable container with the characteristic of
  // clipping (or hiding) overflowing elements with a position different from
  // `initial`


  function getClippingAncestors(element) {
    const clippingAncestors = getOverflowAncestors(element);
    const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle$1(element).position);
    const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;

    if (!isElement(clipperElement)) {
      return [];
    } // @ts-ignore isElement check ensures we return Array<Element>


    return clippingAncestors.filter(clippingAncestors => isElement(clippingAncestors) && contains(clippingAncestors, clipperElement) && getNodeName(clippingAncestors) !== 'body');
  } // Gets the maximum area that the element is visible in due to any number of
  // clipping ancestors


  function getClippingRect(_ref) {
    let {
      element,
      boundary,
      rootBoundary,
      strategy
    } = _ref;
    const mainClippingAncestors = boundary === 'clippingAncestors' ? getClippingAncestors(element) : [].concat(boundary);
    const clippingAncestors = [...mainClippingAncestors, rootBoundary];
    const firstClippingAncestor = clippingAncestors[0];
    const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
      const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
      accRect.top = max(rect.top, accRect.top);
      accRect.right = min(rect.right, accRect.right);
      accRect.bottom = min(rect.bottom, accRect.bottom);
      accRect.left = max(rect.left, accRect.left);
      return accRect;
    }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
    return {
      width: clippingRect.right - clippingRect.left,
      height: clippingRect.bottom - clippingRect.top,
      x: clippingRect.left,
      y: clippingRect.top
    };
  }

  const platform = {
    getClippingRect,
    convertOffsetParentRelativeRectToViewportRelativeRect,
    isElement,
    getDimensions,
    getOffsetParent,
    getDocumentElement,
    getElementRects: _ref => {
      let {
        reference,
        floating,
        strategy
      } = _ref;
      return {
        reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
        floating: { ...getDimensions(floating),
          x: 0,
          y: 0
        }
      };
    },
    getClientRects: element => Array.from(element.getClientRects()),
    isRTL: element => getComputedStyle$1(element).direction === 'rtl'
  };

  /**
   * Automatically updates the position of the floating element when necessary.
   * @see https://floating-ui.com/docs/autoUpdate
   */
  function autoUpdate(reference, floating, update, options) {
    if (options === void 0) {
      options = {};
    }

    const {
      ancestorScroll: _ancestorScroll = true,
      ancestorResize: _ancestorResize = true,
      elementResize = true,
      animationFrame = false
    } = options;
    const ancestorScroll = _ancestorScroll && !animationFrame;
    const ancestorResize = _ancestorResize && !animationFrame;
    const ancestors = ancestorScroll || ancestorResize ? [...(isElement(reference) ? getOverflowAncestors(reference) : []), ...getOverflowAncestors(floating)] : [];
    ancestors.forEach(ancestor => {
      ancestorScroll && ancestor.addEventListener('scroll', update, {
        passive: true
      });
      ancestorResize && ancestor.addEventListener('resize', update);
    });
    let observer = null;

    if (elementResize) {
      let initialUpdate = true;
      observer = new ResizeObserver(() => {
        if (!initialUpdate) {
          update();
        }

        initialUpdate = false;
      });
      isElement(reference) && !animationFrame && observer.observe(reference);
      observer.observe(floating);
    }

    let frameId;
    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;

    if (animationFrame) {
      frameLoop();
    }

    function frameLoop() {
      const nextRefRect = getBoundingClientRect(reference);

      if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
        update();
      }

      prevRefRect = nextRefRect;
      frameId = requestAnimationFrame(frameLoop);
    }

    update();
    return () => {
      var _observer;

      ancestors.forEach(ancestor => {
        ancestorScroll && ancestor.removeEventListener('scroll', update);
        ancestorResize && ancestor.removeEventListener('resize', update);
      });
      (_observer = observer) == null ? void 0 : _observer.disconnect();
      observer = null;

      if (animationFrame) {
        cancelAnimationFrame(frameId);
      }
    };
  }

  /**
   * Computes the `x` and `y` coordinates that will place the floating element
   * next to a reference element when it is given a certain CSS positioning
   * strategy.
   */

  const computePosition = (reference, floating, options) => computePosition$1(reference, floating, {
    platform,
    ...options
  });

  const useTarget = (target, open, gap, mergedMask, scrollIntoViewOptions) => {
    const posInfo = vue.ref(null);
    const getTargetEl = () => {
      let targetEl;
      if (isString$1(target.value)) {
        targetEl = document.querySelector(target.value);
      } else if (isFunction$1(target.value)) {
        targetEl = target.value();
      } else {
        targetEl = target.value;
      }
      return targetEl;
    };
    const updatePosInfo = () => {
      const targetEl = getTargetEl();
      if (!targetEl || !open.value) {
        posInfo.value = null;
        return;
      }
      if (!isInViewPort(targetEl)) {
        targetEl.scrollIntoView(scrollIntoViewOptions.value);
      }
      const { left, top, width, height } = targetEl.getBoundingClientRect();
      posInfo.value = {
        left,
        top,
        width,
        height,
        radius: 0
      };
    };
    vue.onMounted(() => {
      vue.watch([open, target], () => {
        updatePosInfo();
      }, {
        immediate: true
      });
      window.addEventListener("resize", updatePosInfo);
    });
    vue.onBeforeUnmount(() => {
      window.removeEventListener("resize", updatePosInfo);
    });
    const getGapOffset = (index) => {
      var _a;
      return (_a = isArray$1(gap.value.offset) ? gap.value.offset[index] : gap.value.offset) != null ? _a : 6;
    };
    const mergedPosInfo = vue.computed(() => {
      var _a;
      if (!posInfo.value)
        return posInfo.value;
      const gapOffsetX = getGapOffset(0);
      const gapOffsetY = getGapOffset(1);
      const gapRadius = ((_a = gap.value) == null ? void 0 : _a.radius) || 2;
      return {
        left: posInfo.value.left - gapOffsetX,
        top: posInfo.value.top - gapOffsetY,
        width: posInfo.value.width + gapOffsetX * 2,
        height: posInfo.value.height + gapOffsetY * 2,
        radius: gapRadius
      };
    });
    const triggerTarget = vue.computed(() => {
      const targetEl = getTargetEl();
      if (!mergedMask.value || !targetEl || !window.DOMRect) {
        return targetEl || void 0;
      }
      return {
        getBoundingClientRect() {
          var _a, _b, _c, _d;
          return window.DOMRect.fromRect({
            width: ((_a = mergedPosInfo.value) == null ? void 0 : _a.width) || 0,
            height: ((_b = mergedPosInfo.value) == null ? void 0 : _b.height) || 0,
            x: ((_c = mergedPosInfo.value) == null ? void 0 : _c.left) || 0,
            y: ((_d = mergedPosInfo.value) == null ? void 0 : _d.top) || 0
          });
        }
      };
    });
    return {
      mergedPosInfo,
      triggerTarget
    };
  };
  const tourKey = Symbol("ElTour");
  function isInViewPort(element) {
    const viewWidth = window.innerWidth || document.documentElement.clientWidth;
    const viewHeight = window.innerHeight || document.documentElement.clientHeight;
    const { top, right, bottom, left } = element.getBoundingClientRect();
    return top >= 0 && left >= 0 && right <= viewWidth && bottom <= viewHeight;
  }
  const useFloating = (referenceRef, contentRef, arrowRef, placement, strategy, offset$1, zIndex, showArrow) => {
    const x = vue.ref();
    const y = vue.ref();
    const middlewareData = vue.ref({});
    const states = {
      x,
      y,
      placement,
      strategy,
      middlewareData
    };
    const middleware = vue.computed(() => {
      const _middleware = [
        offset(vue.unref(offset$1)),
        flip(),
        shift(),
        overflowMiddleware()
      ];
      if (vue.unref(showArrow) && vue.unref(arrowRef)) {
        _middleware.push(arrow({
          element: vue.unref(arrowRef)
        }));
      }
      return _middleware;
    });
    const update = async () => {
      if (!isClient)
        return;
      const referenceEl = vue.unref(referenceRef);
      const contentEl = vue.unref(contentRef);
      if (!referenceEl || !contentEl)
        return;
      const data = await computePosition(referenceEl, contentEl, {
        placement: vue.unref(placement),
        strategy: vue.unref(strategy),
        middleware: vue.unref(middleware)
      });
      keysOf(states).forEach((key) => {
        states[key].value = data[key];
      });
    };
    const contentStyle = vue.computed(() => {
      if (!vue.unref(referenceRef)) {
        return {
          position: "fixed",
          top: "50%",
          left: "50%",
          transform: "translate3d(-50%, -50%, 0)",
          maxWidth: "100vw",
          zIndex: vue.unref(zIndex)
        };
      }
      const { overflow } = vue.unref(middlewareData);
      return {
        position: vue.unref(strategy),
        zIndex: vue.unref(zIndex),
        top: vue.unref(y) != null ? `${vue.unref(y)}px` : "",
        left: vue.unref(x) != null ? `${vue.unref(x)}px` : "",
        maxWidth: (overflow == null ? void 0 : overflow.maxWidth) ? `${overflow == null ? void 0 : overflow.maxWidth}px` : ""
      };
    });
    const arrowStyle = vue.computed(() => {
      if (!vue.unref(showArrow))
        return {};
      const { arrow: arrow2 } = vue.unref(middlewareData);
      return {
        left: (arrow2 == null ? void 0 : arrow2.x) != null ? `${arrow2 == null ? void 0 : arrow2.x}px` : "",
        top: (arrow2 == null ? void 0 : arrow2.y) != null ? `${arrow2 == null ? void 0 : arrow2.y}px` : ""
      };
    });
    let cleanup;
    vue.onMounted(() => {
      const referenceEl = vue.unref(referenceRef);
      const contentEl = vue.unref(contentRef);
      if (referenceEl && contentEl) {
        cleanup = autoUpdate(referenceEl, contentEl, update);
      }
      vue.watchEffect(() => {
        update();
      });
    });
    vue.onBeforeUnmount(() => {
      cleanup && cleanup();
    });
    return {
      update,
      contentStyle,
      arrowStyle
    };
  };
  const overflowMiddleware = () => {
    return {
      name: "overflow",
      async fn(state) {
        const overflow = await detectOverflow(state);
        let overWidth = 0;
        if (overflow.left > 0)
          overWidth = overflow.left;
        if (overflow.right > 0)
          overWidth = overflow.right;
        const floatingWidth = state.rects.floating.width;
        return {
          data: {
            maxWidth: floatingWidth - overWidth
          }
        };
      }
    };
  };

  const __default__$d = vue.defineComponent({
    name: "ElTourMask",
    inheritAttrs: false
  });
  const _sfc_main$e = /* @__PURE__ */ vue.defineComponent({
    ...__default__$d,
    props: maskProps,
    setup(__props) {
      const props = __props;
      const { ns } = vue.inject(tourKey);
      const radius = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.pos) == null ? void 0 : _a.radius) != null ? _b : 2;
      });
      const roundInfo = vue.computed(() => {
        const v = radius.value;
        const baseInfo = `a${v},${v} 0 0 1`;
        return {
          topRight: `${baseInfo} ${v},${v}`,
          bottomRight: `${baseInfo} ${-v},${v}`,
          bottomLeft: `${baseInfo} ${-v},${-v}`,
          topLeft: `${baseInfo} ${v},${-v}`
        };
      });
      const { width: windowWidth, height: windowHeight } = useWindowSize();
      const path = vue.computed(() => {
        const width = windowWidth.value;
        const height = windowHeight.value;
        const info = roundInfo.value;
        const _path = `M${width},0 L0,0 L0,${height} L${width},${height} L${width},0 Z`;
        const _radius = radius.value;
        return props.pos ? `${_path} M${props.pos.left + _radius},${props.pos.top} h${props.pos.width - _radius * 2} ${info.topRight} v${props.pos.height - _radius * 2} ${info.bottomRight} h${-props.pos.width + _radius * 2} ${info.bottomLeft} v${-props.pos.height + _radius * 2} ${info.topLeft} z` : _path;
      });
      const maskStyle = vue.computed(() => ({
        position: "fixed",
        left: 0,
        right: 0,
        top: 0,
        bottom: 0,
        zIndex: props.zIndex,
        pointerEvents: props.pos && props.targetAreaClickable ? "none" : "auto"
      }));
      const pathStyle = vue.computed(() => ({
        fill: props.fill,
        pointerEvents: "auto",
        cursor: "auto"
      }));
      useLockscreen(vue.toRef(props, "visible"), {
        ns
      });
      return (_ctx, _cache) => {
        return _ctx.visible ? (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
          key: 0,
          class: vue.unref(ns).e("mask"),
          style: vue.unref(maskStyle)
        }, _ctx.$attrs), [
          (vue.openBlock(), vue.createElementBlock("svg", { style: {
            width: "100%",
            height: "100%"
          } }, [
            vue.createElementVNode("path", {
              class: vue.normalizeClass(vue.unref(ns).e("hollow")),
              style: vue.normalizeStyle(vue.unref(pathStyle)),
              d: vue.unref(path)
            }, null, 14, ["d"])
          ]))
        ], 16)) : vue.createCommentVNode("v-if", true);
      };
    }
  });
  var ElTourMask = /* @__PURE__ */ _export_sfc(_sfc_main$e, [["__file", "mask.vue"]]);

  const tourStrategies = ["absolute", "fixed"];
  const tourPlacements = [
    "top-start",
    "top-end",
    "top",
    "bottom-start",
    "bottom-end",
    "bottom",
    "left-start",
    "left-end",
    "left",
    "right-start",
    "right-end",
    "right"
  ];
  const tourContentProps = buildProps({
    placement: {
      type: definePropType(String),
      values: tourPlacements,
      default: "bottom"
    },
    reference: {
      type: definePropType(Object),
      default: null
    },
    strategy: {
      type: definePropType(String),
      values: tourStrategies,
      default: "absolute"
    },
    offset: {
      type: Number,
      default: 10
    },
    showArrow: Boolean,
    zIndex: {
      type: Number,
      default: 2001
    }
  });
  const tourContentEmits = {
    close: () => true
  };

  const __default__$c = vue.defineComponent({
    name: "ElTourContent"
  });
  const _sfc_main$d = /* @__PURE__ */ vue.defineComponent({
    ...__default__$c,
    props: tourContentProps,
    emits: tourContentEmits,
    setup(__props, { emit }) {
      const props = __props;
      const placement = vue.ref(props.placement);
      const strategy = vue.ref(props.strategy);
      const contentRef = vue.ref(null);
      const arrowRef = vue.ref(null);
      vue.watch(() => props.placement, () => {
        placement.value = props.placement;
      });
      const { contentStyle, arrowStyle } = useFloating(vue.toRef(props, "reference"), contentRef, arrowRef, placement, strategy, vue.toRef(props, "offset"), vue.toRef(props, "zIndex"), vue.toRef(props, "showArrow"));
      const side = vue.computed(() => {
        return placement.value.split("-")[0];
      });
      const { ns } = vue.inject(tourKey);
      const onCloseRequested = () => {
        emit("close");
      };
      const onFocusoutPrevented = (event) => {
        if (event.detail.focusReason === "pointer") {
          event.preventDefault();
        }
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "contentRef",
          ref: contentRef,
          style: vue.normalizeStyle(vue.unref(contentStyle)),
          class: vue.normalizeClass(vue.unref(ns).e("content")),
          "data-side": vue.unref(side),
          tabindex: "-1"
        }, [
          vue.createVNode(vue.unref(ElFocusTrap), {
            loop: "",
            trapped: "",
            "focus-start-el": "container",
            "focus-trap-el": contentRef.value || void 0,
            onReleaseRequested: onCloseRequested,
            onFocusoutPrevented
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["focus-trap-el"]),
          _ctx.showArrow ? (vue.openBlock(), vue.createElementBlock("span", {
            key: 0,
            ref_key: "arrowRef",
            ref: arrowRef,
            style: vue.normalizeStyle(vue.unref(arrowStyle)),
            class: vue.normalizeClass(vue.unref(ns).e("arrow"))
          }, null, 6)) : vue.createCommentVNode("v-if", true)
        ], 14, ["data-side"]);
      };
    }
  });
  var ElTourContent = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__file", "content.vue"]]);

  var ElTourSteps = vue.defineComponent({
    name: "ElTourSteps",
    props: {
      current: {
        type: Number,
        default: 0
      }
    },
    emits: ["update-total"],
    setup(props, { slots, emit }) {
      let cacheTotal = 0;
      return () => {
        var _a, _b;
        const children = (_a = slots.default) == null ? void 0 : _a.call(slots);
        const result = [];
        let total = 0;
        function filterSteps(children2) {
          if (!isArray$1(children2))
            return;
          children2.forEach((item) => {
            var _a2;
            const name = (_a2 = (item == null ? void 0 : item.type) || {}) == null ? void 0 : _a2.name;
            if (name === "ElTourStep") {
              result.push(item);
              total += 1;
            }
          });
        }
        if (children.length) {
          filterSteps(flattedChildren((_b = children[0]) == null ? void 0 : _b.children));
        }
        if (cacheTotal !== total) {
          cacheTotal = total;
          emit("update-total", total);
        }
        if (result.length) {
          return result[props.current];
        }
        return null;
      };
    }
  });

  const tourProps = buildProps({
    modelValue: Boolean,
    current: {
      type: Number,
      default: 0
    },
    showArrow: {
      type: Boolean,
      default: true
    },
    showClose: {
      type: Boolean,
      default: true
    },
    closeIcon: {
      type: iconPropType
    },
    placement: tourContentProps.placement,
    contentStyle: {
      type: definePropType([Object])
    },
    mask: {
      type: definePropType([Boolean, Object]),
      default: true
    },
    gap: {
      type: definePropType(Object),
      default: () => ({
        offset: 6,
        radius: 2
      })
    },
    zIndex: {
      type: Number
    },
    scrollIntoViewOptions: {
      type: definePropType([Boolean, Object]),
      default: () => ({
        block: "center"
      })
    },
    type: {
      type: definePropType(String)
    },
    appendTo: {
      type: teleportProps.to.type,
      default: "body"
    },
    closeOnPressEscape: {
      type: Boolean,
      default: true
    },
    targetAreaClickable: {
      type: Boolean,
      default: true
    }
  });
  const tourEmits = {
    [UPDATE_MODEL_EVENT]: (value) => isBoolean(value),
    ["update:current"]: (current) => isNumber(current),
    close: (current) => isNumber(current),
    finish: () => true,
    change: (current) => isNumber(current)
  };

  const __default__$b = vue.defineComponent({
    name: "ElTour"
  });
  const _sfc_main$c = /* @__PURE__ */ vue.defineComponent({
    ...__default__$b,
    props: tourProps,
    emits: tourEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("tour");
      const total = vue.ref(0);
      const currentStep = vue.ref();
      const current = useVModel(props, "current", emit, {
        passive: true
      });
      const currentTarget = vue.computed(() => {
        var _a;
        return (_a = currentStep.value) == null ? void 0 : _a.target;
      });
      const kls = vue.computed(() => [
        ns.b(),
        mergedType.value === "primary" ? ns.m("primary") : ""
      ]);
      const mergedPlacement = vue.computed(() => {
        var _a;
        return ((_a = currentStep.value) == null ? void 0 : _a.placement) || props.placement;
      });
      const mergedContentStyle = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = currentStep.value) == null ? void 0 : _a.contentStyle) != null ? _b : props.contentStyle;
      });
      const mergedMask = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = currentStep.value) == null ? void 0 : _a.mask) != null ? _b : props.mask;
      });
      const mergedShowMask = vue.computed(() => !!mergedMask.value && props.modelValue);
      const mergedMaskStyle = vue.computed(() => isBoolean(mergedMask.value) ? void 0 : mergedMask.value);
      const mergedShowArrow = vue.computed(() => {
        var _a, _b;
        return !!currentTarget.value && ((_b = (_a = currentStep.value) == null ? void 0 : _a.showArrow) != null ? _b : props.showArrow);
      });
      const mergedScrollIntoViewOptions = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = currentStep.value) == null ? void 0 : _a.scrollIntoViewOptions) != null ? _b : props.scrollIntoViewOptions;
      });
      const mergedType = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = currentStep.value) == null ? void 0 : _a.type) != null ? _b : props.type;
      });
      const { nextZIndex } = useZIndex();
      const nowZIndex = nextZIndex();
      const mergedZIndex = vue.computed(() => {
        var _a;
        return (_a = props.zIndex) != null ? _a : nowZIndex;
      });
      const { mergedPosInfo: pos, triggerTarget } = useTarget(currentTarget, vue.toRef(props, "modelValue"), vue.toRef(props, "gap"), mergedMask, mergedScrollIntoViewOptions);
      vue.watch(() => props.modelValue, (val) => {
        if (!val) {
          current.value = 0;
        }
      });
      const onEscClose = () => {
        if (props.closeOnPressEscape) {
          emit(UPDATE_MODEL_EVENT, false);
          emit("close", current.value);
        }
      };
      const onUpdateTotal = (val) => {
        total.value = val;
      };
      const slots = vue.useSlots();
      vue.provide(tourKey, {
        currentStep,
        current,
        total,
        showClose: vue.toRef(props, "showClose"),
        closeIcon: vue.toRef(props, "closeIcon"),
        mergedType,
        ns,
        slots,
        updateModelValue(modelValue) {
          emit(UPDATE_MODEL_EVENT, modelValue);
        },
        onClose() {
          emit("close", current.value);
        },
        onFinish() {
          emit("finish");
        },
        onChange() {
          emit(CHANGE_EVENT, current.value);
        }
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
          vue.createVNode(vue.unref(ElTeleport$1), { to: _ctx.appendTo }, {
            default: vue.withCtx(() => {
              var _a, _b;
              return [
                vue.createElementVNode("div", vue.mergeProps({ class: vue.unref(kls) }, _ctx.$attrs), [
                  vue.createVNode(ElTourMask, {
                    visible: vue.unref(mergedShowMask),
                    fill: (_a = vue.unref(mergedMaskStyle)) == null ? void 0 : _a.color,
                    style: vue.normalizeStyle((_b = vue.unref(mergedMaskStyle)) == null ? void 0 : _b.style),
                    pos: vue.unref(pos),
                    "z-index": vue.unref(mergedZIndex),
                    "target-area-clickable": _ctx.targetAreaClickable
                  }, null, 8, ["visible", "fill", "style", "pos", "z-index", "target-area-clickable"]),
                  _ctx.modelValue ? (vue.openBlock(), vue.createBlock(ElTourContent, {
                    key: vue.unref(current),
                    reference: vue.unref(triggerTarget),
                    placement: vue.unref(mergedPlacement),
                    "show-arrow": vue.unref(mergedShowArrow),
                    "z-index": vue.unref(mergedZIndex),
                    style: vue.normalizeStyle(vue.unref(mergedContentStyle)),
                    onClose: onEscClose
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(ElTourSteps), {
                        current: vue.unref(current),
                        onUpdateTotal
                      }, {
                        default: vue.withCtx(() => [
                          vue.renderSlot(_ctx.$slots, "default")
                        ]),
                        _: 3
                      }, 8, ["current"])
                    ]),
                    _: 3
                  }, 8, ["reference", "placement", "show-arrow", "z-index", "style"])) : vue.createCommentVNode("v-if", true)
                ], 16)
              ];
            }),
            _: 3
          }, 8, ["to"]),
          vue.createCommentVNode(" just for IDE "),
          vue.createCommentVNode("v-if", true)
        ], 64);
      };
    }
  });
  var Tour = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__file", "tour.vue"]]);

  const tourStepProps = buildProps({
    target: {
      type: definePropType([String, Object, Function])
    },
    title: String,
    description: String,
    showClose: {
      type: Boolean,
      default: void 0
    },
    closeIcon: {
      type: iconPropType
    },
    showArrow: {
      type: Boolean,
      default: void 0
    },
    placement: tourContentProps.placement,
    mask: {
      type: definePropType([Boolean, Object]),
      default: void 0
    },
    contentStyle: {
      type: definePropType([Object])
    },
    prevButtonProps: {
      type: definePropType(Object)
    },
    nextButtonProps: {
      type: definePropType(Object)
    },
    scrollIntoViewOptions: {
      type: definePropType([Boolean, Object]),
      default: void 0
    },
    type: {
      type: definePropType(String)
    }
  });
  const tourStepEmits = {
    close: () => true
  };

  const __default__$a = vue.defineComponent({
    name: "ElTourStep"
  });
  const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
    ...__default__$a,
    props: tourStepProps,
    emits: tourStepEmits,
    setup(__props, { emit }) {
      const props = __props;
      const { Close } = CloseComponents;
      const { t } = useLocale();
      const {
        currentStep,
        current,
        total,
        showClose,
        closeIcon,
        mergedType,
        ns,
        slots: tourSlots,
        updateModelValue,
        onClose: tourOnClose,
        onFinish: tourOnFinish,
        onChange
      } = vue.inject(tourKey);
      vue.watch(props, (val) => {
        currentStep.value = val;
      }, {
        immediate: true
      });
      const mergedShowClose = vue.computed(() => {
        var _a;
        return (_a = props.showClose) != null ? _a : showClose.value;
      });
      const mergedCloseIcon = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = props.closeIcon) != null ? _a : closeIcon.value) != null ? _b : Close;
      });
      const filterButtonProps = (btnProps) => {
        if (!btnProps)
          return;
        return omit(btnProps, ["children", "onClick"]);
      };
      const onPrev = () => {
        var _a, _b;
        current.value -= 1;
        if ((_a = props.prevButtonProps) == null ? void 0 : _a.onClick) {
          (_b = props.prevButtonProps) == null ? void 0 : _b.onClick();
        }
        onChange();
      };
      const onNext = () => {
        var _a;
        if (current.value >= total.value - 1) {
          onFinish();
        } else {
          current.value += 1;
        }
        if ((_a = props.nextButtonProps) == null ? void 0 : _a.onClick) {
          props.nextButtonProps.onClick();
        }
        onChange();
      };
      const onFinish = () => {
        onClose();
        tourOnFinish();
      };
      const onClose = () => {
        updateModelValue(false);
        tourOnClose();
        emit("close");
      };
      const handleKeydown = (e) => {
        const target = e.target;
        if (target == null ? void 0 : target.isContentEditable)
          return;
        const code = getEventCode(e);
        switch (code) {
          case EVENT_CODE.left:
            e.preventDefault();
            current.value > 0 && onPrev();
            break;
          case EVENT_CODE.right:
            e.preventDefault();
            onNext();
            break;
        }
      };
      vue.onMounted(() => {
        window.addEventListener("keydown", handleKeydown);
      });
      vue.onBeforeUnmount(() => {
        window.removeEventListener("keydown", handleKeydown);
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
          vue.unref(mergedShowClose) ? (vue.openBlock(), vue.createElementBlock("button", {
            key: 0,
            "aria-label": vue.unref(t)("el.tour.close"),
            class: vue.normalizeClass(vue.unref(ns).e("closebtn")),
            type: "button",
            onClick: onClose
          }, [
            vue.createVNode(vue.unref(ElIcon), {
              class: vue.normalizeClass(vue.unref(ns).e("close"))
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(mergedCloseIcon))))
              ]),
              _: 1
            }, 8, ["class"])
          ], 10, ["aria-label"])) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("header", {
            class: vue.normalizeClass([vue.unref(ns).e("header"), { "show-close": vue.unref(showClose) }])
          }, [
            vue.renderSlot(_ctx.$slots, "header", {}, () => [
              vue.createElementVNode("span", {
                role: "heading",
                class: vue.normalizeClass(vue.unref(ns).e("title"))
              }, vue.toDisplayString(_ctx.title), 3)
            ])
          ], 2),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("body"))
          }, [
            vue.renderSlot(_ctx.$slots, "default", {}, () => [
              vue.createElementVNode("span", null, vue.toDisplayString(_ctx.description), 1)
            ])
          ], 2),
          vue.createElementVNode("footer", {
            class: vue.normalizeClass(vue.unref(ns).e("footer"))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).b("indicators"))
            }, [
              vue.unref(tourSlots).indicators ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(tourSlots).indicators), {
                key: 0,
                current: vue.unref(current),
                total: vue.unref(total)
              }, null, 8, ["current", "total"])) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(vue.unref(total), (item, index) => {
                return vue.openBlock(), vue.createElementBlock("span", {
                  key: item,
                  class: vue.normalizeClass([vue.unref(ns).b("indicator"), vue.unref(ns).is("active", index === vue.unref(current))])
                }, null, 2);
              }), 128))
            ], 2),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).b("buttons"))
            }, [
              vue.unref(current) > 0 ? (vue.openBlock(), vue.createBlock(vue.unref(ElButton), vue.mergeProps({
                key: 0,
                size: "small",
                type: vue.unref(mergedType)
              }, filterButtonProps(_ctx.prevButtonProps), { onClick: onPrev }), {
                default: vue.withCtx(() => {
                  var _a, _b;
                  return [
                    vue.createTextVNode(vue.toDisplayString((_b = (_a = _ctx.prevButtonProps) == null ? void 0 : _a.children) != null ? _b : vue.unref(t)("el.tour.previous")), 1)
                  ];
                }),
                _: 1
              }, 16, ["type"])) : vue.createCommentVNode("v-if", true),
              vue.unref(current) <= vue.unref(total) - 1 ? (vue.openBlock(), vue.createBlock(vue.unref(ElButton), vue.mergeProps({
                key: 1,
                size: "small",
                type: vue.unref(mergedType) === "primary" ? "default" : "primary"
              }, filterButtonProps(_ctx.nextButtonProps), { onClick: onNext }), {
                default: vue.withCtx(() => {
                  var _a, _b;
                  return [
                    vue.createTextVNode(vue.toDisplayString((_b = (_a = _ctx.nextButtonProps) == null ? void 0 : _a.children) != null ? _b : vue.unref(current) === vue.unref(total) - 1 ? vue.unref(t)("el.tour.finish") : vue.unref(t)("el.tour.next")), 1)
                  ];
                }),
                _: 1
              }, 16, ["type"])) : vue.createCommentVNode("v-if", true)
            ], 2)
          ], 2)
        ], 64);
      };
    }
  });
  var TourStep = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__file", "step.vue"]]);

  const ElTour = withInstall(Tour, {
    TourStep
  });
  const ElTourStep = withNoopInstall(TourStep);

  const anchorProps = buildProps({
    container: {
      type: definePropType([
        String,
        Object
      ])
    },
    offset: {
      type: Number,
      default: 0
    },
    bound: {
      type: Number,
      default: 15
    },
    duration: {
      type: Number,
      default: 300
    },
    marker: {
      type: Boolean,
      default: true
    },
    type: {
      type: definePropType(String),
      default: "default"
    },
    direction: {
      type: definePropType(String),
      default: "vertical"
    },
    selectScrollTop: Boolean
  });
  const anchorEmits = {
    change: (href) => isString$1(href),
    click: (e, href) => e instanceof MouseEvent && (isString$1(href) || isUndefined(href))
  };

  const anchorKey = Symbol("anchor");

  const __default__$9 = vue.defineComponent({
    name: "ElAnchor"
  });
  const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
    ...__default__$9,
    props: anchorProps,
    emits: anchorEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const slots = vue.useSlots();
      const currentAnchor = vue.ref("");
      const markerStyle = vue.ref({});
      const anchorRef = vue.ref(null);
      const markerRef = vue.ref(null);
      const containerEl = vue.ref();
      const links = {};
      let isScrolling = false;
      let currentScrollTop = 0;
      const ns = useNamespace("anchor");
      const cls = vue.computed(() => [
        ns.b(),
        props.type === "underline" ? ns.m("underline") : "",
        ns.m(props.direction)
      ]);
      const addLink = (state) => {
        links[state.href] = state.el;
      };
      const removeLink = (href) => {
        delete links[href];
      };
      const setCurrentAnchor = (href) => {
        const activeHref = currentAnchor.value;
        if (activeHref !== href) {
          currentAnchor.value = href;
          emit(CHANGE_EVENT, href);
        }
      };
      let clearAnimate = null;
      const scrollToAnchor = (href) => {
        if (!containerEl.value)
          return;
        const target = getElement(href);
        if (!target)
          return;
        if (clearAnimate)
          clearAnimate();
        isScrolling = true;
        const scrollEle = getScrollElement(target, containerEl.value);
        const distance = getOffsetTopDistance(target, scrollEle);
        const max = scrollEle.scrollHeight - scrollEle.clientHeight;
        const to = Math.min(distance - props.offset, max);
        clearAnimate = animateScrollTo(containerEl.value, currentScrollTop, to, props.duration, () => {
          setTimeout(() => {
            isScrolling = false;
          }, 20);
        });
      };
      const scrollTo = (href) => {
        if (href) {
          setCurrentAnchor(href);
          scrollToAnchor(href);
        }
      };
      const handleClick = (e, href) => {
        emit("click", e, href);
        scrollTo(href);
      };
      const handleScroll = throttleByRaf(() => {
        if (containerEl.value) {
          currentScrollTop = getScrollTop(containerEl.value);
        }
        const currentHref = getCurrentHref();
        if (isScrolling || isUndefined(currentHref))
          return;
        setCurrentAnchor(currentHref);
      });
      const getCurrentHref = () => {
        if (!containerEl.value)
          return;
        const scrollTop = getScrollTop(containerEl.value);
        const anchorTopList = [];
        for (const href of Object.keys(links)) {
          const target = getElement(href);
          if (!target)
            continue;
          const scrollEle = getScrollElement(target, containerEl.value);
          const distance = getOffsetTopDistance(target, scrollEle);
          anchorTopList.push({
            top: distance - props.offset - props.bound,
            href
          });
        }
        anchorTopList.sort((prev, next) => prev.top - next.top);
        for (let i = 0; i < anchorTopList.length; i++) {
          const item = anchorTopList[i];
          const next = anchorTopList[i + 1];
          if (i === 0 && scrollTop === 0) {
            return props.selectScrollTop ? item.href : "";
          }
          if (item.top <= scrollTop && (!next || next.top > scrollTop)) {
            return item.href;
          }
        }
      };
      const getContainer = () => {
        const el = getElement(props.container);
        if (!el || isWindow$1(el)) {
          containerEl.value = window;
        } else {
          containerEl.value = el;
        }
      };
      useEventListener(containerEl, "scroll", handleScroll);
      const updateMarkerStyle = () => {
        vue.nextTick(() => {
          if (!anchorRef.value || !markerRef.value || !currentAnchor.value) {
            markerStyle.value = {};
            return;
          }
          const currentLinkEl = links[currentAnchor.value];
          if (!currentLinkEl) {
            markerStyle.value = {};
            return;
          }
          const anchorRect = anchorRef.value.getBoundingClientRect();
          const markerRect = markerRef.value.getBoundingClientRect();
          const linkRect = currentLinkEl.getBoundingClientRect();
          if (props.direction === "horizontal") {
            const left = linkRect.left - anchorRect.left;
            markerStyle.value = {
              left: `${left}px`,
              width: `${linkRect.width}px`,
              opacity: 1
            };
          } else {
            const top = linkRect.top - anchorRect.top + (linkRect.height - markerRect.height) / 2;
            markerStyle.value = {
              top: `${top}px`,
              opacity: 1
            };
          }
        });
      };
      vue.watch(currentAnchor, updateMarkerStyle);
      vue.watch(() => {
        var _a;
        return (_a = slots.default) == null ? void 0 : _a.call(slots);
      }, updateMarkerStyle);
      vue.onMounted(() => {
        getContainer();
        const hash = decodeURIComponent(window.location.hash);
        const target = getElement(hash);
        if (target) {
          scrollTo(hash);
        } else {
          handleScroll();
        }
      });
      vue.watch(() => props.container, () => {
        getContainer();
      });
      vue.provide(anchorKey, {
        ns,
        direction: props.direction,
        currentAnchor,
        addLink,
        removeLink,
        handleClick
      });
      expose({
        scrollTo
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "anchorRef",
          ref: anchorRef,
          class: vue.normalizeClass(vue.unref(cls))
        }, [
          _ctx.marker ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            ref_key: "markerRef",
            ref: markerRef,
            class: vue.normalizeClass(vue.unref(ns).e("marker")),
            style: vue.normalizeStyle(markerStyle.value)
          }, null, 6)) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("list"))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2)
        ], 2);
      };
    }
  });
  var Anchor = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__file", "anchor.vue"]]);

  const anchorLinkProps = buildProps({
    title: String,
    href: String
  });

  const __default__$8 = vue.defineComponent({
    name: "ElAnchorLink"
  });
  const _sfc_main$9 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$8,
    props: anchorLinkProps,
    setup(__props) {
      const props = __props;
      const linkRef = vue.ref(null);
      const {
        ns,
        direction,
        currentAnchor,
        addLink,
        removeLink,
        handleClick: contextHandleClick
      } = vue.inject(anchorKey);
      const cls = vue.computed(() => [
        ns.e("link"),
        ns.is("active", currentAnchor.value === props.href)
      ]);
      const handleClick = (e) => {
        contextHandleClick(e, props.href);
      };
      vue.watch(() => props.href, (val, oldVal) => {
        vue.nextTick(() => {
          if (oldVal)
            removeLink(oldVal);
          if (val) {
            addLink({
              href: val,
              el: linkRef.value
            });
          }
        });
      });
      vue.onMounted(() => {
        const { href } = props;
        if (href) {
          addLink({
            href,
            el: linkRef.value
          });
        }
      });
      vue.onBeforeUnmount(() => {
        const { href } = props;
        if (href) {
          removeLink(href);
        }
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass(vue.unref(ns).e("item"))
        }, [
          vue.createElementVNode("a", {
            ref_key: "linkRef",
            ref: linkRef,
            class: vue.normalizeClass(vue.unref(cls)),
            href: _ctx.href,
            onClick: handleClick
          }, [
            vue.renderSlot(_ctx.$slots, "default", {}, () => [
              vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
            ])
          ], 10, ["href"]),
          _ctx.$slots["sub-link"] && vue.unref(direction) === "vertical" ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).e("list"))
          }, [
            vue.renderSlot(_ctx.$slots, "sub-link")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var AnchorLink = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__file", "anchor-link.vue"]]);

  const ElAnchor = withInstall(Anchor, {
    AnchorLink
  });
  const ElAnchorLink = withNoopInstall(AnchorLink);

  const defaultProps = {
    label: "label",
    value: "value",
    disabled: "disabled"
  };
  const segmentedProps = buildProps({
    direction: {
      type: definePropType(String),
      default: "horizontal"
    },
    options: {
      type: definePropType(Array),
      default: () => []
    },
    modelValue: {
      type: [String, Number, Boolean],
      default: void 0
    },
    props: {
      type: definePropType(Object),
      default: () => defaultProps
    },
    block: Boolean,
    size: useSizeProp,
    disabled: Boolean,
    validateEvent: {
      type: Boolean,
      default: true
    },
    id: String,
    name: String,
    ...useAriaProps(["ariaLabel"])
  });
  const segmentedEmits = {
    [UPDATE_MODEL_EVENT]: (val) => isString$1(val) || isNumber(val) || isBoolean(val),
    [CHANGE_EVENT]: (val) => isString$1(val) || isNumber(val) || isBoolean(val)
  };

  const __default__$7 = vue.defineComponent({
    name: "ElSegmented"
  });
  const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$7,
    props: segmentedProps,
    emits: segmentedEmits,
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("segmented");
      const segmentedId = useId();
      const segmentedSize = useFormSize();
      const _disabled = useFormDisabled();
      const { formItem } = useFormItem();
      const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
        formItemContext: formItem
      });
      const segmentedRef = vue.ref(null);
      const activeElement = useActiveElement();
      const state = vue.reactive({
        isInit: false,
        width: 0,
        height: 0,
        translateX: 0,
        translateY: 0,
        focusVisible: false
      });
      const handleChange = (item) => {
        const value = getValue(item);
        emit(UPDATE_MODEL_EVENT, value);
        emit(CHANGE_EVENT, value);
      };
      const aliasProps = vue.computed(() => ({ ...defaultProps, ...props.props }));
      const intoAny = (item) => item;
      const getValue = (item) => {
        return isObject$1(item) ? item[aliasProps.value.value] : item;
      };
      const getLabel = (item) => {
        return isObject$1(item) ? item[aliasProps.value.label] : item;
      };
      const getDisabled = (item) => {
        return !!(_disabled.value || (isObject$1(item) ? item[aliasProps.value.disabled] : false));
      };
      const getSelected = (item) => {
        return props.modelValue === getValue(item);
      };
      const getOption = (value) => {
        return props.options.find((item) => getValue(item) === value);
      };
      const getItemCls = (item) => {
        return [
          ns.e("item"),
          ns.is("selected", getSelected(item)),
          ns.is("disabled", getDisabled(item))
        ];
      };
      const updateSelect = () => {
        if (!segmentedRef.value)
          return;
        const selectedItem = segmentedRef.value.querySelector(".is-selected");
        const selectedItemInput = segmentedRef.value.querySelector(".is-selected input");
        if (!selectedItem || !selectedItemInput) {
          state.width = 0;
          state.height = 0;
          state.translateX = 0;
          state.translateY = 0;
          state.focusVisible = false;
          return;
        }
        state.isInit = true;
        if (props.direction === "vertical") {
          state.height = selectedItem.offsetHeight;
          state.translateY = selectedItem.offsetTop;
        } else {
          state.width = selectedItem.offsetWidth;
          state.translateX = selectedItem.offsetLeft;
        }
        try {
          state.focusVisible = selectedItemInput.matches(":focus-visible");
        } catch (e) {
        }
      };
      const segmentedCls = vue.computed(() => [
        ns.b(),
        ns.m(segmentedSize.value),
        ns.is("block", props.block)
      ]);
      const selectedStyle = vue.computed(() => ({
        width: props.direction === "vertical" ? "100%" : `${state.width}px`,
        height: props.direction === "vertical" ? `${state.height}px` : "100%",
        transform: props.direction === "vertical" ? `translateY(${state.translateY}px)` : `translateX(${state.translateX}px)`,
        display: state.isInit ? "block" : "none"
      }));
      const selectedCls = vue.computed(() => [
        ns.e("item-selected"),
        ns.is("disabled", getDisabled(getOption(props.modelValue))),
        ns.is("focus-visible", state.focusVisible)
      ]);
      const name = vue.computed(() => {
        return props.name || segmentedId.value;
      });
      useResizeObserver(segmentedRef, updateSelect);
      vue.watch(activeElement, updateSelect);
      vue.watch(() => props.modelValue, () => {
        var _a;
        updateSelect();
        if (props.validateEvent) {
          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
        }
      }, {
        flush: "post"
      });
      return (_ctx, _cache) => {
        return _ctx.options.length ? (vue.openBlock(), vue.createElementBlock("div", {
          key: 0,
          id: vue.unref(inputId),
          ref_key: "segmentedRef",
          ref: segmentedRef,
          class: vue.normalizeClass(vue.unref(segmentedCls)),
          role: "radiogroup",
          "aria-label": !vue.unref(isLabeledByFormItem) ? _ctx.ariaLabel || "segmented" : void 0,
          "aria-labelledby": vue.unref(isLabeledByFormItem) ? vue.unref(formItem).labelId : void 0
        }, [
          vue.createElementVNode("div", {
            class: vue.normalizeClass([vue.unref(ns).e("group"), vue.unref(ns).m(_ctx.direction)])
          }, [
            vue.createElementVNode("div", {
              style: vue.normalizeStyle(vue.unref(selectedStyle)),
              class: vue.normalizeClass(vue.unref(selectedCls))
            }, null, 6),
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.options, (item, index) => {
              return vue.openBlock(), vue.createElementBlock("label", {
                key: index,
                class: vue.normalizeClass(getItemCls(item))
              }, [
                vue.createElementVNode("input", {
                  class: vue.normalizeClass(vue.unref(ns).e("item-input")),
                  type: "radio",
                  name: vue.unref(name),
                  disabled: getDisabled(item),
                  checked: getSelected(item),
                  onChange: ($event) => handleChange(item)
                }, null, 42, ["name", "disabled", "checked", "onChange"]),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("item-label"))
                }, [
                  vue.renderSlot(_ctx.$slots, "default", {
                    item: intoAny(item)
                  }, () => [
                    vue.createTextVNode(vue.toDisplayString(getLabel(item)), 1)
                  ])
                ], 2)
              ], 2);
            }), 128))
          ], 2)
        ], 10, ["id", "aria-label", "aria-labelledby"])) : vue.createCommentVNode("v-if", true);
      };
    }
  });
  var Segmented = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__file", "segmented.vue"]]);

  const ElSegmented = withInstall(Segmented);

  const filterOption = (pattern, option) => {
    const lowerCase = pattern.toLowerCase();
    const label = option.label || option.value || "";
    return label.toLowerCase().includes(lowerCase);
  };
  const getMentionCtx = (inputEl, prefix, split) => {
    const { selectionEnd } = inputEl;
    if (selectionEnd === null)
      return;
    const inputValue = inputEl.value;
    const prefixArray = castArray$1(prefix);
    let splitIndex = -1;
    let mentionCtx;
    for (let i = selectionEnd - 1; i >= 0; --i) {
      const char = inputValue[i];
      if (char === split || char === "\n" || char === "\r") {
        splitIndex = i;
        continue;
      }
      if (prefixArray.includes(char)) {
        const end = splitIndex === -1 ? selectionEnd : splitIndex;
        const pattern = inputValue.slice(i + 1, end);
        mentionCtx = {
          pattern,
          start: i + 1,
          end,
          prefix: char,
          prefixIndex: i,
          splitIndex,
          selectionEnd
        };
        break;
      }
    }
    return mentionCtx;
  };
  const getCursorPosition = (element, options = {
    debug: false,
    useSelectionEnd: false
  }) => {
    const selectionStart = element.selectionStart !== null ? element.selectionStart : 0;
    const selectionEnd = element.selectionEnd !== null ? element.selectionEnd : 0;
    const position = options.useSelectionEnd ? selectionEnd : selectionStart;
    const properties = [
      "direction",
      "boxSizing",
      "width",
      "height",
      "overflowX",
      "overflowY",
      "borderTopWidth",
      "borderRightWidth",
      "borderBottomWidth",
      "borderLeftWidth",
      "borderStyle",
      "paddingTop",
      "paddingRight",
      "paddingBottom",
      "paddingLeft",
      "fontStyle",
      "fontVariant",
      "fontWeight",
      "fontStretch",
      "fontSize",
      "fontSizeAdjust",
      "lineHeight",
      "fontFamily",
      "textAlign",
      "textTransform",
      "textIndent",
      "textDecoration",
      "letterSpacing",
      "wordSpacing",
      "tabSize",
      "MozTabSize"
    ];
    if (options.debug) {
      const el = document.querySelector("#input-textarea-caret-position-mirror-div");
      if (el == null ? void 0 : el.parentNode)
        el.parentNode.removeChild(el);
    }
    const div = document.createElement("div");
    div.id = "input-textarea-caret-position-mirror-div";
    document.body.appendChild(div);
    const style = div.style;
    const computed = window.getComputedStyle(element);
    const isInput = element.nodeName === "INPUT";
    style.whiteSpace = isInput ? "nowrap" : "pre-wrap";
    if (!isInput)
      style.wordWrap = "break-word";
    style.position = "absolute";
    if (!options.debug)
      style.visibility = "hidden";
    properties.forEach((prop) => {
      if (isInput && prop === "lineHeight") {
        if (computed.boxSizing === "border-box") {
          const height = Number.parseInt(computed.height);
          const outerHeight = Number.parseInt(computed.paddingTop) + Number.parseInt(computed.paddingBottom) + Number.parseInt(computed.borderTopWidth) + Number.parseInt(computed.borderBottomWidth);
          const targetHeight = outerHeight + Number.parseInt(computed.lineHeight);
          if (height > targetHeight) {
            style.lineHeight = `${height - outerHeight}px`;
          } else if (height === targetHeight) {
            style.lineHeight = computed.lineHeight;
          } else {
            style.lineHeight = "0";
          }
        } else {
          style.lineHeight = computed.height;
        }
      } else {
        style[prop] = computed[prop];
      }
    });
    if (isFirefox()) {
      if (element.scrollHeight > Number.parseInt(computed.height)) {
        style.overflowY = "scroll";
      }
    } else {
      style.overflow = "hidden";
    }
    div.textContent = element.value.slice(0, Math.max(0, position));
    if (isInput && div.textContent) {
      div.textContent = div.textContent.replace(/\s/g, "\xA0");
    }
    const span = document.createElement("span");
    span.textContent = element.value.slice(Math.max(0, position)) || ".";
    span.style.position = "relative";
    span.style.left = `${-element.scrollLeft}px`;
    span.style.top = `${-element.scrollTop}px`;
    div.appendChild(span);
    const relativePosition = {
      top: span.offsetTop + Number.parseInt(computed.borderTopWidth),
      left: span.offsetLeft + Number.parseInt(computed.borderLeftWidth),
      height: Number.parseInt(computed.fontSize) * 1.5
    };
    if (options.debug) {
      span.style.backgroundColor = "#aaa";
    } else {
      document.body.removeChild(div);
    }
    if (relativePosition.left >= element.clientWidth) {
      relativePosition.left = element.clientWidth;
    }
    return relativePosition;
  };

  const mentionProps = buildProps({
    ...inputProps,
    options: {
      type: definePropType(Array),
      default: () => []
    },
    prefix: {
      type: definePropType([String, Array]),
      default: "@",
      validator: (val) => {
        if (isString$1(val))
          return val.length === 1;
        return val.every((v) => isString$1(v) && v.length === 1);
      }
    },
    split: {
      type: String,
      default: " ",
      validator: (val) => val.length === 1
    },
    filterOption: {
      type: definePropType([Boolean, Function]),
      default: () => filterOption,
      validator: (val) => {
        if (val === false)
          return true;
        return isFunction$1(val);
      }
    },
    placement: {
      type: definePropType(String),
      default: "bottom"
    },
    showArrow: Boolean,
    offset: {
      type: Number,
      default: 0
    },
    whole: Boolean,
    checkIsWhole: {
      type: definePropType(Function)
    },
    modelValue: String,
    loading: Boolean,
    popperClass: useTooltipContentProps.popperClass,
    popperStyle: useTooltipContentProps.popperStyle,
    popperOptions: {
      type: definePropType(Object),
      default: () => ({})
    },
    props: {
      type: definePropType(Object),
      default: () => mentionDefaultProps
    }
  });
  const mentionEmits = {
    [UPDATE_MODEL_EVENT]: (value) => isString$1(value),
    "whole-remove": (pattern, prefix) => isString$1(pattern) && isString$1(prefix),
    input: (value) => isString$1(value),
    search: (pattern, prefix) => isString$1(pattern) && isString$1(prefix),
    select: (option, prefix) => isObject$1(option) && isString$1(prefix),
    focus: (evt) => evt instanceof FocusEvent,
    blur: (evt) => evt instanceof FocusEvent
  };
  const mentionDefaultProps = {
    value: "value",
    label: "label",
    disabled: "disabled"
  };

  const mentionDropdownProps = buildProps({
    options: {
      type: definePropType(Array),
      default: () => []
    },
    loading: Boolean,
    disabled: Boolean,
    contentId: String,
    ariaLabel: String
  });
  const mentionDropdownEmits = {
    select: (option) => isString$1(option.value)
  };

  const __default__$6 = vue.defineComponent({
    name: "ElMentionDropdown"
  });
  const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$6,
    props: mentionDropdownProps,
    emits: mentionDropdownEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const ns = useNamespace("mention");
      const { t } = useLocale();
      const hoveringIndex = vue.ref(-1);
      const scrollbarRef = vue.ref();
      const optionRefs = vue.ref();
      const dropdownRef = vue.ref();
      const optionkls = (item, index) => [
        ns.be("dropdown", "item"),
        ns.is("hovering", hoveringIndex.value === index),
        ns.is("disabled", item.disabled || props.disabled)
      ];
      const handleSelect = (item) => {
        if (item.disabled || props.disabled)
          return;
        emit("select", item);
      };
      const handleMouseEnter = (index) => {
        hoveringIndex.value = index;
      };
      const filteredAllDisabled = vue.computed(() => props.disabled || props.options.every((item) => item.disabled));
      const hoverOption = vue.computed(() => props.options[hoveringIndex.value]);
      const selectHoverOption = () => {
        if (!hoverOption.value)
          return;
        emit("select", hoverOption.value);
      };
      const navigateOptions = (direction) => {
        const { options } = props;
        if (options.length === 0 || filteredAllDisabled.value)
          return;
        if (direction === "next") {
          hoveringIndex.value++;
          if (hoveringIndex.value === options.length) {
            hoveringIndex.value = 0;
          }
        } else if (direction === "prev") {
          hoveringIndex.value--;
          if (hoveringIndex.value < 0) {
            hoveringIndex.value = options.length - 1;
          }
        }
        const option = options[hoveringIndex.value];
        if (option.disabled) {
          navigateOptions(direction);
          return;
        }
        vue.nextTick(() => scrollToOption(option));
      };
      const scrollToOption = (option) => {
        var _a, _b, _c, _d;
        const { options } = props;
        const index = options.findIndex((item) => item.value === option.value);
        const target = (_a = optionRefs.value) == null ? void 0 : _a[index];
        if (target) {
          const menu = (_c = (_b = dropdownRef.value) == null ? void 0 : _b.querySelector) == null ? void 0 : _c.call(_b, `.${ns.be("dropdown", "wrap")}`);
          if (menu) {
            scrollIntoView(menu, target);
          }
        }
        (_d = scrollbarRef.value) == null ? void 0 : _d.handleScroll();
      };
      const resetHoveringIndex = () => {
        if (filteredAllDisabled.value || props.options.length === 0) {
          hoveringIndex.value = -1;
        } else {
          hoveringIndex.value = 0;
        }
      };
      vue.watch(() => props.options, resetHoveringIndex, {
        immediate: true
      });
      expose({
        hoveringIndex,
        navigateOptions,
        selectHoverOption,
        hoverOption
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "dropdownRef",
          ref: dropdownRef,
          class: vue.normalizeClass(vue.unref(ns).b("dropdown"))
        }, [
          _ctx.$slots.header ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass(vue.unref(ns).be("dropdown", "header"))
          }, [
            vue.renderSlot(_ctx.$slots, "header")
          ], 2)) : vue.createCommentVNode("v-if", true),
          vue.withDirectives(vue.createVNode(vue.unref(ElScrollbar), {
            id: _ctx.contentId,
            ref_key: "scrollbarRef",
            ref: scrollbarRef,
            tag: "ul",
            "wrap-class": vue.unref(ns).be("dropdown", "wrap"),
            "view-class": vue.unref(ns).be("dropdown", "list"),
            role: "listbox",
            "aria-label": _ctx.ariaLabel,
            "aria-orientation": "vertical"
          }, {
            default: vue.withCtx(() => [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.options, (item, index) => {
                return vue.openBlock(), vue.createElementBlock("li", {
                  id: `${_ctx.contentId}-${index}`,
                  ref_for: true,
                  ref_key: "optionRefs",
                  ref: optionRefs,
                  key: index,
                  class: vue.normalizeClass(optionkls(item, index)),
                  role: "option",
                  "aria-disabled": item.disabled || _ctx.disabled || void 0,
                  "aria-selected": hoveringIndex.value === index,
                  onMousemove: ($event) => handleMouseEnter(index),
                  onClick: vue.withModifiers(($event) => handleSelect(item), ["stop"])
                }, [
                  vue.renderSlot(_ctx.$slots, "label", {
                    item,
                    index
                  }, () => {
                    var _a;
                    return [
                      vue.createElementVNode("span", null, vue.toDisplayString((_a = item.label) != null ? _a : item.value), 1)
                    ];
                  })
                ], 42, ["id", "aria-disabled", "aria-selected", "onMousemove", "onClick"]);
              }), 128))
            ]),
            _: 3
          }, 8, ["id", "wrap-class", "view-class", "aria-label"]), [
            [vue.vShow, _ctx.options.length > 0 && !_ctx.loading]
          ]),
          _ctx.loading ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).be("dropdown", "loading"))
          }, [
            vue.renderSlot(_ctx.$slots, "loading", {}, () => [
              vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.mention.loading")), 1)
            ])
          ], 2)) : vue.createCommentVNode("v-if", true),
          _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 2,
            class: vue.normalizeClass(vue.unref(ns).be("dropdown", "footer"))
          }, [
            vue.renderSlot(_ctx.$slots, "footer")
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 2);
      };
    }
  });
  var ElMentionDropdown = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__file", "mention-dropdown.vue"]]);

  const __default__$5 = vue.defineComponent({
    name: "ElMention",
    inheritAttrs: false
  });
  const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$5,
    props: mentionProps,
    emits: mentionEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const passInputProps = vue.computed(() => pick(props, Object.keys(inputProps)));
      const ns = useNamespace("mention");
      const disabled = useFormDisabled();
      const contentId = useId();
      const elInputRef = vue.ref();
      const tooltipRef = vue.ref();
      const dropdownRef = vue.ref();
      const visible = vue.ref(false);
      const cursorStyle = vue.ref();
      const mentionCtx = vue.ref();
      const computedPlacement = vue.computed(() => props.showArrow ? props.placement : `${props.placement}-start`);
      const computedFallbackPlacements = vue.computed(() => props.showArrow ? ["bottom", "top"] : ["bottom-start", "top-start"]);
      const aliasProps = vue.computed(() => ({
        ...mentionDefaultProps,
        ...props.props
      }));
      const mapOption = (option) => {
        const base = {
          label: option[aliasProps.value.label],
          value: option[aliasProps.value.value],
          disabled: option[aliasProps.value.disabled]
        };
        return { ...option, ...base };
      };
      const options = vue.computed(() => props.options.map(mapOption));
      const filteredOptions = vue.computed(() => {
        const { filterOption } = props;
        if (!mentionCtx.value || !filterOption)
          return options.value;
        return options.value.filter((option) => filterOption(mentionCtx.value.pattern, option));
      });
      const dropdownVisible = vue.computed(() => {
        return visible.value && (!!filteredOptions.value.length || props.loading);
      });
      const hoveringId = vue.computed(() => {
        var _a;
        return `${contentId.value}-${(_a = dropdownRef.value) == null ? void 0 : _a.hoveringIndex}`;
      });
      const handleInputChange = (value) => {
        emit(UPDATE_MODEL_EVENT, value);
        emit(INPUT_EVENT, value);
        syncAfterCursorMove();
      };
      const handleInputKeyDown = (event) => {
        var _a, _b, _c, _d;
        if ((_a = elInputRef.value) == null ? void 0 : _a.isComposing)
          return;
        const code = getEventCode(event);
        switch (code) {
          case EVENT_CODE.left:
          case EVENT_CODE.right:
            syncAfterCursorMove();
            break;
          case EVENT_CODE.up:
          case EVENT_CODE.down:
            if (!visible.value)
              return;
            event.preventDefault();
            (_b = dropdownRef.value) == null ? void 0 : _b.navigateOptions(code === EVENT_CODE.up ? "prev" : "next");
            break;
          case EVENT_CODE.enter:
          case EVENT_CODE.numpadEnter:
            if (!visible.value) {
              props.type !== "textarea" && syncAfterCursorMove();
              return;
            }
            event.preventDefault();
            if ((_c = dropdownRef.value) == null ? void 0 : _c.hoverOption) {
              (_d = dropdownRef.value) == null ? void 0 : _d.selectHoverOption();
            } else {
              visible.value = false;
            }
            break;
          case EVENT_CODE.esc:
            if (!visible.value)
              return;
            event.preventDefault();
            visible.value = false;
            break;
          case EVENT_CODE.backspace:
            if (props.whole && mentionCtx.value) {
              const { splitIndex, selectionEnd, pattern, prefixIndex, prefix } = mentionCtx.value;
              const inputEl = getInputEl();
              if (!inputEl)
                return;
              const inputValue = inputEl.value;
              const matchOption = options.value.find((item) => item.value === pattern);
              const isWhole = isFunction$1(props.checkIsWhole) ? props.checkIsWhole(pattern, prefix) : matchOption;
              if (isWhole && splitIndex !== -1 && splitIndex + 1 === selectionEnd) {
                event.preventDefault();
                const newValue = inputValue.slice(0, prefixIndex) + inputValue.slice(splitIndex + 1);
                emit(UPDATE_MODEL_EVENT, newValue);
                emit(INPUT_EVENT, newValue);
                emit("whole-remove", pattern, prefix);
                const newSelectionEnd = prefixIndex;
                vue.nextTick(() => {
                  inputEl.selectionStart = newSelectionEnd;
                  inputEl.selectionEnd = newSelectionEnd;
                  syncDropdownVisible();
                });
              }
            }
        }
      };
      const { wrapperRef } = useFocusController(elInputRef, {
        disabled,
        afterFocus() {
          syncAfterCursorMove();
        },
        beforeBlur(event) {
          var _a;
          return (_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event);
        },
        afterBlur() {
          visible.value = false;
        }
      });
      const handleInputMouseDown = () => {
        syncAfterCursorMove();
      };
      const getOriginalOption = (mentionOption) => {
        return props.options.find((option) => {
          return mentionOption.value === option[aliasProps.value.value];
        });
      };
      const handleSelect = (item) => {
        if (!mentionCtx.value)
          return;
        const inputEl = getInputEl();
        if (!inputEl)
          return;
        const inputValue = inputEl.value;
        const { split } = props;
        const newEndPart = inputValue.slice(mentionCtx.value.end);
        const alreadySeparated = newEndPart.startsWith(split);
        const newMiddlePart = `${item.value}${alreadySeparated ? "" : split}`;
        const newValue = inputValue.slice(0, mentionCtx.value.start) + newMiddlePart + newEndPart;
        emit(UPDATE_MODEL_EVENT, newValue);
        emit(INPUT_EVENT, newValue);
        emit("select", getOriginalOption(item), mentionCtx.value.prefix);
        const newSelectionEnd = mentionCtx.value.start + newMiddlePart.length + (alreadySeparated ? 1 : 0);
        vue.nextTick(() => {
          inputEl.selectionStart = newSelectionEnd;
          inputEl.selectionEnd = newSelectionEnd;
          inputEl.focus();
          syncDropdownVisible();
        });
      };
      const getInputEl = () => {
        var _a, _b;
        return props.type === "textarea" ? (_a = elInputRef.value) == null ? void 0 : _a.textarea : (_b = elInputRef.value) == null ? void 0 : _b.input;
      };
      const syncAfterCursorMove = () => {
        setTimeout(() => {
          syncCursor();
          syncDropdownVisible();
          vue.nextTick(() => {
            var _a;
            return (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper();
          });
        }, 0);
      };
      const syncCursor = () => {
        const inputEl = getInputEl();
        if (!inputEl)
          return;
        const caretPosition = getCursorPosition(inputEl);
        const inputRect = inputEl.getBoundingClientRect();
        const wrapperRect = wrapperRef.value.getBoundingClientRect();
        cursorStyle.value = {
          position: "absolute",
          width: 0,
          height: `${caretPosition.height}px`,
          left: `${caretPosition.left + inputRect.left - wrapperRect.left}px`,
          top: `${caretPosition.top + inputRect.top - wrapperRect.top}px`
        };
      };
      const syncDropdownVisible = () => {
        const inputEl = getInputEl();
        if (document.activeElement !== inputEl) {
          visible.value = false;
          return;
        }
        const { prefix, split } = props;
        mentionCtx.value = getMentionCtx(inputEl, prefix, split);
        if (mentionCtx.value && mentionCtx.value.splitIndex === -1) {
          visible.value = true;
          emit("search", mentionCtx.value.pattern, mentionCtx.value.prefix);
          return;
        }
        visible.value = false;
      };
      expose({
        input: elInputRef,
        tooltip: tooltipRef,
        dropdownVisible
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "wrapperRef",
          ref: wrapperRef,
          class: vue.normalizeClass(vue.unref(ns).b())
        }, [
          vue.createVNode(vue.unref(ElInput), vue.mergeProps(vue.mergeProps(vue.unref(passInputProps), _ctx.$attrs), {
            ref_key: "elInputRef",
            ref: elInputRef,
            "model-value": _ctx.modelValue,
            disabled: vue.unref(disabled),
            role: vue.unref(dropdownVisible) ? "combobox" : void 0,
            "aria-activedescendant": vue.unref(dropdownVisible) ? vue.unref(hoveringId) || "" : void 0,
            "aria-controls": vue.unref(dropdownVisible) ? vue.unref(contentId) : void 0,
            "aria-expanded": vue.unref(dropdownVisible) || void 0,
            "aria-label": _ctx.ariaLabel,
            "aria-autocomplete": vue.unref(dropdownVisible) ? "none" : void 0,
            "aria-haspopup": vue.unref(dropdownVisible) ? "listbox" : void 0,
            onInput: handleInputChange,
            onKeydown: handleInputKeyDown,
            onMousedown: handleInputMouseDown
          }), vue.createSlots({
            _: 2
          }, [
            vue.renderList(_ctx.$slots, (_, name) => {
              return {
                name,
                fn: vue.withCtx((slotProps) => [
                  vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps)))
                ])
              };
            })
          ]), 1040, ["model-value", "disabled", "role", "aria-activedescendant", "aria-controls", "aria-expanded", "aria-label", "aria-autocomplete", "aria-haspopup"]),
          vue.createVNode(vue.unref(ElTooltip), {
            ref_key: "tooltipRef",
            ref: tooltipRef,
            visible: vue.unref(dropdownVisible),
            "popper-class": [vue.unref(ns).e("popper"), _ctx.popperClass],
            "popper-style": _ctx.popperStyle,
            "popper-options": _ctx.popperOptions,
            placement: vue.unref(computedPlacement),
            "fallback-placements": vue.unref(computedFallbackPlacements),
            effect: "light",
            pure: "",
            offset: _ctx.offset,
            "show-arrow": _ctx.showArrow
          }, {
            default: vue.withCtx(() => [
              vue.createElementVNode("div", {
                style: vue.normalizeStyle(cursorStyle.value)
              }, null, 4)
            ]),
            content: vue.withCtx(() => {
              var _a;
              return [
                vue.createVNode(ElMentionDropdown, {
                  ref_key: "dropdownRef",
                  ref: dropdownRef,
                  options: vue.unref(filteredOptions),
                  disabled: vue.unref(disabled),
                  loading: _ctx.loading,
                  "content-id": vue.unref(contentId),
                  "aria-label": _ctx.ariaLabel,
                  onSelect: handleSelect,
                  onClick: vue.withModifiers((_a = elInputRef.value) == null ? void 0 : _a.focus, ["stop"])
                }, vue.createSlots({
                  _: 2
                }, [
                  vue.renderList(_ctx.$slots, (_, name) => {
                    return {
                      name,
                      fn: vue.withCtx((slotProps) => [
                        vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps)))
                      ])
                    };
                  })
                ]), 1032, ["options", "disabled", "loading", "content-id", "aria-label", "onClick"])
              ];
            }),
            _: 3
          }, 8, ["visible", "popper-class", "popper-style", "popper-options", "placement", "fallback-placements", "offset", "show-arrow"])
        ], 2);
      };
    }
  });
  var Mention = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__file", "mention.vue"]]);

  const ElMention = withInstall(Mention);

  function useContainer(layout) {
    const containerEl = vue.ref();
    const { width, height } = useElementSize(containerEl);
    const containerSize = vue.computed(() => {
      return layout.value === "horizontal" ? width.value : height.value;
    });
    return { containerEl, containerSize };
  }

  function getPct(str) {
    return Number(str.slice(0, -1)) / 100;
  }
  function getPx(str) {
    return Number(str.slice(0, -2));
  }
  function isPct(itemSize) {
    return isString$1(itemSize) && itemSize.endsWith("%");
  }
  function isPx(itemSize) {
    return isString$1(itemSize) && itemSize.endsWith("px");
  }
  function useSize(panels, containerSize) {
    const propSizes = vue.computed(() => panels.value.map((i) => i.size));
    const panelCounts = vue.computed(() => panels.value.length);
    const percentSizes = vue.ref([]);
    vue.watch([propSizes, panelCounts, containerSize], () => {
      var _a;
      let ptgList = [];
      let emptyCount = 0;
      for (let i = 0; i < panelCounts.value; i += 1) {
        const itemSize = (_a = panels.value[i]) == null ? void 0 : _a.size;
        if (isPct(itemSize)) {
          ptgList[i] = getPct(itemSize);
        } else if (isPx(itemSize)) {
          ptgList[i] = getPx(itemSize) / containerSize.value;
        } else if (itemSize || itemSize === 0) {
          const num = Number(itemSize);
          if (!Number.isNaN(num)) {
            ptgList[i] = num / containerSize.value;
          }
        } else {
          emptyCount += 1;
          ptgList[i] = void 0;
        }
      }
      const totalPtg = ptgList.reduce((acc, ptg) => acc + (ptg || 0), 0);
      if (totalPtg > 1 || !emptyCount) {
        const scale = 1 / totalPtg;
        ptgList = ptgList.map((ptg) => ptg === void 0 ? 0 : ptg * scale);
      } else {
        const avgRest = (1 - totalPtg) / emptyCount;
        ptgList = ptgList.map((ptg) => ptg === void 0 ? avgRest : ptg);
      }
      percentSizes.value = ptgList;
    });
    const ptg2px = (ptg) => ptg * containerSize.value;
    const pxSizes = vue.computed(() => percentSizes.value.map(ptg2px));
    return { percentSizes, pxSizes };
  }

  function useResize(panels, containerSize, pxSizes, lazy) {
    const ptg2px = (ptg) => ptg * containerSize.value || 0;
    function getLimitSize(str, defaultLimit) {
      if (isPct(str)) {
        return ptg2px(getPct(str));
      } else if (isPx(str)) {
        return getPx(str);
      }
      return str != null ? str : defaultLimit;
    }
    const lazyOffset = vue.ref(0);
    const movingIndex = vue.ref(null);
    let cachePxSizes = [];
    let updatePanelSizes = NOOP;
    const limitSizes = vue.computed(() => panels.value.map((item) => [item.min, item.max]));
    vue.watch(lazy, () => {
      if (lazyOffset.value) {
        const mouseup = new MouseEvent("mouseup", { bubbles: true });
        window.dispatchEvent(mouseup);
      }
    });
    const onMoveStart = (index) => {
      lazyOffset.value = 0;
      movingIndex.value = { index, confirmed: false };
      cachePxSizes = pxSizes.value;
    };
    const onMoving = (index, offset) => {
      var _a, _b;
      let confirmedIndex = null;
      if ((!movingIndex.value || !movingIndex.value.confirmed) && offset !== 0) {
        if (offset > 0) {
          confirmedIndex = index;
          movingIndex.value = { index, confirmed: true };
        } else {
          for (let i = index; i >= 0; i -= 1) {
            if (cachePxSizes[i] > 0) {
              confirmedIndex = i;
              movingIndex.value = { index: i, confirmed: true };
              break;
            }
          }
        }
      }
      const mergedIndex = (_b = confirmedIndex != null ? confirmedIndex : (_a = movingIndex.value) == null ? void 0 : _a.index) != null ? _b : index;
      const numSizes = [...cachePxSizes];
      const nextIndex = mergedIndex + 1;
      const startMinSize = getLimitSize(limitSizes.value[mergedIndex][0], 0);
      const endMinSize = getLimitSize(limitSizes.value[nextIndex][0], 0);
      const startMaxSize = getLimitSize(limitSizes.value[mergedIndex][1], containerSize.value || 0);
      const endMaxSize = getLimitSize(limitSizes.value[nextIndex][1], containerSize.value || 0);
      let mergedOffset = offset;
      if (numSizes[mergedIndex] + mergedOffset < startMinSize) {
        mergedOffset = startMinSize - numSizes[mergedIndex];
      }
      if (numSizes[nextIndex] - mergedOffset < endMinSize) {
        mergedOffset = numSizes[nextIndex] - endMinSize;
      }
      if (numSizes[mergedIndex] + mergedOffset > startMaxSize) {
        mergedOffset = startMaxSize - numSizes[mergedIndex];
      }
      if (numSizes[nextIndex] - mergedOffset > endMaxSize) {
        mergedOffset = numSizes[nextIndex] - endMaxSize;
      }
      numSizes[mergedIndex] += mergedOffset;
      numSizes[nextIndex] -= mergedOffset;
      lazyOffset.value = mergedOffset;
      updatePanelSizes = () => {
        panels.value.forEach((panel, index2) => {
          panel.size = numSizes[index2];
        });
        updatePanelSizes = NOOP;
      };
      if (!lazy.value) {
        updatePanelSizes();
      }
    };
    const onMoveEnd = () => {
      if (lazy.value) {
        updatePanelSizes();
      }
      lazyOffset.value = 0;
      movingIndex.value = null;
      cachePxSizes = [];
    };
    const cacheCollapsedSize = [];
    const onCollapse = (index, type) => {
      if (!cacheCollapsedSize.length) {
        cacheCollapsedSize.push(...pxSizes.value);
      }
      const currentSizes = pxSizes.value;
      const currentIndex = type === "start" ? index : index + 1;
      const targetIndex = type === "start" ? index + 1 : index;
      const currentSize = currentSizes[currentIndex];
      const targetSize = currentSizes[targetIndex];
      if (currentSize !== 0 && targetSize !== 0) {
        currentSizes[currentIndex] = 0;
        currentSizes[targetIndex] += currentSize;
        cacheCollapsedSize[index] = currentSize;
      } else {
        const totalSize = currentSize + targetSize;
        const targetCacheCollapsedSize = cacheCollapsedSize[index];
        const currentCacheCollapsedSize = totalSize - targetCacheCollapsedSize;
        currentSizes[targetIndex] = targetCacheCollapsedSize;
        currentSizes[currentIndex] = currentCacheCollapsedSize;
      }
      panels.value.forEach((panel, index2) => {
        panel.size = currentSizes[index2];
      });
    };
    return {
      lazyOffset,
      onMoveStart,
      onMoving,
      onMoveEnd,
      movingIndex,
      onCollapse
    };
  }

  const splitterProps = buildProps({
    layout: {
      type: String,
      default: "horizontal",
      values: ["horizontal", "vertical"]
    },
    lazy: Boolean
  });

  const splitterRootContextKey = Symbol("splitterRootContextKey");

  const __default__$4 = vue.defineComponent({
    name: "ElSplitter"
  });
  const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$4,
    props: splitterProps,
    emits: ["resizeStart", "resize", "resizeEnd", "collapse"],
    setup(__props, { emit: emits }) {
      const props = __props;
      const ns = useNamespace("splitter");
      const layout = vue.toRef(props, "layout");
      const lazy = vue.toRef(props, "lazy");
      const { containerEl, containerSize } = useContainer(layout);
      const {
        removeChild: unregisterPanel,
        children: panels,
        addChild: registerPanel,
        ChildrenSorter: PanelsSorter
      } = useOrderedChildren(vue.getCurrentInstance(), "ElSplitterPanel");
      vue.watch(panels, () => {
        panels.value.forEach((instance, index) => {
          instance.setIndex(index);
        });
      });
      const { percentSizes, pxSizes } = useSize(panels, containerSize);
      const {
        lazyOffset,
        movingIndex,
        onMoveStart,
        onMoving,
        onMoveEnd,
        onCollapse
      } = useResize(panels, containerSize, pxSizes, lazy);
      const splitterStyles = vue.computed(() => {
        return {
          [ns.cssVarBlockName("bar-offset")]: lazy.value ? `${lazyOffset.value}px` : void 0
        };
      });
      const onResizeStart = (index) => {
        onMoveStart(index);
        emits("resizeStart", index, pxSizes.value);
      };
      const onResize = (index, offset) => {
        onMoving(index, offset);
        if (!lazy.value) {
          emits("resize", index, pxSizes.value);
        }
      };
      const onResizeEnd = async (index) => {
        onMoveEnd();
        await vue.nextTick();
        emits("resizeEnd", index, pxSizes.value);
      };
      const onCollapsible = (index, type) => {
        onCollapse(index, type);
        emits("collapse", index, type, pxSizes.value);
      };
      vue.provide(splitterRootContextKey, vue.reactive({
        panels,
        percentSizes,
        pxSizes,
        layout,
        lazy,
        movingIndex,
        containerSize,
        onMoveStart: onResizeStart,
        onMoving: onResize,
        onMoveEnd: onResizeEnd,
        onCollapse: onCollapsible,
        registerPanel,
        unregisterPanel
      }));
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          ref_key: "containerEl",
          ref: containerEl,
          class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).e(vue.unref(layout))]),
          style: vue.normalizeStyle(vue.unref(splitterStyles))
        }, [
          vue.renderSlot(_ctx.$slots, "default"),
          vue.createVNode(vue.unref(PanelsSorter)),
          vue.createCommentVNode(" Prevent iframe touch events from breaking "),
          vue.unref(movingIndex) ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass([vue.unref(ns).e("mask"), vue.unref(ns).e(`mask-${vue.unref(layout)}`)])
          }, null, 2)) : vue.createCommentVNode("v-if", true)
        ], 6);
      };
    }
  });
  var Splitter = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__file", "splitter.vue"]]);

  function getCollapsible(collapsible) {
    if (collapsible && isObject$1(collapsible)) {
      return collapsible;
    }
    return {
      start: !!collapsible,
      end: !!collapsible
    };
  }
  function isCollapsible(panel, size, nextPanel, nextSize) {
    if ((panel == null ? void 0 : panel.collapsible.end) && size > 0) {
      return true;
    }
    if ((nextPanel == null ? void 0 : nextPanel.collapsible.start) && nextSize === 0 && size > 0) {
      return true;
    }
    return false;
  }

  const __default__$3 = vue.defineComponent({
    name: "ElSplitterBar"
  });
  const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$3,
    props: {
      index: {
        type: Number,
        required: true
      },
      layout: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "horizontal"
      },
      resizable: {
        type: Boolean,
        default: true
      },
      lazy: Boolean,
      startCollapsible: Boolean,
      endCollapsible: Boolean
    },
    emits: ["moveStart", "moving", "moveEnd", "collapse"],
    setup(__props, { emit }) {
      const props = __props;
      const ns = useNamespace("splitter-bar");
      const isHorizontal = vue.computed(() => props.layout === "horizontal");
      const barWrapStyles = vue.computed(() => {
        if (isHorizontal.value) {
          return { width: 0 };
        }
        return { height: 0 };
      });
      const draggerStyles = vue.computed(() => {
        return {
          width: isHorizontal.value ? "16px" : "100%",
          height: isHorizontal.value ? "100%" : "16px",
          cursor: !props.resizable ? "auto" : isHorizontal.value ? "ew-resize" : "ns-resize",
          touchAction: "none"
        };
      });
      const draggerPseudoClass = vue.computed(() => {
        const prefix = ns.e("dragger");
        return {
          [`${prefix}-horizontal`]: isHorizontal.value,
          [`${prefix}-vertical`]: !isHorizontal.value,
          [`${prefix}-active`]: !!startPos.value
        };
      });
      const startPos = vue.ref(null);
      const onMousedown = (e) => {
        if (!props.resizable)
          return;
        startPos.value = [e.pageX, e.pageY];
        emit("moveStart", props.index);
        window.addEventListener("mouseup", onMouseUp);
        window.addEventListener("mousemove", onMouseMove);
      };
      const onTouchStart = (e) => {
        if (props.resizable && e.touches.length === 1) {
          e.preventDefault();
          const touch = e.touches[0];
          startPos.value = [touch.pageX, touch.pageY];
          emit("moveStart", props.index);
          window.addEventListener("touchend", onTouchEnd);
          window.addEventListener("touchmove", onTouchMove);
        }
      };
      const onMouseMove = (e) => {
        const { pageX, pageY } = e;
        const offsetX = pageX - startPos.value[0];
        const offsetY = pageY - startPos.value[1];
        const offset = isHorizontal.value ? offsetX : offsetY;
        emit("moving", props.index, offset);
      };
      const onTouchMove = (e) => {
        if (e.touches.length === 1) {
          e.preventDefault();
          const touch = e.touches[0];
          const offsetX = touch.pageX - startPos.value[0];
          const offsetY = touch.pageY - startPos.value[1];
          const offset = isHorizontal.value ? offsetX : offsetY;
          emit("moving", props.index, offset);
        }
      };
      const onMouseUp = () => {
        startPos.value = null;
        window.removeEventListener("mouseup", onMouseUp);
        window.removeEventListener("mousemove", onMouseMove);
        emit("moveEnd", props.index);
      };
      const onTouchEnd = () => {
        startPos.value = null;
        window.removeEventListener("touchend", onTouchEnd);
        window.removeEventListener("touchmove", onTouchMove);
        emit("moveEnd", props.index);
      };
      const StartIcon = vue.computed(() => isHorizontal.value ? arrow_left_default : arrow_up_default);
      const EndIcon = vue.computed(() => isHorizontal.value ? arrow_right_default : arrow_down_default);
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", {
          class: vue.normalizeClass([vue.unref(ns).b()]),
          style: vue.normalizeStyle(vue.unref(barWrapStyles))
        }, [
          __props.startCollapsible ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass([vue.unref(ns).e("collapse-icon"), vue.unref(ns).e(`${__props.layout}-collapse-icon-start`)]),
            onClick: ($event) => emit("collapse", __props.index, "start")
          }, [
            vue.renderSlot(_ctx.$slots, "start-collapsible", {}, () => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(StartIcon)), { style: { "width": "12px", "height": "12px" } }))
            ])
          ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            class: vue.normalizeClass([
              vue.unref(ns).e("dragger"),
              vue.unref(draggerPseudoClass),
              vue.unref(ns).is("disabled", !__props.resizable),
              vue.unref(ns).is("lazy", __props.resizable && __props.lazy)
            ]),
            style: vue.normalizeStyle(vue.unref(draggerStyles)),
            onMousedown,
            onTouchstart: onTouchStart
          }, null, 38),
          __props.endCollapsible ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass([vue.unref(ns).e("collapse-icon"), vue.unref(ns).e(`${__props.layout}-collapse-icon-end`)]),
            onClick: ($event) => emit("collapse", __props.index, "end")
          }, [
            vue.renderSlot(_ctx.$slots, "end-collapsible", {}, () => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(EndIcon)), { style: { "width": "12px", "height": "12px" } }))
            ])
          ], 10, ["onClick"])) : vue.createCommentVNode("v-if", true)
        ], 6);
      };
    }
  });
  var SplitBar = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__file", "split-bar.vue"]]);

  const splitterPanelProps = buildProps({
    min: {
      type: [String, Number]
    },
    max: {
      type: [String, Number]
    },
    size: {
      type: [String, Number]
    },
    resizable: {
      type: Boolean,
      default: true
    },
    collapsible: Boolean
  });

  const COMPONENT_NAME = "ElSplitterPanel";
  const __default__$2 = vue.defineComponent({
    name: COMPONENT_NAME
  });
  const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$2,
    props: splitterPanelProps,
    emits: ["update:size"],
    setup(__props, { emit: emits }) {
      const props = __props;
      const ns = useNamespace("splitter-panel");
      const splitterContext = vue.inject(splitterRootContextKey);
      if (!splitterContext)
        throwError(COMPONENT_NAME, "usage: <el-splitter><el-splitter-panel /></el-splitter/>");
      const { panels, layout, lazy, containerSize, pxSizes } = vue.toRefs(splitterContext);
      const {
        registerPanel,
        unregisterPanel,
        onCollapse,
        onMoveEnd,
        onMoveStart,
        onMoving
      } = splitterContext;
      const panelEl = vue.ref();
      const instance = vue.getCurrentInstance();
      const uid = instance.uid;
      const index = vue.ref(0);
      const panel = vue.computed(() => panels.value[index.value]);
      const setIndex = (val) => {
        index.value = val;
      };
      const panelSize = vue.computed(() => {
        var _a;
        if (!panel.value)
          return 0;
        return (_a = pxSizes.value[index.value]) != null ? _a : 0;
      });
      const nextSize = vue.computed(() => {
        var _a;
        if (!panel.value)
          return 0;
        return (_a = pxSizes.value[index.value + 1]) != null ? _a : 0;
      });
      const nextPanel = vue.computed(() => {
        if (panel.value) {
          return panels.value[index.value + 1];
        }
        return null;
      });
      const isResizable = vue.computed(() => {
        var _a;
        if (!nextPanel.value)
          return false;
        return props.resizable && ((_a = nextPanel.value) == null ? void 0 : _a.resizable) && (panelSize.value !== 0 || !props.min) && (nextSize.value !== 0 || !nextPanel.value.min);
      });
      const isShowBar = vue.computed(() => {
        if (!panel.value)
          return false;
        return index.value !== panels.value.length - 1;
      });
      const startCollapsible = vue.computed(() => isCollapsible(panel.value, panelSize.value, nextPanel.value, nextSize.value));
      const endCollapsible = vue.computed(() => isCollapsible(nextPanel.value, nextSize.value, panel.value, panelSize.value));
      function sizeToPx(str) {
        if (isPct(str)) {
          return getPct(str) * containerSize.value || 0;
        } else if (isPx(str)) {
          return getPx(str);
        }
        return str != null ? str : 0;
      }
      let isSizeUpdating = false;
      vue.watch(() => props.size, () => {
        if (!isSizeUpdating && panel.value) {
          if (!containerSize.value) {
            panel.value.size = props.size;
            return;
          }
          const size = sizeToPx(props.size);
          const maxSize = sizeToPx(props.max);
          const minSize = sizeToPx(props.min);
          const finalSize = Math.min(Math.max(size, minSize || 0), maxSize || size);
          if (finalSize !== size) {
            emits("update:size", finalSize);
          }
          panel.value.size = finalSize;
        }
      });
      vue.watch(() => {
        var _a;
        return (_a = panel.value) == null ? void 0 : _a.size;
      }, (val) => {
        if (val !== props.size) {
          isSizeUpdating = true;
          emits("update:size", val);
          vue.nextTick(() => isSizeUpdating = false);
        }
      });
      vue.watch(() => props.resizable, (val) => {
        if (panel.value) {
          panel.value.resizable = val;
        }
      });
      const _panel = vue.reactive({
        el: panelEl.value,
        uid,
        getVnode: () => instance.vnode,
        setIndex,
        ...props,
        collapsible: vue.computed(() => getCollapsible(props.collapsible))
      });
      registerPanel(_panel);
      vue.onBeforeUnmount(() => unregisterPanel(_panel));
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
          vue.createElementVNode("div", vue.mergeProps({
            ref_key: "panelEl",
            ref: panelEl,
            class: [vue.unref(ns).b()],
            style: { flexBasis: `${vue.unref(panelSize)}px` }
          }, _ctx.$attrs), [
            vue.renderSlot(_ctx.$slots, "default")
          ], 16),
          vue.unref(isShowBar) ? (vue.openBlock(), vue.createBlock(SplitBar, {
            key: 0,
            index: index.value,
            layout: vue.unref(layout),
            lazy: vue.unref(lazy),
            resizable: vue.unref(isResizable),
            "start-collapsible": vue.unref(startCollapsible),
            "end-collapsible": vue.unref(endCollapsible),
            onMoveStart: vue.unref(onMoveStart),
            onMoving: vue.unref(onMoving),
            onMoveEnd: vue.unref(onMoveEnd),
            onCollapse: vue.unref(onCollapse)
          }, {
            "start-collapsible": vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "start-collapsible")
            ]),
            "end-collapsible": vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "end-collapsible")
            ]),
            _: 3
          }, 8, ["index", "layout", "lazy", "resizable", "start-collapsible", "end-collapsible", "onMoveStart", "onMoving", "onMoveEnd", "onCollapse"])) : vue.createCommentVNode("v-if", true)
        ], 64);
      };
    }
  });
  var SplitPanel = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__file", "split-panel.vue"]]);

  const ElSplitter = withInstall(Splitter, {
    SplitPanel
  });
  const ElSplitterPanel = withNoopInstall(SplitPanel);

  var Components = [
    ElAffix,
    ElAlert,
    ElAutocomplete,
    ElAutoResizer,
    ElAvatar,
    ElBacktop,
    ElBadge,
    ElBreadcrumb,
    ElBreadcrumbItem,
    ElButton,
    ElButtonGroup$1,
    ElCalendar,
    ElCard,
    ElCarousel,
    ElCarouselItem,
    ElCascader,
    ElCascaderPanel,
    ElCheckTag,
    ElCheckbox,
    ElCheckboxButton,
    ElCheckboxGroup$1,
    ElCol,
    ElCollapse,
    ElCollapseItem,
    ElCollapseTransition,
    ElColorPickerPanel,
    ElColorPicker,
    ElConfigProvider,
    ElContainer,
    ElAside,
    ElFooter,
    ElHeader,
    ElMain,
    ElDatePicker,
    ElDatePickerPanel,
    ElDescriptions,
    ElDescriptionsItem,
    ElDialog,
    ElDivider,
    ElDrawer,
    ElDropdown,
    ElDropdownItem,
    ElDropdownMenu,
    ElEmpty,
    ElForm,
    ElFormItem,
    ElIcon,
    ElImage,
    ElImageViewer,
    ElInput,
    ElInputNumber,
    ElInputTag,
    ElLink,
    ElMenu,
    ElMenuItem,
    ElMenuItemGroup,
    ElSubMenu,
    ElPageHeader,
    ElPagination,
    ElPopconfirm,
    ElPopover,
    ElPopper,
    ElProgress,
    ElRadio,
    ElRadioButton,
    ElRadioGroup,
    ElRate,
    ElResult,
    ElRow,
    ElScrollbar,
    ElSelect,
    ElOption,
    ElOptionGroup,
    ElSelectV2,
    ElSkeleton,
    ElSkeletonItem,
    ElSlider,
    ElSpace,
    ElStatistic,
    ElCountdown,
    ElSteps,
    ElStep,
    ElSwitch,
    ElTable,
    ElTableColumn,
    ElTableV2,
    ElTabs,
    ElTabPane,
    ElTag,
    ElText,
    ElTimePicker,
    ElTimeSelect,
    ElTimeline,
    ElTimelineItem,
    ElTooltip,
    ElTransfer,
    ElTree,
    ElTreeSelect,
    ElTreeV2,
    ElUpload,
    ElWatermark,
    ElTour,
    ElTourStep,
    ElAnchor,
    ElAnchorLink,
    ElSegmented,
    ElMention,
    ElSplitter,
    ElSplitterPanel
  ];

  const SCOPE = "ElInfiniteScroll";
  const CHECK_INTERVAL = 50;
  const DEFAULT_DELAY = 200;
  const DEFAULT_DISTANCE = 0;
  const attributes = {
    delay: {
      type: Number,
      default: DEFAULT_DELAY
    },
    distance: {
      type: Number,
      default: DEFAULT_DISTANCE
    },
    disabled: {
      type: Boolean,
      default: false
    },
    immediate: {
      type: Boolean,
      default: true
    }
  };
  const getScrollOptions = (el, instance) => {
    return Object.entries(attributes).reduce((acm, [name, option]) => {
      var _a, _b;
      const { type, default: defaultValue } = option;
      const attrVal = el.getAttribute(`infinite-scroll-${name}`);
      let value = (_b = (_a = instance[attrVal]) != null ? _a : attrVal) != null ? _b : defaultValue;
      value = value === "false" ? false : value;
      value = type(value);
      acm[name] = Number.isNaN(value) ? defaultValue : value;
      return acm;
    }, {});
  };
  const destroyObserver = (el) => {
    const { observer } = el[SCOPE];
    if (observer) {
      observer.disconnect();
      delete el[SCOPE].observer;
    }
  };
  const handleScroll = (el, cb) => {
    const { container, containerEl, instance, observer, lastScrollTop } = el[SCOPE];
    const { disabled, distance } = getScrollOptions(el, instance);
    const { clientHeight, scrollHeight, scrollTop } = containerEl;
    const delta = scrollTop - lastScrollTop;
    el[SCOPE].lastScrollTop = scrollTop;
    if (observer || disabled || delta < 0)
      return;
    let shouldTrigger = false;
    if (container === el) {
      shouldTrigger = scrollHeight - (clientHeight + scrollTop) <= distance;
    } else {
      const { clientTop, scrollHeight: height } = el;
      const offsetTop = getOffsetTopDistance(el, containerEl);
      shouldTrigger = scrollTop + clientHeight >= offsetTop + clientTop + height - distance;
    }
    if (shouldTrigger) {
      cb.call(instance);
    }
  };
  function checkFull(el, cb) {
    const { containerEl, instance } = el[SCOPE];
    const { disabled } = getScrollOptions(el, instance);
    if (disabled || containerEl.clientHeight === 0)
      return;
    if (containerEl.scrollHeight <= containerEl.clientHeight) {
      cb.call(instance);
    } else {
      destroyObserver(el);
    }
  }
  const InfiniteScroll = {
    async mounted(el, binding) {
      const { instance, value: cb } = binding;
      useDeprecated({
        scope: SCOPE,
        from: "the directive v-infinite-scroll",
        replacement: "the el-scrollbar infinite scroll",
        version: "3.0.0",
        ref: "https://element-plus.org/en-US/component/scrollbar#infinite-scroll"
      }, true);
      if (!isFunction$1(cb)) {
        throwError(SCOPE, "'v-infinite-scroll' binding value must be a function");
      }
      await vue.nextTick();
      const { delay, immediate } = getScrollOptions(el, instance);
      const container = getScrollContainer(el, true);
      const containerEl = container === window ? document.documentElement : container;
      const onScroll = throttle(handleScroll.bind(null, el, cb), delay);
      if (!container)
        return;
      el[SCOPE] = {
        instance,
        container,
        containerEl,
        delay,
        cb,
        onScroll,
        lastScrollTop: containerEl.scrollTop
      };
      if (immediate) {
        const observer = new MutationObserver(throttle(checkFull.bind(null, el, cb), CHECK_INTERVAL));
        el[SCOPE].observer = observer;
        observer.observe(el, { childList: true, subtree: true });
        checkFull(el, cb);
      }
      container.addEventListener("scroll", onScroll);
    },
    unmounted(el) {
      if (!el[SCOPE])
        return;
      const { container, onScroll } = el[SCOPE];
      container == null ? void 0 : container.removeEventListener("scroll", onScroll);
      destroyObserver(el);
    },
    async updated(el) {
      if (!el[SCOPE]) {
        await vue.nextTick();
      } else {
        const { containerEl, cb, observer } = el[SCOPE];
        if (containerEl.clientHeight && observer) {
          checkFull(el, cb);
        }
      }
    }
  };
  var InfiniteScroll$1 = InfiniteScroll;

  const _InfiniteScroll = InfiniteScroll$1;
  _InfiniteScroll.install = (app) => {
    app.directive("InfiniteScroll", _InfiniteScroll);
  };
  const ElInfiniteScroll = _InfiniteScroll;

  function createLoadingComponent(options, appContext) {
    let afterLeaveTimer;
    const afterLeaveFlag = vue.ref(false);
    const data = vue.reactive({
      ...options,
      originalPosition: "",
      originalOverflow: "",
      visible: false
    });
    function setText(text) {
      data.text = text;
    }
    function destroySelf() {
      const target = data.parent;
      const ns = vm.ns;
      if (!target.vLoadingAddClassList) {
        let loadingNumber = target.getAttribute("loading-number");
        loadingNumber = Number.parseInt(loadingNumber) - 1;
        if (!loadingNumber) {
          removeClass(target, ns.bm("parent", "relative"));
          target.removeAttribute("loading-number");
        } else {
          target.setAttribute("loading-number", loadingNumber.toString());
        }
        removeClass(target, ns.bm("parent", "hidden"));
      }
      removeElLoadingChild();
      loadingInstance.unmount();
    }
    function removeElLoadingChild() {
      var _a, _b;
      (_b = (_a = vm.$el) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.removeChild(vm.$el);
    }
    function close() {
      var _a;
      if (options.beforeClose && !options.beforeClose())
        return;
      afterLeaveFlag.value = true;
      clearTimeout(afterLeaveTimer);
      afterLeaveTimer = setTimeout(handleAfterLeave, 400);
      data.visible = false;
      (_a = options.closed) == null ? void 0 : _a.call(options);
    }
    function handleAfterLeave() {
      if (!afterLeaveFlag.value)
        return;
      const target = data.parent;
      afterLeaveFlag.value = false;
      target.vLoadingAddClassList = void 0;
      destroySelf();
    }
    const elLoadingComponent = vue.defineComponent({
      name: "ElLoading",
      setup(_, { expose }) {
        const { ns, zIndex } = useGlobalComponentSettings("loading");
        expose({
          ns,
          zIndex
        });
        return () => {
          const svg = data.spinner || data.svg;
          const spinner = vue.h("svg", {
            class: "circular",
            viewBox: data.svgViewBox ? data.svgViewBox : "0 0 50 50",
            ...svg ? { innerHTML: svg } : {}
          }, [
            vue.h("circle", {
              class: "path",
              cx: "25",
              cy: "25",
              r: "20",
              fill: "none"
            })
          ]);
          const spinnerText = data.text ? vue.h("p", { class: ns.b("text") }, [data.text]) : void 0;
          return vue.h(vue.Transition, {
            name: ns.b("fade"),
            onAfterLeave: handleAfterLeave
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createVNode("div", {
                style: {
                  backgroundColor: data.background || ""
                },
                class: [
                  ns.b("mask"),
                  data.customClass,
                  ns.is("fullscreen", data.fullscreen)
                ]
              }, [
                vue.h("div", {
                  class: ns.b("spinner")
                }, [spinner, spinnerText])
              ]), [[vue.vShow, data.visible]])
            ])
          });
        };
      }
    });
    const loadingInstance = vue.createApp(elLoadingComponent);
    Object.assign(loadingInstance._context, appContext != null ? appContext : {});
    const vm = loadingInstance.mount(document.createElement("div"));
    return {
      ...vue.toRefs(data),
      setText,
      removeElLoadingChild,
      close,
      handleAfterLeave,
      vm,
      get $el() {
        return vm.$el;
      }
    };
  }

  let fullscreenInstance = void 0;
  const Loading = function(options = {}, context) {
    if (!isClient)
      return void 0;
    const resolved = resolveOptions(options);
    if (resolved.fullscreen && fullscreenInstance) {
      return fullscreenInstance;
    }
    const instance = createLoadingComponent({
      ...resolved,
      closed: () => {
        var _a;
        (_a = resolved.closed) == null ? void 0 : _a.call(resolved);
        if (resolved.fullscreen)
          fullscreenInstance = void 0;
      }
    }, context != null ? context : Loading._context);
    addStyle(resolved, resolved.parent, instance);
    addClassList(resolved, resolved.parent, instance);
    resolved.parent.vLoadingAddClassList = () => addClassList(resolved, resolved.parent, instance);
    let loadingNumber = resolved.parent.getAttribute("loading-number");
    if (!loadingNumber) {
      loadingNumber = "1";
    } else {
      loadingNumber = `${Number.parseInt(loadingNumber) + 1}`;
    }
    resolved.parent.setAttribute("loading-number", loadingNumber);
    resolved.parent.appendChild(instance.$el);
    vue.nextTick(() => instance.visible.value = resolved.visible);
    if (resolved.fullscreen) {
      fullscreenInstance = instance;
    }
    return instance;
  };
  const resolveOptions = (options) => {
    var _a, _b, _c, _d;
    let target;
    if (isString$1(options.target)) {
      target = (_a = document.querySelector(options.target)) != null ? _a : document.body;
    } else {
      target = options.target || document.body;
    }
    return {
      parent: target === document.body || options.body ? document.body : target,
      background: options.background || "",
      svg: options.svg || "",
      svgViewBox: options.svgViewBox || "",
      spinner: options.spinner || false,
      text: options.text || "",
      fullscreen: target === document.body && ((_b = options.fullscreen) != null ? _b : true),
      lock: (_c = options.lock) != null ? _c : false,
      customClass: options.customClass || "",
      visible: (_d = options.visible) != null ? _d : true,
      beforeClose: options.beforeClose,
      closed: options.closed,
      target
    };
  };
  const addStyle = async (options, parent, instance) => {
    const { nextZIndex } = instance.vm.zIndex || instance.vm._.exposed.zIndex;
    const maskStyle = {};
    if (options.fullscreen) {
      instance.originalPosition.value = getStyle(document.body, "position");
      instance.originalOverflow.value = getStyle(document.body, "overflow");
      maskStyle.zIndex = nextZIndex();
    } else if (options.parent === document.body) {
      instance.originalPosition.value = getStyle(document.body, "position");
      await vue.nextTick();
      for (const property of ["top", "left"]) {
        const scroll = property === "top" ? "scrollTop" : "scrollLeft";
        maskStyle[property] = `${options.target.getBoundingClientRect()[property] + document.body[scroll] + document.documentElement[scroll] - Number.parseInt(getStyle(document.body, `margin-${property}`), 10)}px`;
      }
      for (const property of ["height", "width"]) {
        maskStyle[property] = `${options.target.getBoundingClientRect()[property]}px`;
      }
    } else {
      instance.originalPosition.value = getStyle(parent, "position");
    }
    for (const [key, value] of Object.entries(maskStyle)) {
      instance.$el.style[key] = value;
    }
  };
  const addClassList = (options, parent, instance) => {
    const ns = instance.vm.ns || instance.vm._.exposed.ns;
    if (!["absolute", "fixed", "sticky"].includes(instance.originalPosition.value)) {
      addClass(parent, ns.bm("parent", "relative"));
    } else {
      removeClass(parent, ns.bm("parent", "relative"));
    }
    if (options.fullscreen && options.lock) {
      addClass(parent, ns.bm("parent", "hidden"));
    } else {
      removeClass(parent, ns.bm("parent", "hidden"));
    }
  };
  Loading._context = null;
  var Loading$1 = Loading;

  const INSTANCE_KEY = Symbol("ElLoading");
  const getAttributeName = (name) => {
    return `element-loading-${hyphenate(name)}`;
  };
  const createInstance = (el, binding) => {
    var _a, _b, _c, _d;
    const vm = binding.instance;
    const getBindingProp = (key) => isObject$1(binding.value) ? binding.value[key] : void 0;
    const resolveExpression = (key) => {
      const data = isString$1(key) && (vm == null ? void 0 : vm[key]) || key;
      return vue.ref(data);
    };
    const getProp = (name) => resolveExpression(getBindingProp(name) || el.getAttribute(getAttributeName(name)));
    const fullscreen = (_a = getBindingProp("fullscreen")) != null ? _a : binding.modifiers.fullscreen;
    const options = {
      text: getProp("text"),
      svg: getProp("svg"),
      svgViewBox: getProp("svgViewBox"),
      spinner: getProp("spinner"),
      background: getProp("background"),
      customClass: getProp("customClass"),
      fullscreen,
      target: (_b = getBindingProp("target")) != null ? _b : fullscreen ? void 0 : el,
      body: (_c = getBindingProp("body")) != null ? _c : binding.modifiers.body,
      lock: (_d = getBindingProp("lock")) != null ? _d : binding.modifiers.lock
    };
    const instance = Loading$1(options);
    instance._context = vLoading._context;
    el[INSTANCE_KEY] = {
      options,
      instance
    };
  };
  const updateOptions = (originalOptions, newOptions) => {
    for (const key of Object.keys(originalOptions)) {
      if (vue.isRef(originalOptions[key]))
        originalOptions[key].value = newOptions[key];
    }
  };
  const vLoading = {
    mounted(el, binding) {
      if (binding.value) {
        createInstance(el, binding);
      }
    },
    updated(el, binding) {
      const instance = el[INSTANCE_KEY];
      if (!binding.value) {
        instance == null ? void 0 : instance.instance.close();
        el[INSTANCE_KEY] = null;
        return;
      }
      if (!instance)
        createInstance(el, binding);
      else {
        updateOptions(instance.options, isObject$1(binding.value) ? binding.value : {
          text: el.getAttribute(getAttributeName("text")),
          svg: el.getAttribute(getAttributeName("svg")),
          svgViewBox: el.getAttribute(getAttributeName("svgViewBox")),
          spinner: el.getAttribute(getAttributeName("spinner")),
          background: el.getAttribute(getAttributeName("background")),
          customClass: el.getAttribute(getAttributeName("customClass"))
        });
      }
    },
    unmounted(el) {
      var _a;
      (_a = el[INSTANCE_KEY]) == null ? void 0 : _a.instance.close();
      el[INSTANCE_KEY] = null;
    }
  };
  vLoading._context = null;
  var vLoading$1 = vLoading;

  const ElLoading = {
    install(app) {
      Loading$1._context = app._context;
      vLoading$1._context = app._context;
      app.directive("loading", vLoading$1);
      app.config.globalProperties.$loading = Loading$1;
    },
    directive: vLoading$1,
    service: Loading$1
  };

  const messageTypes = [
    "primary",
    "success",
    "info",
    "warning",
    "error"
  ];
  const messagePlacement = [
    "top",
    "top-left",
    "top-right",
    "bottom",
    "bottom-left",
    "bottom-right"
  ];
  const MESSAGE_DEFAULT_PLACEMENT = "top";
  const messageDefaults = mutable({
    customClass: "",
    dangerouslyUseHTMLString: false,
    duration: 3e3,
    icon: void 0,
    id: "",
    message: "",
    onClose: void 0,
    showClose: false,
    type: "info",
    plain: false,
    offset: 16,
    placement: void 0,
    zIndex: 0,
    grouping: false,
    repeatNum: 1,
    appendTo: isClient ? document.body : void 0
  });
  const messageProps = buildProps({
    customClass: {
      type: String,
      default: messageDefaults.customClass
    },
    dangerouslyUseHTMLString: {
      type: Boolean,
      default: messageDefaults.dangerouslyUseHTMLString
    },
    duration: {
      type: Number,
      default: messageDefaults.duration
    },
    icon: {
      type: iconPropType,
      default: messageDefaults.icon
    },
    id: {
      type: String,
      default: messageDefaults.id
    },
    message: {
      type: definePropType([
        String,
        Object,
        Function
      ]),
      default: messageDefaults.message
    },
    onClose: {
      type: definePropType(Function),
      default: messageDefaults.onClose
    },
    showClose: {
      type: Boolean,
      default: messageDefaults.showClose
    },
    type: {
      type: String,
      values: messageTypes,
      default: messageDefaults.type
    },
    plain: {
      type: Boolean,
      default: messageDefaults.plain
    },
    offset: {
      type: Number,
      default: messageDefaults.offset
    },
    placement: {
      type: String,
      values: messagePlacement,
      default: messageDefaults.placement
    },
    zIndex: {
      type: Number,
      default: messageDefaults.zIndex
    },
    grouping: {
      type: Boolean,
      default: messageDefaults.grouping
    },
    repeatNum: {
      type: Number,
      default: messageDefaults.repeatNum
    }
  });
  const messageEmits = {
    destroy: () => true
  };

  const placementInstances = vue.shallowReactive({});
  const getOrCreatePlacementInstances = (placement) => {
    if (!placementInstances[placement]) {
      placementInstances[placement] = vue.shallowReactive([]);
    }
    return placementInstances[placement];
  };
  const getInstance = (id, placement) => {
    const instances = placementInstances[placement] || [];
    const idx = instances.findIndex((instance) => instance.id === id);
    const current = instances[idx];
    let prev;
    if (idx > 0) {
      prev = instances[idx - 1];
    }
    return { current, prev };
  };
  const getLastOffset = (id, placement) => {
    const { prev } = getInstance(id, placement);
    if (!prev)
      return 0;
    return prev.vm.exposed.bottom.value;
  };
  const getOffsetOrSpace = (id, offset, placement) => {
    const instances = placementInstances[placement] || [];
    const idx = instances.findIndex((instance) => instance.id === id);
    return idx > 0 ? 16 : offset;
  };

  const __default__$1 = vue.defineComponent({
    name: "ElMessage"
  });
  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
    ...__default__$1,
    props: messageProps,
    emits: messageEmits,
    setup(__props, { expose, emit }) {
      const props = __props;
      const { Close } = TypeComponents;
      const isStartTransition = vue.ref(false);
      const { ns, zIndex } = useGlobalComponentSettings("message");
      const { currentZIndex, nextZIndex } = zIndex;
      const messageRef = vue.ref();
      const visible = vue.ref(false);
      const height = vue.ref(0);
      let stopTimer = void 0;
      const badgeType = vue.computed(() => props.type ? props.type === "error" ? "danger" : props.type : "info");
      const typeClass = vue.computed(() => {
        const type = props.type;
        return { [ns.bm("icon", type)]: type && TypeComponentsMap[type] };
      });
      const iconComponent = vue.computed(() => props.icon || TypeComponentsMap[props.type] || "");
      const placement = vue.computed(() => props.placement || MESSAGE_DEFAULT_PLACEMENT);
      const lastOffset = vue.computed(() => getLastOffset(props.id, placement.value));
      const offset = vue.computed(() => {
        return getOffsetOrSpace(props.id, props.offset, placement.value) + lastOffset.value;
      });
      const bottom = vue.computed(() => height.value + offset.value);
      const horizontalClass = vue.computed(() => {
        if (placement.value.includes("left"))
          return ns.is("left");
        if (placement.value.includes("right"))
          return ns.is("right");
        return ns.is("center");
      });
      const verticalProperty = vue.computed(() => placement.value.startsWith("top") ? "top" : "bottom");
      const customStyle = vue.computed(() => ({
        [verticalProperty.value]: `${offset.value}px`,
        zIndex: currentZIndex.value
      }));
      function startTimer() {
        if (props.duration === 0)
          return;
        ({ stop: stopTimer } = useTimeoutFn(() => {
          close();
        }, props.duration));
      }
      function clearTimer() {
        stopTimer == null ? void 0 : stopTimer();
      }
      function close() {
        visible.value = false;
        vue.nextTick(() => {
          var _a;
          if (!isStartTransition.value) {
            (_a = props.onClose) == null ? void 0 : _a.call(props);
            emit("destroy");
          }
        });
      }
      function keydown(event) {
        const code = getEventCode(event);
        if (code === EVENT_CODE.esc) {
          close();
        }
      }
      vue.onMounted(() => {
        startTimer();
        nextZIndex();
        visible.value = true;
      });
      vue.watch(() => props.repeatNum, () => {
        clearTimer();
        startTimer();
      });
      useEventListener(document, "keydown", keydown);
      useResizeObserver(messageRef, () => {
        height.value = messageRef.value.getBoundingClientRect().height;
      });
      expose({
        visible,
        bottom,
        close
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, {
          name: vue.unref(ns).b("fade"),
          onBeforeEnter: ($event) => isStartTransition.value = true,
          onBeforeLeave: _ctx.onClose,
          onAfterLeave: ($event) => _ctx.$emit("destroy"),
          persisted: ""
        }, {
          default: vue.withCtx(() => [
            vue.withDirectives(vue.createElementVNode("div", {
              id: _ctx.id,
              ref_key: "messageRef",
              ref: messageRef,
              class: vue.normalizeClass([
                vue.unref(ns).b(),
                { [vue.unref(ns).m(_ctx.type)]: _ctx.type },
                vue.unref(ns).is("closable", _ctx.showClose),
                vue.unref(ns).is("plain", _ctx.plain),
                vue.unref(ns).is("bottom", vue.unref(verticalProperty) === "bottom"),
                vue.unref(horizontalClass),
                _ctx.customClass
              ]),
              style: vue.normalizeStyle(vue.unref(customStyle)),
              role: "alert",
              onMouseenter: clearTimer,
              onMouseleave: startTimer
            }, [
              _ctx.repeatNum > 1 ? (vue.openBlock(), vue.createBlock(vue.unref(ElBadge), {
                key: 0,
                value: _ctx.repeatNum,
                type: vue.unref(badgeType),
                class: vue.normalizeClass(vue.unref(ns).e("badge"))
              }, null, 8, ["value", "type", "class"])) : vue.createCommentVNode("v-if", true),
              vue.unref(iconComponent) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 1,
                class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(typeClass)])
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
                ]),
                _: 1
              }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
              vue.renderSlot(_ctx.$slots, "default", {}, () => [
                !_ctx.dangerouslyUseHTMLString ? (vue.openBlock(), vue.createElementBlock("p", {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).e("content"))
                }, vue.toDisplayString(_ctx.message), 3)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                  vue.createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
                  vue.createElementVNode("p", {
                    class: vue.normalizeClass(vue.unref(ns).e("content")),
                    innerHTML: _ctx.message
                  }, null, 10, ["innerHTML"])
                ], 2112))
              ]),
              _ctx.showClose ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 2,
                class: vue.normalizeClass(vue.unref(ns).e("closeBtn")),
                onClick: vue.withModifiers(close, ["stop"])
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(vue.unref(Close))
                ]),
                _: 1
              }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
            ], 46, ["id"]), [
              [vue.vShow, visible.value]
            ])
          ]),
          _: 3
        }, 8, ["name", "onBeforeEnter", "onBeforeLeave", "onAfterLeave"]);
      };
    }
  });
  var MessageConstructor = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "message.vue"]]);

  let seed$1 = 1;
  const normalizeAppendTo = (normalized) => {
    const appendTo = normalized.appendTo;
    if (!appendTo) {
      normalized.appendTo = document.body;
    } else if (isString$1(normalized.appendTo)) {
      let appendTo2 = document.querySelector(normalized.appendTo);
      if (!isElement$2(appendTo2)) {
        debugWarn("ElMessage", "the appendTo option is not an HTMLElement. Falling back to document.body.");
        appendTo2 = document.body;
      }
      normalized.appendTo = appendTo2;
    }
  };
  const normalizePlacement = (normalized) => {
    if (!normalized.placement && isString$1(messageConfig.placement) && messageConfig.placement) {
      normalized.placement = messageConfig.placement;
    }
    if (!normalized.placement) {
      normalized.placement = MESSAGE_DEFAULT_PLACEMENT;
    }
    if (!messagePlacement.includes(normalized.placement)) {
      debugWarn("ElMessage", `Invalid placement: ${normalized.placement}. Falling back to '${MESSAGE_DEFAULT_PLACEMENT}'.`);
      normalized.placement = MESSAGE_DEFAULT_PLACEMENT;
    }
  };
  const normalizeOptions = (params) => {
    const options = !params || isString$1(params) || vue.isVNode(params) || isFunction$1(params) ? { message: params } : params;
    const normalized = {
      ...messageDefaults,
      ...options
    };
    normalizeAppendTo(normalized);
    normalizePlacement(normalized);
    if (isBoolean(messageConfig.grouping) && !normalized.grouping) {
      normalized.grouping = messageConfig.grouping;
    }
    if (isNumber(messageConfig.duration) && normalized.duration === 3e3) {
      normalized.duration = messageConfig.duration;
    }
    if (isNumber(messageConfig.offset) && normalized.offset === 16) {
      normalized.offset = messageConfig.offset;
    }
    if (isBoolean(messageConfig.showClose) && !normalized.showClose) {
      normalized.showClose = messageConfig.showClose;
    }
    if (isBoolean(messageConfig.plain) && !normalized.plain) {
      normalized.plain = messageConfig.plain;
    }
    return normalized;
  };
  const closeMessage = (instance) => {
    const placement = instance.props.placement || MESSAGE_DEFAULT_PLACEMENT;
    const instances = placementInstances[placement];
    const idx = instances.indexOf(instance);
    if (idx === -1)
      return;
    instances.splice(idx, 1);
    const { handler } = instance;
    handler.close();
  };
  const createMessage = ({ appendTo, ...options }, context) => {
    const id = `message_${seed$1++}`;
    const userOnClose = options.onClose;
    const container = document.createElement("div");
    const props = {
      ...options,
      id,
      onClose: () => {
        userOnClose == null ? void 0 : userOnClose();
        closeMessage(instance);
      },
      onDestroy: () => {
        vue.render(null, container);
      }
    };
    const vnode = vue.createVNode(MessageConstructor, props, isFunction$1(props.message) || vue.isVNode(props.message) ? {
      default: isFunction$1(props.message) ? props.message : () => props.message
    } : null);
    vnode.appContext = context || message._context;
    vue.render(vnode, container);
    appendTo.appendChild(container.firstElementChild);
    const vm = vnode.component;
    const handler = {
      close: () => {
        vm.exposed.close();
      }
    };
    const instance = {
      id,
      vnode,
      vm,
      handler,
      props: vnode.component.props
    };
    return instance;
  };
  const message = (options = {}, context) => {
    if (!isClient)
      return { close: () => void 0 };
    const normalized = normalizeOptions(options);
    const instances = getOrCreatePlacementInstances(normalized.placement || MESSAGE_DEFAULT_PLACEMENT);
    if (normalized.grouping && instances.length) {
      const instance2 = instances.find(({ vnode: vm }) => {
        var _a;
        return ((_a = vm.props) == null ? void 0 : _a.message) === normalized.message;
      });
      if (instance2) {
        instance2.props.repeatNum += 1;
        instance2.props.type = normalized.type;
        return instance2.handler;
      }
    }
    if (isNumber(messageConfig.max) && instances.length >= messageConfig.max) {
      return { close: () => void 0 };
    }
    const instance = createMessage(normalized, context);
    instances.push(instance);
    return instance.handler;
  };
  messageTypes.forEach((type) => {
    message[type] = (options = {}, appContext) => {
      const normalized = normalizeOptions(options);
      return message({ ...normalized, type }, appContext);
    };
  });
  function closeAll$1(type) {
    for (const placement in placementInstances) {
      if (hasOwn(placementInstances, placement)) {
        const instances = [...placementInstances[placement]];
        for (const instance of instances) {
          if (!type || type === instance.props.type) {
            instance.handler.close();
          }
        }
      }
    }
  }
  function closeAllByPlacement(placement) {
    if (!placementInstances[placement])
      return;
    const instances = [...placementInstances[placement]];
    instances.forEach((instance) => instance.handler.close());
  }
  message.closeAll = closeAll$1;
  message.closeAllByPlacement = closeAllByPlacement;
  message._context = null;
  var Message = message;

  const ElMessage = withInstallFunction(Message, "$message");

  const _sfc_main$1 = vue.defineComponent({
    name: "ElMessageBox",
    directives: {
      TrapFocus
    },
    components: {
      ElButton,
      ElFocusTrap,
      ElInput,
      ElOverlay,
      ElIcon,
      ...TypeComponents
    },
    inheritAttrs: false,
    props: {
      buttonSize: {
        type: String,
        validator: isValidComponentSize
      },
      modal: {
        type: Boolean,
        default: true
      },
      lockScroll: {
        type: Boolean,
        default: true
      },
      showClose: {
        type: Boolean,
        default: true
      },
      closeOnClickModal: {
        type: Boolean,
        default: true
      },
      closeOnPressEscape: {
        type: Boolean,
        default: true
      },
      closeOnHashChange: {
        type: Boolean,
        default: true
      },
      center: Boolean,
      draggable: Boolean,
      overflow: Boolean,
      roundButton: Boolean,
      container: {
        type: String,
        default: "body"
      },
      boxType: {
        type: String,
        default: ""
      }
    },
    emits: ["vanish", "action"],
    setup(props, { emit }) {
      const {
        locale,
        zIndex,
        ns,
        size: btnSize
      } = useGlobalComponentSettings("message-box", vue.computed(() => props.buttonSize));
      const { t } = locale;
      const { nextZIndex } = zIndex;
      const visible = vue.ref(false);
      const state = vue.reactive({
        autofocus: true,
        beforeClose: null,
        callback: null,
        cancelButtonText: "",
        cancelButtonClass: "",
        confirmButtonText: "",
        confirmButtonClass: "",
        customClass: "",
        customStyle: {},
        dangerouslyUseHTMLString: false,
        distinguishCancelAndClose: false,
        icon: "",
        closeIcon: "",
        inputPattern: null,
        inputPlaceholder: "",
        inputType: "text",
        inputValue: "",
        inputValidator: void 0,
        inputErrorMessage: "",
        message: "",
        modalFade: true,
        modalClass: "",
        showCancelButton: false,
        showConfirmButton: true,
        type: "",
        title: void 0,
        showInput: false,
        action: "",
        confirmButtonLoading: false,
        cancelButtonLoading: false,
        confirmButtonLoadingIcon: vue.markRaw(loading_default),
        cancelButtonLoadingIcon: vue.markRaw(loading_default),
        confirmButtonDisabled: false,
        editorErrorMessage: "",
        validateError: false,
        zIndex: nextZIndex()
      });
      const typeClass = vue.computed(() => {
        const type = state.type;
        return { [ns.bm("icon", type)]: type && TypeComponentsMap[type] };
      });
      const contentId = useId();
      const inputId = useId();
      const iconComponent = vue.computed(() => {
        const type = state.type;
        return state.icon || type && TypeComponentsMap[type] || "";
      });
      const hasMessage = vue.computed(() => !!state.message);
      const rootRef = vue.ref();
      const headerRef = vue.ref();
      const focusStartRef = vue.ref();
      const inputRef = vue.ref();
      const confirmRef = vue.ref();
      const confirmButtonClasses = vue.computed(() => state.confirmButtonClass);
      vue.watch(() => state.inputValue, async (val) => {
        await vue.nextTick();
        if (props.boxType === "prompt" && val) {
          validate();
        }
      }, { immediate: true });
      vue.watch(() => visible.value, (val) => {
        var _a, _b;
        if (val) {
          if (props.boxType !== "prompt") {
            if (state.autofocus) {
              focusStartRef.value = (_b = (_a = confirmRef.value) == null ? void 0 : _a.$el) != null ? _b : rootRef.value;
            } else {
              focusStartRef.value = rootRef.value;
            }
          }
          state.zIndex = nextZIndex();
        }
        if (props.boxType !== "prompt")
          return;
        if (val) {
          vue.nextTick().then(() => {
            var _a2;
            if (inputRef.value && inputRef.value.$el) {
              if (state.autofocus) {
                focusStartRef.value = (_a2 = getInputElement()) != null ? _a2 : rootRef.value;
              } else {
                focusStartRef.value = rootRef.value;
              }
            }
          });
        } else {
          state.editorErrorMessage = "";
          state.validateError = false;
        }
      });
      const draggable = vue.computed(() => props.draggable);
      const overflow = vue.computed(() => props.overflow);
      const { isDragging } = useDraggable(rootRef, headerRef, draggable, overflow);
      vue.onMounted(async () => {
        await vue.nextTick();
        if (props.closeOnHashChange) {
          window.addEventListener("hashchange", doClose);
        }
      });
      vue.onBeforeUnmount(() => {
        if (props.closeOnHashChange) {
          window.removeEventListener("hashchange", doClose);
        }
      });
      function doClose() {
        if (!visible.value)
          return;
        visible.value = false;
        vue.nextTick(() => {
          if (state.action)
            emit("action", state.action);
        });
      }
      const handleWrapperClick = () => {
        if (props.closeOnClickModal) {
          handleAction(state.distinguishCancelAndClose ? "close" : "cancel");
        }
      };
      const overlayEvent = useSameTarget(handleWrapperClick);
      const handleInputEnter = (e) => {
        if (state.inputType !== "textarea") {
          e.preventDefault();
          return handleAction("confirm");
        }
      };
      const handleAction = (action) => {
        var _a;
        if (props.boxType === "prompt" && action === "confirm" && !validate()) {
          return;
        }
        state.action = action;
        if (state.beforeClose) {
          (_a = state.beforeClose) == null ? void 0 : _a.call(state, action, state, doClose);
        } else {
          doClose();
        }
      };
      const validate = () => {
        if (props.boxType === "prompt") {
          const inputPattern = state.inputPattern;
          if (inputPattern && !inputPattern.test(state.inputValue || "")) {
            state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
            state.validateError = true;
            return false;
          }
          const inputValidator = state.inputValidator;
          if (isFunction$1(inputValidator)) {
            const validateResult = inputValidator(state.inputValue);
            if (validateResult === false) {
              state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
              state.validateError = true;
              return false;
            }
            if (isString$1(validateResult)) {
              state.editorErrorMessage = validateResult;
              state.validateError = true;
              return false;
            }
          }
        }
        state.editorErrorMessage = "";
        state.validateError = false;
        return true;
      };
      const getInputElement = () => {
        var _a, _b;
        const inputRefs = (_a = inputRef.value) == null ? void 0 : _a.$refs;
        return (_b = inputRefs == null ? void 0 : inputRefs.input) != null ? _b : inputRefs == null ? void 0 : inputRefs.textarea;
      };
      const handleClose = () => {
        handleAction("close");
      };
      const onCloseRequested = () => {
        if (props.closeOnPressEscape) {
          handleClose();
        }
      };
      if (props.lockScroll) {
        useLockscreen(visible, { ns });
      }
      return {
        ...vue.toRefs(state),
        ns,
        overlayEvent,
        visible,
        hasMessage,
        typeClass,
        contentId,
        inputId,
        btnSize,
        iconComponent,
        confirmButtonClasses,
        rootRef,
        focusStartRef,
        headerRef,
        inputRef,
        isDragging,
        confirmRef,
        doClose,
        handleClose,
        onCloseRequested,
        handleWrapperClick,
        handleInputEnter,
        handleAction,
        t
      };
    }
  });
  function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
    const _component_el_icon = vue.resolveComponent("el-icon");
    const _component_el_input = vue.resolveComponent("el-input");
    const _component_el_button = vue.resolveComponent("el-button");
    const _component_el_focus_trap = vue.resolveComponent("el-focus-trap");
    const _component_el_overlay = vue.resolveComponent("el-overlay");
    return vue.openBlock(), vue.createBlock(vue.Transition, {
      name: "fade-in-linear",
      onAfterLeave: ($event) => _ctx.$emit("vanish"),
      persisted: ""
    }, {
      default: vue.withCtx(() => [
        vue.withDirectives(vue.createVNode(_component_el_overlay, {
          "z-index": _ctx.zIndex,
          "overlay-class": [_ctx.ns.is("message-box"), _ctx.modalClass],
          mask: _ctx.modal
        }, {
          default: vue.withCtx(() => [
            vue.createElementVNode("div", {
              role: "dialog",
              "aria-label": _ctx.title,
              "aria-modal": "true",
              "aria-describedby": !_ctx.showInput ? _ctx.contentId : void 0,
              class: vue.normalizeClass(`${_ctx.ns.namespace.value}-overlay-message-box`),
              onClick: _ctx.overlayEvent.onClick,
              onMousedown: _ctx.overlayEvent.onMousedown,
              onMouseup: _ctx.overlayEvent.onMouseup
            }, [
              vue.createVNode(_component_el_focus_trap, {
                loop: "",
                trapped: _ctx.visible,
                "focus-trap-el": _ctx.rootRef,
                "focus-start-el": _ctx.focusStartRef,
                onReleaseRequested: _ctx.onCloseRequested
              }, {
                default: vue.withCtx(() => [
                  vue.createElementVNode("div", {
                    ref: "rootRef",
                    class: vue.normalizeClass([
                      _ctx.ns.b(),
                      _ctx.customClass,
                      _ctx.ns.is("draggable", _ctx.draggable),
                      _ctx.ns.is("dragging", _ctx.isDragging),
                      { [_ctx.ns.m("center")]: _ctx.center }
                    ]),
                    style: vue.normalizeStyle(_ctx.customStyle),
                    tabindex: "-1",
                    onClick: vue.withModifiers(() => {
                    }, ["stop"])
                  }, [
                    _ctx.title !== null && _ctx.title !== void 0 ? (vue.openBlock(), vue.createElementBlock("div", {
                      key: 0,
                      ref: "headerRef",
                      class: vue.normalizeClass([_ctx.ns.e("header"), { "show-close": _ctx.showClose }])
                    }, [
                      vue.createElementVNode("div", {
                        class: vue.normalizeClass(_ctx.ns.e("title"))
                      }, [
                        _ctx.iconComponent && _ctx.center ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                          key: 0,
                          class: vue.normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
                        }, {
                          default: vue.withCtx(() => [
                            (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                          ]),
                          _: 1
                        }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                        vue.createElementVNode("span", null, vue.toDisplayString(_ctx.title), 1)
                      ], 2),
                      _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("button", {
                        key: 0,
                        type: "button",
                        class: vue.normalizeClass(_ctx.ns.e("headerbtn")),
                        "aria-label": _ctx.t("el.messagebox.close"),
                        onClick: ($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel"),
                        onKeydown: vue.withKeys(vue.withModifiers(($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel"), ["prevent"]), ["enter"])
                      }, [
                        vue.createVNode(_component_el_icon, {
                          class: vue.normalizeClass(_ctx.ns.e("close"))
                        }, {
                          default: vue.withCtx(() => [
                            (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.closeIcon || "close")))
                          ]),
                          _: 1
                        }, 8, ["class"])
                      ], 42, ["aria-label", "onClick", "onKeydown"])) : vue.createCommentVNode("v-if", true)
                    ], 2)) : vue.createCommentVNode("v-if", true),
                    vue.createElementVNode("div", {
                      id: _ctx.contentId,
                      class: vue.normalizeClass(_ctx.ns.e("content"))
                    }, [
                      vue.createElementVNode("div", {
                        class: vue.normalizeClass(_ctx.ns.e("container"))
                      }, [
                        _ctx.iconComponent && !_ctx.center && _ctx.hasMessage ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                          key: 0,
                          class: vue.normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
                        }, {
                          default: vue.withCtx(() => [
                            (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                          ]),
                          _: 1
                        }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                        _ctx.hasMessage ? (vue.openBlock(), vue.createElementBlock("div", {
                          key: 1,
                          class: vue.normalizeClass(_ctx.ns.e("message"))
                        }, [
                          vue.renderSlot(_ctx.$slots, "default", {}, () => [
                            !_ctx.dangerouslyUseHTMLString ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
                              key: 0,
                              for: _ctx.showInput ? _ctx.inputId : void 0,
                              textContent: vue.toDisplayString(_ctx.message)
                            }, null, 8, ["for", "textContent"])) : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
                              key: 1,
                              for: _ctx.showInput ? _ctx.inputId : void 0,
                              innerHTML: _ctx.message
                            }, null, 8, ["for", "innerHTML"]))
                          ])
                        ], 2)) : vue.createCommentVNode("v-if", true)
                      ], 2),
                      vue.withDirectives(vue.createElementVNode("div", {
                        class: vue.normalizeClass(_ctx.ns.e("input"))
                      }, [
                        vue.createVNode(_component_el_input, {
                          id: _ctx.inputId,
                          ref: "inputRef",
                          modelValue: _ctx.inputValue,
                          "onUpdate:modelValue": ($event) => _ctx.inputValue = $event,
                          type: _ctx.inputType,
                          placeholder: _ctx.inputPlaceholder,
                          "aria-invalid": _ctx.validateError,
                          class: vue.normalizeClass({ invalid: _ctx.validateError }),
                          onKeydown: vue.withKeys(_ctx.handleInputEnter, ["enter"])
                        }, null, 8, ["id", "modelValue", "onUpdate:modelValue", "type", "placeholder", "aria-invalid", "class", "onKeydown"]),
                        vue.createElementVNode("div", {
                          class: vue.normalizeClass(_ctx.ns.e("errormsg")),
                          style: vue.normalizeStyle({
                            visibility: !!_ctx.editorErrorMessage ? "visible" : "hidden"
                          })
                        }, vue.toDisplayString(_ctx.editorErrorMessage), 7)
                      ], 2), [
                        [vue.vShow, _ctx.showInput]
                      ])
                    ], 10, ["id"]),
                    vue.createElementVNode("div", {
                      class: vue.normalizeClass(_ctx.ns.e("btns"))
                    }, [
                      _ctx.showCancelButton ? (vue.openBlock(), vue.createBlock(_component_el_button, {
                        key: 0,
                        loading: _ctx.cancelButtonLoading,
                        "loading-icon": _ctx.cancelButtonLoadingIcon,
                        class: vue.normalizeClass([_ctx.cancelButtonClass]),
                        round: _ctx.roundButton,
                        size: _ctx.btnSize,
                        onClick: ($event) => _ctx.handleAction("cancel"),
                        onKeydown: vue.withKeys(vue.withModifiers(($event) => _ctx.handleAction("cancel"), ["prevent"]), ["enter"])
                      }, {
                        default: vue.withCtx(() => [
                          vue.createTextVNode(vue.toDisplayString(_ctx.cancelButtonText || _ctx.t("el.messagebox.cancel")), 1)
                        ]),
                        _: 1
                      }, 8, ["loading", "loading-icon", "class", "round", "size", "onClick", "onKeydown"])) : vue.createCommentVNode("v-if", true),
                      vue.withDirectives(vue.createVNode(_component_el_button, {
                        ref: "confirmRef",
                        type: "primary",
                        loading: _ctx.confirmButtonLoading,
                        "loading-icon": _ctx.confirmButtonLoadingIcon,
                        class: vue.normalizeClass([_ctx.confirmButtonClasses]),
                        round: _ctx.roundButton,
                        disabled: _ctx.confirmButtonDisabled,
                        size: _ctx.btnSize,
                        onClick: ($event) => _ctx.handleAction("confirm"),
                        onKeydown: vue.withKeys(vue.withModifiers(($event) => _ctx.handleAction("confirm"), ["prevent"]), ["enter"])
                      }, {
                        default: vue.withCtx(() => [
                          vue.createTextVNode(vue.toDisplayString(_ctx.confirmButtonText || _ctx.t("el.messagebox.confirm")), 1)
                        ]),
                        _: 1
                      }, 8, ["loading", "loading-icon", "class", "round", "disabled", "size", "onClick", "onKeydown"]), [
                        [vue.vShow, _ctx.showConfirmButton]
                      ])
                    ], 2)
                  ], 14, ["onClick"])
                ]),
                _: 3
              }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onReleaseRequested"])
            ], 42, ["aria-label", "aria-describedby", "onClick", "onMousedown", "onMouseup"])
          ]),
          _: 3
        }, 8, ["z-index", "overlay-class", "mask"]), [
          [vue.vShow, _ctx.visible]
        ])
      ]),
      _: 3
    }, 8, ["onAfterLeave"]);
  }
  var MessageBoxConstructor = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render], ["__file", "index.vue"]]);

  const messageInstance = /* @__PURE__ */ new Map();
  const getAppendToElement = (props) => {
    let appendTo = document.body;
    if (props.appendTo) {
      if (isString$1(props.appendTo)) {
        appendTo = document.querySelector(props.appendTo);
      }
      if (isElement$2(props.appendTo)) {
        appendTo = props.appendTo;
      }
      if (!isElement$2(appendTo)) {
        debugWarn("ElMessageBox", "the appendTo option is not an HTMLElement. Falling back to document.body.");
        appendTo = document.body;
      }
    }
    return appendTo;
  };
  const initInstance = (props, container, appContext = null) => {
    const vnode = vue.createVNode(MessageBoxConstructor, props, isFunction$1(props.message) || vue.isVNode(props.message) ? {
      default: isFunction$1(props.message) ? props.message : () => props.message
    } : null);
    vnode.appContext = appContext;
    vue.render(vnode, container);
    getAppendToElement(props).appendChild(container.firstElementChild);
    return vnode.component;
  };
  const genContainer = () => {
    return document.createElement("div");
  };
  const showMessage = (options, appContext) => {
    const container = genContainer();
    options.onVanish = () => {
      vue.render(null, container);
      messageInstance.delete(vm);
    };
    options.onAction = (action) => {
      const currentMsg = messageInstance.get(vm);
      let resolve;
      if (options.showInput) {
        resolve = { value: vm.inputValue, action };
      } else {
        resolve = action;
      }
      if (options.callback) {
        options.callback(resolve, instance.proxy);
      } else {
        if (action === "cancel" || action === "close") {
          if (options.distinguishCancelAndClose && action !== "cancel") {
            currentMsg.reject("close");
          } else {
            currentMsg.reject("cancel");
          }
        } else {
          currentMsg.resolve(resolve);
        }
      }
    };
    const instance = initInstance(options, container, appContext);
    const vm = instance.proxy;
    for (const prop in options) {
      if (hasOwn(options, prop) && !hasOwn(vm.$props, prop)) {
        if (prop === "closeIcon" && isObject$1(options[prop])) {
          vm[prop] = vue.markRaw(options[prop]);
        } else {
          vm[prop] = options[prop];
        }
      }
    }
    vm.visible = true;
    return vm;
  };
  function MessageBox(options, appContext = null) {
    if (!isClient)
      return Promise.reject();
    let callback;
    if (isString$1(options) || vue.isVNode(options)) {
      options = {
        message: options
      };
    } else {
      callback = options.callback;
    }
    return new Promise((resolve, reject) => {
      const vm = showMessage(options, appContext != null ? appContext : MessageBox._context);
      messageInstance.set(vm, {
        options,
        callback,
        resolve,
        reject
      });
    });
  }
  const MESSAGE_BOX_VARIANTS = ["alert", "confirm", "prompt"];
  const MESSAGE_BOX_DEFAULT_OPTS = {
    alert: { closeOnPressEscape: false, closeOnClickModal: false },
    confirm: { showCancelButton: true },
    prompt: { showCancelButton: true, showInput: true }
  };
  MESSAGE_BOX_VARIANTS.forEach((boxType) => {
    MessageBox[boxType] = messageBoxFactory(boxType);
  });
  function messageBoxFactory(boxType) {
    return (message, title, options, appContext) => {
      let titleOrOpts = "";
      if (isObject$1(title)) {
        options = title;
        titleOrOpts = "";
      } else if (isUndefined(title)) {
        titleOrOpts = "";
      } else {
        titleOrOpts = title;
      }
      return MessageBox(Object.assign({
        title: titleOrOpts,
        message,
        type: "",
        ...MESSAGE_BOX_DEFAULT_OPTS[boxType]
      }, options, {
        boxType
      }), appContext);
    };
  }
  MessageBox.close = () => {
    messageInstance.forEach((_, vm) => {
      vm.doClose();
    });
    messageInstance.clear();
  };
  MessageBox._context = null;

  const _MessageBox = MessageBox;
  _MessageBox.install = (app) => {
    _MessageBox._context = app._context;
    app.config.globalProperties.$msgbox = _MessageBox;
    app.config.globalProperties.$messageBox = _MessageBox;
    app.config.globalProperties.$alert = _MessageBox.alert;
    app.config.globalProperties.$confirm = _MessageBox.confirm;
    app.config.globalProperties.$prompt = _MessageBox.prompt;
  };
  const ElMessageBox = _MessageBox;

  const notificationTypes = [
    "primary",
    "success",
    "info",
    "warning",
    "error"
  ];
  const notificationProps = buildProps({
    customClass: {
      type: String,
      default: ""
    },
    dangerouslyUseHTMLString: Boolean,
    duration: {
      type: Number,
      default: 4500
    },
    icon: {
      type: iconPropType
    },
    id: {
      type: String,
      default: ""
    },
    message: {
      type: definePropType([
        String,
        Object,
        Function
      ]),
      default: ""
    },
    offset: {
      type: Number,
      default: 0
    },
    onClick: {
      type: definePropType(Function),
      default: () => void 0
    },
    onClose: {
      type: definePropType(Function),
      required: true
    },
    position: {
      type: String,
      values: ["top-right", "top-left", "bottom-right", "bottom-left"],
      default: "top-right"
    },
    showClose: {
      type: Boolean,
      default: true
    },
    title: {
      type: String,
      default: ""
    },
    type: {
      type: String,
      values: [...notificationTypes, ""],
      default: ""
    },
    zIndex: Number,
    closeIcon: {
      type: iconPropType,
      default: close_default
    }
  });
  const notificationEmits = {
    destroy: () => true
  };

  const __default__ = vue.defineComponent({
    name: "ElNotification"
  });
  const _sfc_main = /* @__PURE__ */ vue.defineComponent({
    ...__default__,
    props: notificationProps,
    emits: notificationEmits,
    setup(__props, { expose }) {
      const props = __props;
      const { ns, zIndex } = useGlobalComponentSettings("notification");
      const { nextZIndex, currentZIndex } = zIndex;
      const visible = vue.ref(false);
      let timer = void 0;
      const typeClass = vue.computed(() => {
        const type = props.type;
        return type && TypeComponentsMap[props.type] ? ns.m(type) : "";
      });
      const iconComponent = vue.computed(() => {
        if (!props.type)
          return props.icon;
        return TypeComponentsMap[props.type] || props.icon;
      });
      const horizontalClass = vue.computed(() => props.position.endsWith("right") ? "right" : "left");
      const verticalProperty = vue.computed(() => props.position.startsWith("top") ? "top" : "bottom");
      const positionStyle = vue.computed(() => {
        var _a;
        return {
          [verticalProperty.value]: `${props.offset}px`,
          zIndex: (_a = props.zIndex) != null ? _a : currentZIndex.value
        };
      });
      function startTimer() {
        if (props.duration > 0) {
          ({ stop: timer } = useTimeoutFn(() => {
            if (visible.value)
              close();
          }, props.duration));
        }
      }
      function clearTimer() {
        timer == null ? void 0 : timer();
      }
      function close() {
        visible.value = false;
      }
      function onKeydown(event) {
        const code = getEventCode(event);
        switch (code) {
          case EVENT_CODE.delete:
          case EVENT_CODE.backspace:
            clearTimer();
            break;
          case EVENT_CODE.esc:
            if (visible.value) {
              close();
            }
            break;
          default:
            startTimer();
            break;
        }
      }
      vue.onMounted(() => {
        startTimer();
        nextZIndex();
        visible.value = true;
      });
      useEventListener(document, "keydown", onKeydown);
      expose({
        visible,
        close
      });
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createBlock(vue.Transition, {
          name: vue.unref(ns).b("fade"),
          onBeforeLeave: _ctx.onClose,
          onAfterLeave: ($event) => _ctx.$emit("destroy"),
          persisted: ""
        }, {
          default: vue.withCtx(() => [
            vue.withDirectives(vue.createElementVNode("div", {
              id: _ctx.id,
              class: vue.normalizeClass([vue.unref(ns).b(), _ctx.customClass, vue.unref(horizontalClass)]),
              style: vue.normalizeStyle(vue.unref(positionStyle)),
              role: "alert",
              onMouseenter: clearTimer,
              onMouseleave: startTimer,
              onClick: _ctx.onClick
            }, [
              vue.unref(iconComponent) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(typeClass)])
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
                ]),
                _: 1
              }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("group"))
              }, [
                vue.createElementVNode("h2", {
                  class: vue.normalizeClass(vue.unref(ns).e("title")),
                  textContent: vue.toDisplayString(_ctx.title)
                }, null, 10, ["textContent"]),
                vue.withDirectives(vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("content")),
                  style: vue.normalizeStyle(!!_ctx.title ? void 0 : { margin: 0 })
                }, [
                  vue.renderSlot(_ctx.$slots, "default", {}, () => [
                    !_ctx.dangerouslyUseHTMLString ? (vue.openBlock(), vue.createElementBlock("p", { key: 0 }, vue.toDisplayString(_ctx.message), 1)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                      vue.createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
                      vue.createElementVNode("p", { innerHTML: _ctx.message }, null, 8, ["innerHTML"])
                    ], 2112))
                  ])
                ], 6), [
                  [vue.vShow, _ctx.message]
                ]),
                _ctx.showClose ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).e("closeBtn")),
                  onClick: vue.withModifiers(close, ["stop"])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.closeIcon)))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
              ], 2)
            ], 46, ["id", "onClick"]), [
              [vue.vShow, visible.value]
            ])
          ]),
          _: 3
        }, 8, ["name", "onBeforeLeave", "onAfterLeave"]);
      };
    }
  });
  var NotificationConstructor = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "notification.vue"]]);

  const notifications = {
    "top-left": [],
    "top-right": [],
    "bottom-left": [],
    "bottom-right": []
  };
  const GAP_SIZE = 16;
  let seed = 1;
  const notify = function(options = {}, context) {
    if (!isClient)
      return { close: () => void 0 };
    if (isString$1(options) || vue.isVNode(options)) {
      options = { message: options };
    }
    const position = options.position || "top-right";
    let verticalOffset = options.offset || 0;
    notifications[position].forEach(({ vm: vm2 }) => {
      var _a;
      verticalOffset += (((_a = vm2.el) == null ? void 0 : _a.offsetHeight) || 0) + GAP_SIZE;
    });
    verticalOffset += GAP_SIZE;
    const id = `notification_${seed++}`;
    const userOnClose = options.onClose;
    const props = {
      ...options,
      offset: verticalOffset,
      id,
      onClose: () => {
        close(id, position, userOnClose);
      }
    };
    let appendTo = document.body;
    if (isElement$2(options.appendTo)) {
      appendTo = options.appendTo;
    } else if (isString$1(options.appendTo)) {
      appendTo = document.querySelector(options.appendTo);
    }
    if (!isElement$2(appendTo)) {
      debugWarn("ElNotification", "the appendTo option is not an HTMLElement. Falling back to document.body.");
      appendTo = document.body;
    }
    const container = document.createElement("div");
    const vm = vue.createVNode(NotificationConstructor, props, isFunction$1(props.message) ? props.message : vue.isVNode(props.message) ? () => props.message : null);
    vm.appContext = isUndefined(context) ? notify._context : context;
    vm.props.onDestroy = () => {
      vue.render(null, container);
    };
    vue.render(vm, container);
    notifications[position].push({ vm });
    appendTo.appendChild(container.firstElementChild);
    return {
      close: () => {
        vm.component.exposed.visible.value = false;
      }
    };
  };
  notificationTypes.forEach((type) => {
    notify[type] = (options = {}, appContext) => {
      if (isString$1(options) || vue.isVNode(options)) {
        options = {
          message: options
        };
      }
      return notify({ ...options, type }, appContext);
    };
  });
  function close(id, position, userOnClose) {
    const orientedNotifications = notifications[position];
    const idx = orientedNotifications.findIndex(({ vm: vm2 }) => {
      var _a;
      return ((_a = vm2.component) == null ? void 0 : _a.props.id) === id;
    });
    if (idx === -1)
      return;
    const { vm } = orientedNotifications[idx];
    if (!vm)
      return;
    userOnClose == null ? void 0 : userOnClose(vm);
    const removedHeight = vm.el.offsetHeight;
    const verticalPos = position.split("-")[0];
    orientedNotifications.splice(idx, 1);
    const len = orientedNotifications.length;
    if (len < 1)
      return;
    for (let i = idx; i < len; i++) {
      const { el, component } = orientedNotifications[i].vm;
      const pos = Number.parseInt(el.style[verticalPos], 10) - removedHeight - GAP_SIZE;
      component.props.offset = pos;
    }
  }
  function closeAll() {
    for (const orientedNotifications of Object.values(notifications)) {
      orientedNotifications.forEach(({ vm }) => {
        vm.component.exposed.visible.value = false;
      });
    }
  }
  function updateOffsets(position = "top-right") {
    var _a, _b, _c, _d;
    let verticalOffset = ((_c = (_b = (_a = notifications[position][0]) == null ? void 0 : _a.vm.component) == null ? void 0 : _b.props) == null ? void 0 : _c.offset) || 0;
    for (const { vm } of notifications[position]) {
      vm.component.props.offset = verticalOffset;
      verticalOffset += (((_d = vm.el) == null ? void 0 : _d.offsetHeight) || 0) + GAP_SIZE;
    }
  }
  notify.closeAll = closeAll;
  notify.updateOffsets = updateOffsets;
  notify._context = null;
  var Notify = notify;

  const ElNotification = withInstallFunction(Notify, "$notify");

  var Plugins = [
    ElInfiniteScroll,
    ElLoading,
    ElMessage,
    ElMessageBox,
    ElNotification,
    ElPopoverDirective
  ];

  var installer = makeInstaller([...Components, ...Plugins]);

  const install = installer.install;
  const version = installer.version;

  exports.BAR_MAP = BAR_MAP;
  exports.BORDER_HORIZONTAL_WIDTH = BORDER_HORIZONTAL_WIDTH;
  exports.CAROUSEL_ITEM_NAME = CAROUSEL_ITEM_NAME;
  exports.CASCADER_PANEL_INJECTION_KEY = CASCADER_PANEL_INJECTION_KEY;
  exports.CHANGE_EVENT = CHANGE_EVENT;
  exports.ClickOutside = ClickOutside;
  exports.CommonPicker = CommonPicker;
  exports.CommonProps = CommonProps;
  exports.DEFAULT_DIALOG_TRANSITION = DEFAULT_DIALOG_TRANSITION;
  exports.DEFAULT_EMPTY_VALUES = DEFAULT_EMPTY_VALUES;
  exports.DEFAULT_FORMATS_DATE = DEFAULT_FORMATS_DATE;
  exports.DEFAULT_FORMATS_DATEPICKER = DEFAULT_FORMATS_DATEPICKER;
  exports.DEFAULT_FORMATS_TIME = DEFAULT_FORMATS_TIME;
  exports.DEFAULT_VALUE_ON_CLEAR = DEFAULT_VALUE_ON_CLEAR;
  exports.DROPDOWN_INJECTION_KEY = DROPDOWN_INJECTION_KEY;
  exports.DROPDOWN_INSTANCE_INJECTION_KEY = DROPDOWN_INSTANCE_INJECTION_KEY;
  exports.DefaultProps = DefaultProps;
  exports.DynamicSizeGrid = DynamicSizeGrid$1;
  exports.DynamicSizeList = DynamicSizeList$1;
  exports.EVENT_CODE = EVENT_CODE;
  exports.Effect = Effect;
  exports.ElAffix = ElAffix;
  exports.ElAlert = ElAlert;
  exports.ElAnchor = ElAnchor;
  exports.ElAnchorLink = ElAnchorLink;
  exports.ElAside = ElAside;
  exports.ElAutoResizer = ElAutoResizer;
  exports.ElAutocomplete = ElAutocomplete;
  exports.ElAvatar = ElAvatar;
  exports.ElBacktop = ElBacktop;
  exports.ElBadge = ElBadge;
  exports.ElBreadcrumb = ElBreadcrumb;
  exports.ElBreadcrumbItem = ElBreadcrumbItem;
  exports.ElButton = ElButton;
  exports.ElButtonGroup = ElButtonGroup$1;
  exports.ElCalendar = ElCalendar;
  exports.ElCard = ElCard;
  exports.ElCarousel = ElCarousel;
  exports.ElCarouselItem = ElCarouselItem;
  exports.ElCascader = ElCascader;
  exports.ElCascaderPanel = ElCascaderPanel;
  exports.ElCheckTag = ElCheckTag;
  exports.ElCheckbox = ElCheckbox;
  exports.ElCheckboxButton = ElCheckboxButton;
  exports.ElCheckboxGroup = ElCheckboxGroup$1;
  exports.ElCol = ElCol;
  exports.ElCollapse = ElCollapse;
  exports.ElCollapseItem = ElCollapseItem;
  exports.ElCollapseTransition = ElCollapseTransition;
  exports.ElColorPicker = ElColorPicker;
  exports.ElColorPickerPanel = ElColorPickerPanel;
  exports.ElConfigProvider = ElConfigProvider;
  exports.ElContainer = ElContainer;
  exports.ElCountdown = ElCountdown;
  exports.ElDatePicker = ElDatePicker;
  exports.ElDatePickerPanel = ElDatePickerPanel;
  exports.ElDescriptions = ElDescriptions;
  exports.ElDescriptionsItem = ElDescriptionsItem;
  exports.ElDialog = ElDialog;
  exports.ElDivider = ElDivider;
  exports.ElDrawer = ElDrawer;
  exports.ElDropdown = ElDropdown;
  exports.ElDropdownItem = ElDropdownItem;
  exports.ElDropdownMenu = ElDropdownMenu;
  exports.ElEmpty = ElEmpty;
  exports.ElFooter = ElFooter;
  exports.ElForm = ElForm;
  exports.ElFormItem = ElFormItem;
  exports.ElHeader = ElHeader;
  exports.ElIcon = ElIcon;
  exports.ElImage = ElImage;
  exports.ElImageViewer = ElImageViewer;
  exports.ElInfiniteScroll = ElInfiniteScroll;
  exports.ElInput = ElInput;
  exports.ElInputNumber = ElInputNumber;
  exports.ElInputTag = ElInputTag;
  exports.ElLink = ElLink;
  exports.ElLoading = ElLoading;
  exports.ElLoadingDirective = vLoading$1;
  exports.ElLoadingService = Loading$1;
  exports.ElMain = ElMain;
  exports.ElMention = ElMention;
  exports.ElMenu = ElMenu;
  exports.ElMenuItem = ElMenuItem;
  exports.ElMenuItemGroup = ElMenuItemGroup;
  exports.ElMessage = ElMessage;
  exports.ElMessageBox = ElMessageBox;
  exports.ElNotification = ElNotification;
  exports.ElOption = ElOption;
  exports.ElOptionGroup = ElOptionGroup;
  exports.ElOverlay = ElOverlay;
  exports.ElPageHeader = ElPageHeader;
  exports.ElPagination = ElPagination;
  exports.ElPopconfirm = ElPopconfirm;
  exports.ElPopover = ElPopover;
  exports.ElPopoverDirective = ElPopoverDirective;
  exports.ElPopper = ElPopper;
  exports.ElPopperArrow = ElPopperArrow;
  exports.ElPopperContent = ElPopperContent;
  exports.ElPopperTrigger = ElPopperTrigger;
  exports.ElProgress = ElProgress;
  exports.ElRadio = ElRadio;
  exports.ElRadioButton = ElRadioButton;
  exports.ElRadioGroup = ElRadioGroup;
  exports.ElRate = ElRate;
  exports.ElResult = ElResult;
  exports.ElRow = ElRow;
  exports.ElScrollbar = ElScrollbar;
  exports.ElSegmented = ElSegmented;
  exports.ElSelect = ElSelect;
  exports.ElSelectV2 = ElSelectV2;
  exports.ElSkeleton = ElSkeleton;
  exports.ElSkeletonItem = ElSkeletonItem;
  exports.ElSlider = ElSlider;
  exports.ElSpace = ElSpace;
  exports.ElSplitter = ElSplitter;
  exports.ElSplitterPanel = ElSplitterPanel;
  exports.ElStatistic = ElStatistic;
  exports.ElStep = ElStep;
  exports.ElSteps = ElSteps;
  exports.ElSubMenu = ElSubMenu;
  exports.ElSwitch = ElSwitch;
  exports.ElTabPane = ElTabPane;
  exports.ElTable = ElTable;
  exports.ElTableColumn = ElTableColumn;
  exports.ElTableV2 = ElTableV2;
  exports.ElTabs = ElTabs;
  exports.ElTag = ElTag;
  exports.ElText = ElText;
  exports.ElTimePicker = ElTimePicker;
  exports.ElTimeSelect = ElTimeSelect;
  exports.ElTimeline = ElTimeline;
  exports.ElTimelineItem = ElTimelineItem;
  exports.ElTooltip = ElTooltip;
  exports.ElTour = ElTour;
  exports.ElTourStep = ElTourStep;
  exports.ElTransfer = ElTransfer;
  exports.ElTree = ElTree;
  exports.ElTreeSelect = ElTreeSelect;
  exports.ElTreeV2 = ElTreeV2;
  exports.ElUpload = ElUpload;
  exports.ElWatermark = ElWatermark;
  exports.FIRST_KEYS = FIRST_KEYS;
  exports.FIRST_LAST_KEYS = FIRST_LAST_KEYS;
  exports.FORWARD_REF_INJECTION_KEY = FORWARD_REF_INJECTION_KEY;
  exports.FixedSizeGrid = FixedSizeGrid$1;
  exports.FixedSizeList = FixedSizeList$1;
  exports.GAP = GAP;
  exports.ID_INJECTION_KEY = ID_INJECTION_KEY;
  exports.INPUT_EVENT = INPUT_EVENT;
  exports.INSTALLED_KEY = INSTALLED_KEY;
  exports.IconComponentMap = IconComponentMap;
  exports.IconMap = IconMap;
  exports.LAST_KEYS = LAST_KEYS;
  exports.LEFT_CHECK_CHANGE_EVENT = LEFT_CHECK_CHANGE_EVENT;
  exports.MENU_INJECTION_KEY = MENU_INJECTION_KEY;
  exports.MESSAGE_DEFAULT_PLACEMENT = MESSAGE_DEFAULT_PLACEMENT;
  exports.MINIMUM_INPUT_WIDTH = MINIMUM_INPUT_WIDTH;
  exports.Mousewheel = Mousewheel;
  exports.NODE_INSTANCE_INJECTION_KEY = NODE_INSTANCE_INJECTION_KEY;
  exports.PICKER_BASE_INJECTION_KEY = PICKER_BASE_INJECTION_KEY;
  exports.PICKER_POPPER_OPTIONS_INJECTION_KEY = PICKER_POPPER_OPTIONS_INJECTION_KEY;
  exports.POPPER_CONTENT_INJECTION_KEY = POPPER_CONTENT_INJECTION_KEY;
  exports.POPPER_INJECTION_KEY = POPPER_INJECTION_KEY;
  exports.RIGHT_CHECK_CHANGE_EVENT = RIGHT_CHECK_CHANGE_EVENT;
  exports.ROOT_COMMON_COLOR_INJECTION_KEY = ROOT_COMMON_COLOR_INJECTION_KEY;
  exports.ROOT_COMMON_PICKER_INJECTION_KEY = ROOT_COMMON_PICKER_INJECTION_KEY;
  exports.ROOT_PICKER_INJECTION_KEY = ROOT_PICKER_INJECTION_KEY;
  exports.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY;
  exports.ROOT_TREE_INJECTION_KEY = ROOT_TREE_INJECTION_KEY$1;
  exports.RowAlign = RowAlign;
  exports.RowJustify = RowJustify;
  exports.SCOPE = SCOPE$7;
  exports.SIZE_INJECTION_KEY = SIZE_INJECTION_KEY;
  exports.STEPS_INJECTION_KEY = STEPS_INJECTION_KEY;
  exports.SUB_MENU_INJECTION_KEY = SUB_MENU_INJECTION_KEY;
  exports.TIMELINE_INJECTION_KEY = TIMELINE_INJECTION_KEY;
  exports.TOOLTIP_INJECTION_KEY = TOOLTIP_INJECTION_KEY;
  exports.TREE_NODE_MAP_INJECTION_KEY = TREE_NODE_MAP_INJECTION_KEY;
  exports.TableV2 = TableV2$1;
  exports.TableV2Alignment = Alignment;
  exports.TableV2FixedDir = FixedDir;
  exports.TableV2Placeholder = placeholderSign;
  exports.TableV2SortOrder = SortOrder;
  exports.TimePickPanel = TimePickPanel;
  exports.TrapFocus = TrapFocus;
  exports.UPDATE_MODEL_EVENT = UPDATE_MODEL_EVENT;
  exports.WEEK_DAYS = WEEK_DAYS;
  exports.ZINDEX_INJECTION_KEY = ZINDEX_INJECTION_KEY;
  exports.affixEmits = affixEmits;
  exports.affixProps = affixProps;
  exports.alertEffects = alertEffects;
  exports.alertEmits = alertEmits;
  exports.alertProps = alertProps;
  exports.anchorEmits = anchorEmits;
  exports.anchorProps = anchorProps;
  exports.ariaProps = ariaProps;
  exports.arrowMiddleware = arrowMiddleware;
  exports.autoResizerProps = autoResizerProps;
  exports.autocompleteEmits = autocompleteEmits;
  exports.autocompleteProps = autocompleteProps;
  exports.avatarEmits = avatarEmits;
  exports.avatarProps = avatarProps;
  exports.backtopEmits = backtopEmits;
  exports.backtopProps = backtopProps;
  exports.badgeProps = badgeProps;
  exports.breadcrumbItemProps = breadcrumbItemProps;
  exports.breadcrumbKey = breadcrumbKey;
  exports.breadcrumbProps = breadcrumbProps;
  exports.buildLocaleContext = buildLocaleContext;
  exports.buildTimeList = buildTimeList;
  exports.buildTranslator = buildTranslator;
  exports.buttonEmits = buttonEmits;
  exports.buttonGroupContextKey = buttonGroupContextKey;
  exports.buttonNativeTypes = buttonNativeTypes;
  exports.buttonProps = buttonProps;
  exports.buttonTypes = buttonTypes;
  exports.calendarEmits = calendarEmits;
  exports.calendarProps = calendarProps;
  exports.cardContextKey = cardContextKey;
  exports.cardProps = cardProps;
  exports.carouselContextKey = carouselContextKey;
  exports.carouselEmits = carouselEmits;
  exports.carouselItemProps = carouselItemProps;
  exports.carouselProps = carouselProps;
  exports.cascaderEmits = cascaderEmits;
  exports.cascaderPanelEmits = cascaderPanelEmits;
  exports.cascaderPanelProps = cascaderPanelProps;
  exports.cascaderProps = cascaderProps;
  exports.checkTagEmits = checkTagEmits;
  exports.checkTagProps = checkTagProps;
  exports.checkboxDefaultProps = checkboxDefaultProps;
  exports.checkboxEmits = checkboxEmits;
  exports.checkboxGroupContextKey = checkboxGroupContextKey;
  exports.checkboxGroupEmits = checkboxGroupEmits;
  exports.checkboxGroupProps = checkboxGroupProps;
  exports.checkboxProps = checkboxProps;
  exports.colProps = colProps;
  exports.collapseContextKey = collapseContextKey;
  exports.collapseEmits = collapseEmits;
  exports.collapseItemProps = collapseItemProps;
  exports.collapseProps = collapseProps;
  exports.colorPickerEmits = colorPickerEmits;
  exports.colorPickerPanelContextKey = colorPickerPanelContextKey;
  exports.colorPickerPanelEmits = colorPickerPanelEmits;
  exports.colorPickerPanelProps = colorPickerPanelProps;
  exports.colorPickerProps = colorPickerProps;
  exports.columnAlignment = columnAlignment;
  exports.componentSizeMap = componentSizeMap;
  exports.componentSizes = componentSizes;
  exports.configProviderContextKey = configProviderContextKey;
  exports.configProviderProps = configProviderProps;
  exports.countdownEmits = countdownEmits;
  exports.countdownProps = countdownProps;
  exports.createModelToggleComposable = createModelToggleComposable;
  exports.dateEquals = dateEquals;
  exports.datePickTypes = datePickTypes;
  exports.datePickerPanelProps = datePickerPanelProps;
  exports.datePickerProps = datePickerProps;
  exports.dayOrDaysToDate = dayOrDaysToDate;
  exports.dayjs = dayjs;
  exports["default"] = installer;
  exports.defaultInitialZIndex = defaultInitialZIndex;
  exports.defaultNamespace = defaultNamespace;
  exports.defaultProps = defaultProps;
  exports.descriptionItemProps = descriptionItemProps;
  exports.descriptionProps = descriptionProps;
  exports.dialogContextKey = dialogContextKey;
  exports.dialogEmits = dialogEmits;
  exports.dialogInjectionKey = dialogInjectionKey;
  exports.dialogProps = dialogProps;
  exports.dividerProps = dividerProps;
  exports.drawerEmits = drawerEmits;
  exports.drawerProps = drawerProps;
  exports.dropdownItemProps = dropdownItemProps;
  exports.dropdownMenuProps = dropdownMenuProps;
  exports.dropdownProps = dropdownProps;
  exports.elPaginationKey = elPaginationKey;
  exports.emitChangeFn = emitChangeFn;
  exports.emptyProps = emptyProps;
  exports.emptyValuesContextKey = emptyValuesContextKey;
  exports.extractDateFormat = extractDateFormat;
  exports.extractTimeFormat = extractTimeFormat;
  exports.formContextKey = formContextKey;
  exports.formEmits = formEmits;
  exports.formItemContextKey = formItemContextKey;
  exports.formItemProps = formItemProps;
  exports.formItemValidateStates = formItemValidateStates;
  exports.formMetaProps = formMetaProps;
  exports.formProps = formProps;
  exports.formatter = formatter;
  exports.genFileId = genFileId;
  exports.getPositionDataWithUnit = getPositionDataWithUnit;
  exports.iconProps = iconProps;
  exports.imageEmits = imageEmits;
  exports.imageProps = imageProps;
  exports.imageViewerEmits = imageViewerEmits;
  exports.imageViewerProps = imageViewerProps;
  exports.inputEmits = inputEmits;
  exports.inputNumberEmits = inputNumberEmits;
  exports.inputNumberProps = inputNumberProps;
  exports.inputProps = inputProps;
  exports.inputTagEmits = inputTagEmits;
  exports.inputTagProps = inputTagProps;
  exports.install = install;
  exports.linkEmits = linkEmits;
  exports.linkProps = linkProps;
  exports.localeContextKey = localeContextKey;
  exports.makeInstaller = makeInstaller;
  exports.makeList = makeList;
  exports.mentionDefaultProps = mentionDefaultProps;
  exports.mentionEmits = mentionEmits;
  exports.mentionProps = mentionProps;
  exports.menuEmits = menuEmits;
  exports.menuItemEmits = menuItemEmits;
  exports.menuItemGroupProps = menuItemGroupProps;
  exports.menuItemProps = menuItemProps;
  exports.menuProps = menuProps;
  exports.messageConfig = messageConfig;
  exports.messageDefaults = messageDefaults;
  exports.messageEmits = messageEmits;
  exports.messagePlacement = messagePlacement;
  exports.messageProps = messageProps;
  exports.messageTypes = messageTypes;
  exports.namespaceContextKey = namespaceContextKey;
  exports.notificationEmits = notificationEmits;
  exports.notificationProps = notificationProps;
  exports.notificationTypes = notificationTypes;
  exports.overlayEmits = overlayEmits;
  exports.overlayProps = overlayProps;
  exports.pageHeaderEmits = pageHeaderEmits;
  exports.pageHeaderProps = pageHeaderProps;
  exports.paginationEmits = paginationEmits;
  exports.paginationProps = paginationProps;
  exports.parseDate = parseDate;
  exports.popconfirmEmits = popconfirmEmits;
  exports.popconfirmProps = popconfirmProps;
  exports.popoverEmits = popoverEmits;
  exports.popoverProps = popoverProps;
  exports.popperArrowProps = popperArrowProps;
  exports.popperContentEmits = popperContentEmits;
  exports.popperContentProps = popperContentProps;
  exports.popperCoreConfigProps = popperCoreConfigProps;
  exports.popperProps = popperProps;
  exports.popperTriggerProps = popperTriggerProps;
  exports.progressProps = progressProps;
  exports.provideGlobalConfig = provideGlobalConfig;
  exports.radioButtonProps = radioButtonProps;
  exports.radioDefaultProps = radioDefaultProps;
  exports.radioEmits = radioEmits;
  exports.radioGroupEmits = radioGroupEmits;
  exports.radioGroupKey = radioGroupKey;
  exports.radioGroupProps = radioGroupProps;
  exports.radioProps = radioProps;
  exports.radioPropsBase = radioPropsBase;
  exports.rangeArr = rangeArr;
  exports.rateEmits = rateEmits;
  exports.rateProps = rateProps;
  exports.renderThumbStyle = renderThumbStyle$1;
  exports.resultProps = resultProps;
  exports.roleTypes = roleTypes;
  exports.rowContextKey = rowContextKey;
  exports.rowProps = rowProps;
  exports.scrollbarContextKey = scrollbarContextKey;
  exports.scrollbarEmits = scrollbarEmits;
  exports.scrollbarProps = scrollbarProps;
  exports.segmentedEmits = segmentedEmits;
  exports.segmentedProps = segmentedProps;
  exports.selectEmits = selectEmits;
  exports.selectGroupKey = selectGroupKey;
  exports.selectKey = selectKey;
  exports.selectProps = selectProps;
  exports.selectV2InjectionKey = selectV2InjectionKey;
  exports.skeletonItemProps = skeletonItemProps;
  exports.skeletonProps = skeletonProps;
  exports.sliderContextKey = sliderContextKey;
  exports.sliderEmits = sliderEmits;
  exports.sliderProps = sliderProps;
  exports.spaceItemProps = spaceItemProps;
  exports.spaceProps = spaceProps;
  exports.splitterPanelProps = splitterPanelProps;
  exports.splitterProps = splitterProps;
  exports.statisticProps = statisticProps;
  exports.stepProps = stepProps;
  exports.stepsEmits = stepsEmits;
  exports.stepsProps = stepsProps;
  exports.subMenuProps = subMenuProps;
  exports.switchEmits = switchEmits;
  exports.switchProps = switchProps;
  exports.tabBarProps = tabBarProps;
  exports.tabNavEmits = tabNavEmits;
  exports.tabNavProps = tabNavProps;
  exports.tabPaneProps = tabPaneProps;
  exports.tableV2Props = tableV2Props;
  exports.tableV2RowProps = tableV2RowProps;
  exports.tabsEmits = tabsEmits;
  exports.tabsProps = tabsProps;
  exports.tabsRootContextKey = tabsRootContextKey;
  exports.tagEmits = tagEmits;
  exports.tagProps = tagProps;
  exports.textProps = textProps;
  exports.thumbProps = thumbProps;
  exports.timePickerDefaultProps = timePickerDefaultProps;
  exports.timePickerRangeTriggerProps = timePickerRangeTriggerProps;
  exports.timePickerRngeTriggerProps = timePickerRngeTriggerProps;
  exports.timeSelectProps = timeSelectProps;
  exports.timeUnits = timeUnits$1;
  exports.timelineItemProps = timelineItemProps;
  exports.tooltipEmits = tooltipEmits;
  exports.tourContentEmits = tourContentEmits;
  exports.tourContentProps = tourContentProps;
  exports.tourEmits = tourEmits;
  exports.tourPlacements = tourPlacements;
  exports.tourProps = tourProps;
  exports.tourStepEmits = tourStepEmits;
  exports.tourStepProps = tourStepProps;
  exports.tourStrategies = tourStrategies;
  exports.transferCheckedChangeFn = transferCheckedChangeFn;
  exports.transferEmits = transferEmits;
  exports.transferProps = transferProps;
  exports.translate = translate;
  exports.treeEmits = treeEmits$1;
  exports.uploadBaseProps = uploadBaseProps;
  exports.uploadContentProps = uploadContentProps;
  exports.uploadContextKey = uploadContextKey;
  exports.uploadDraggerEmits = uploadDraggerEmits;
  exports.uploadDraggerProps = uploadDraggerProps;
  exports.uploadListEmits = uploadListEmits;
  exports.uploadListProps = uploadListProps;
  exports.uploadListTypes = uploadListTypes;
  exports.uploadProps = uploadProps;
  exports.useAriaProps = useAriaProps;
  exports.useAttrs = useAttrs;
  exports.useCalcInputWidth = useCalcInputWidth;
  exports.useCascaderConfig = useCascaderConfig;
  exports.useComposition = useComposition;
  exports.useCursor = useCursor;
  exports.useDelayedRender = useDelayedRender;
  exports.useDelayedToggle = useDelayedToggle;
  exports.useDelayedToggleProps = useDelayedToggleProps;
  exports.useDeprecated = useDeprecated;
  exports.useDialog = useDialog;
  exports.useDisabled = useDisabled;
  exports.useDraggable = useDraggable;
  exports.useEmptyValues = useEmptyValues;
  exports.useEmptyValuesProps = useEmptyValuesProps;
  exports.useEscapeKeydown = useEscapeKeydown;
  exports.useFloating = useFloating$1;
  exports.useFloatingProps = useFloatingProps;
  exports.useFocus = useFocus;
  exports.useFocusController = useFocusController;
  exports.useFormDisabled = useFormDisabled;
  exports.useFormItem = useFormItem;
  exports.useFormItemInputId = useFormItemInputId;
  exports.useFormSize = useFormSize;
  exports.useForwardRef = useForwardRef;
  exports.useForwardRefDirective = useForwardRefDirective;
  exports.useGetDerivedNamespace = useGetDerivedNamespace;
  exports.useGlobalComponentSettings = useGlobalComponentSettings;
  exports.useGlobalConfig = useGlobalConfig;
  exports.useGlobalSize = useGlobalSize;
  exports.useId = useId;
  exports.useIdInjection = useIdInjection;
  exports.useLocale = useLocale;
  exports.useLockscreen = useLockscreen;
  exports.useModal = useModal;
  exports.useModelToggle = useModelToggle;
  exports.useModelToggleEmits = useModelToggleEmits;
  exports.useModelToggleProps = useModelToggleProps;
  exports.useNamespace = useNamespace;
  exports.useOrderedChildren = useOrderedChildren;
  exports.usePopper = usePopper;
  exports.usePopperArrowProps = usePopperArrowProps;
  exports.usePopperContainer = usePopperContainer;
  exports.usePopperContainerId = usePopperContainerId;
  exports.usePopperContentEmits = usePopperContentEmits;
  exports.usePopperContentProps = usePopperContentProps;
  exports.usePopperCoreConfigProps = usePopperCoreConfigProps;
  exports.usePopperProps = usePopperProps;
  exports.usePopperTriggerProps = usePopperTriggerProps;
  exports.usePreventGlobal = usePreventGlobal;
  exports.useProp = useProp;
  exports.useSameTarget = useSameTarget;
  exports.useSize = useSize$1;
  exports.useSizeProp = useSizeProp;
  exports.useSizeProps = useSizeProps;
  exports.useSpace = useSpace;
  exports.useTeleport = useTeleport;
  exports.useThrottleRender = useThrottleRender;
  exports.useTimeout = useTimeout;
  exports.useTooltipContentProps = useTooltipContentProps;
  exports.useTooltipModelToggle = useTooltipModelToggle;
  exports.useTooltipModelToggleEmits = useTooltipModelToggleEmits;
  exports.useTooltipModelToggleProps = useTooltipModelToggleProps;
  exports.useTooltipProps = useTooltipProps;
  exports.useTooltipTriggerProps = useTooltipTriggerProps;
  exports.useTransitionFallthrough = useTransitionFallthrough;
  exports.useTransitionFallthroughEmits = useTransitionFallthroughEmits;
  exports.useZIndex = useZIndex;
  exports.vLoading = vLoading$1;
  exports.vRepeatClick = vRepeatClick;
  exports.valueEquals = valueEquals;
  exports.version = version;
  exports.virtualizedGridProps = virtualizedGridProps;
  exports.virtualizedListProps = virtualizedListProps;
  exports.virtualizedProps = virtualizedProps;
  exports.virtualizedScrollbarProps = virtualizedScrollbarProps;
  exports.watermarkProps = watermarkProps;
  exports.zIndexContextKey = zIndexContextKey;

  Object.defineProperty(exports, '__esModule', { value: true });

}));