Reservation/out/renderer/assets/index-e95a9740.js

var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var require_index_001 = __commonJS({
  "assets/index-e95a9740.js"(exports, module) {
    function makeMap(str, expectsLowerCase) {
      const map2 = /* @__PURE__ */ Object.create(null);
      const list = str.split(",");
      for (let i = 0; i < list.length; i++) {
        map2[list[i]] = true;
      }
      return expectsLowerCase ? (val) => !!map2[val.toLowerCase()] : (val) => !!map2[val];
    }
    const EMPTY_OBJ = {};
    const EMPTY_ARR = [];
    const NOOP = () => {
    };
    const NO = () => false;
    const onRE = /^on[^a-z]/;
    const isOn = (key) => onRE.test(key);
    const isModelListener = (key) => key.startsWith("onUpdate:");
    const extend = Object.assign;
    const remove = (arr, el) => {
      const i = arr.indexOf(el);
      if (i > -1) {
        arr.splice(i, 1);
      }
    };
    const hasOwnProperty$e = Object.prototype.hasOwnProperty;
    const hasOwn = (val, key) => hasOwnProperty$e.call(val, key);
    const isArray$3 = Array.isArray;
    const isMap$2 = (val) => toTypeString(val) === "[object Map]";
    const isSet$2 = (val) => toTypeString(val) === "[object Set]";
    const isDate = (val) => toTypeString(val) === "[object Date]";
    const isFunction$2 = (val) => typeof val === "function";
    const isString$1 = (val) => typeof val === "string";
    const isSymbol$1 = (val) => typeof val === "symbol";
    const isObject$1 = (val) => val !== null && typeof val === "object";
    const isPromise = (val) => {
      return (isObject$1(val) || isFunction$2(val)) && isFunction$2(val.then) && isFunction$2(val.catch);
    };
    const objectToString$1 = Object.prototype.toString;
    const toTypeString = (value) => objectToString$1.call(value);
    const toRawType = (value) => {
      return toTypeString(value).slice(8, -1);
    };
    const isPlainObject$2 = (val) => toTypeString(val) === "[object Object]";
    const isIntegerKey = (key) => isString$1(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
    const isReservedProp = /* @__PURE__ */ makeMap(
      // the leading comma is intentional so empty string "" is also included
      ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
    );
    const cacheStringFunction = (fn2) => {
      const cache2 = /* @__PURE__ */ Object.create(null);
      return (str) => {
        const hit = cache2[str];
        return hit || (cache2[str] = fn2(str));
      };
    };
    const camelizeRE = /-(\w)/g;
    const camelize = cacheStringFunction((str) => {
      return str.replace(camelizeRE, (_2, c2) => c2 ? c2.toUpperCase() : "");
    });
    const hyphenateRE = /\B([A-Z])/g;
    const hyphenate = cacheStringFunction(
      (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
    );
    const capitalize$1 = cacheStringFunction((str) => {
      return str.charAt(0).toUpperCase() + str.slice(1);
    });
    const toHandlerKey = cacheStringFunction((str) => {
      const s2 = str ? `on${capitalize$1(str)}` : ``;
      return s2;
    });
    const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
    const invokeArrayFns = (fns, arg) => {
      for (let i = 0; i < fns.length; i++) {
        fns[i](arg);
      }
    };
    const def = (obj, key, value) => {
      Object.defineProperty(obj, key, {
        configurable: true,
        enumerable: false,
        value
      });
    };
    const looseToNumber = (val) => {
      const n = parseFloat(val);
      return isNaN(n) ? val : n;
    };
    const toNumber$1 = (val) => {
      const n = isString$1(val) ? Number(val) : NaN;
      return isNaN(n) ? val : n;
    };
    let _globalThis;
    const getGlobalThis = () => {
      return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
    };
    function normalizeStyle(value) {
      if (isArray$3(value)) {
        const res = {};
        for (let i = 0; i < value.length; i++) {
          const item = value[i];
          const normalized = isString$1(item) ? parseStringStyle(item) : normalizeStyle(item);
          if (normalized) {
            for (const key in normalized) {
              res[key] = normalized[key];
            }
          }
        }
        return res;
      } else if (isString$1(value) || isObject$1(value)) {
        return value;
      }
    }
    const listDelimiterRE = /;(?![^(]*\))/g;
    const propertyDelimiterRE = /:([^]+)/;
    const styleCommentRE = /\/\*[^]*?\*\//g;
    function parseStringStyle(cssText) {
      const ret = {};
      cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
        if (item) {
          const tmp = item.split(propertyDelimiterRE);
          tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
        }
      });
      return ret;
    }
    function normalizeClass(value) {
      let res = "";
      if (isString$1(value)) {
        res = value;
      } else if (isArray$3(value)) {
        for (let i = 0; i < value.length; i++) {
          const normalized = normalizeClass(value[i]);
          if (normalized) {
            res += normalized + " ";
          }
        }
      } else if (isObject$1(value)) {
        for (const name in value) {
          if (value[name]) {
            res += name + " ";
          }
        }
      }
      return res.trim();
    }
    function normalizeProps(props) {
      if (!props)
        return null;
      let { class: klass, style } = props;
      if (klass && !isString$1(klass)) {
        props.class = normalizeClass(klass);
      }
      if (style) {
        props.style = normalizeStyle(style);
      }
      return props;
    }
    const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
    const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
    function includeBooleanAttr(value) {
      return !!value || value === "";
    }
    function looseCompareArrays(a2, b2) {
      if (a2.length !== b2.length)
        return false;
      let equal = true;
      for (let i = 0; equal && i < a2.length; i++) {
        equal = looseEqual(a2[i], b2[i]);
      }
      return equal;
    }
    function looseEqual(a2, b2) {
      if (a2 === b2)
        return true;
      let aValidType = isDate(a2);
      let bValidType = isDate(b2);
      if (aValidType || bValidType) {
        return aValidType && bValidType ? a2.getTime() === b2.getTime() : false;
      }
      aValidType = isSymbol$1(a2);
      bValidType = isSymbol$1(b2);
      if (aValidType || bValidType) {
        return a2 === b2;
      }
      aValidType = isArray$3(a2);
      bValidType = isArray$3(b2);
      if (aValidType || bValidType) {
        return aValidType && bValidType ? looseCompareArrays(a2, b2) : false;
      }
      aValidType = isObject$1(a2);
      bValidType = isObject$1(b2);
      if (aValidType || bValidType) {
        if (!aValidType || !bValidType) {
          return false;
        }
        const aKeysCount = Object.keys(a2).length;
        const bKeysCount = Object.keys(b2).length;
        if (aKeysCount !== bKeysCount) {
          return false;
        }
        for (const key in a2) {
          const aHasKey = a2.hasOwnProperty(key);
          const bHasKey = b2.hasOwnProperty(key);
          if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a2[key], b2[key])) {
            return false;
          }
        }
      }
      return String(a2) === String(b2);
    }
    function looseIndexOf(arr, val) {
      return arr.findIndex((item) => looseEqual(item, val));
    }
    const toDisplayString = (val) => {
      return isString$1(val) ? val : val == null ? "" : isArray$3(val) || isObject$1(val) && (val.toString === objectToString$1 || !isFunction$2(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
    };
    const replacer = (_key, val) => {
      if (val && val.__v_isRef) {
        return replacer(_key, val.value);
      } else if (isMap$2(val)) {
        return {
          [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
            entries[`${key} =>`] = val2;
            return entries;
          }, {})
        };
      } else if (isSet$2(val)) {
        return {
          [`Set(${val.size})`]: [...val.values()]
        };
      } else if (isObject$1(val) && !isArray$3(val) && !isPlainObject$2(val)) {
        return String(val);
      }
      return val;
    };
    let activeEffectScope;
    class EffectScope {
      constructor(detached = false) {
        this.detached = detached;
        this._active = true;
        this.effects = [];
        this.cleanups = [];
        this.parent = activeEffectScope;
        if (!detached && activeEffectScope) {
          this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
            this
          ) - 1;
        }
      }
      get active() {
        return this._active;
      }
      run(fn2) {
        if (this._active) {
          const currentEffectScope = activeEffectScope;
          try {
            activeEffectScope = this;
            return fn2();
          } finally {
            activeEffectScope = currentEffectScope;
          }
        }
      }
      /**
       * This should only be called on non-detached scopes
       * @internal
       */
      on() {
        activeEffectScope = this;
      }
      /**
       * This should only be called on non-detached scopes
       * @internal
       */
      off() {
        activeEffectScope = this.parent;
      }
      stop(fromParent) {
        if (this._active) {
          let i, l2;
          for (i = 0, l2 = this.effects.length; i < l2; i++) {
            this.effects[i].stop();
          }
          for (i = 0, l2 = this.cleanups.length; i < l2; i++) {
            this.cleanups[i]();
          }
          if (this.scopes) {
            for (i = 0, l2 = this.scopes.length; i < l2; i++) {
              this.scopes[i].stop(true);
            }
          }
          if (!this.detached && this.parent && !fromParent) {
            const last = this.parent.scopes.pop();
            if (last && last !== this) {
              this.parent.scopes[this.index] = last;
              last.index = this.index;
            }
          }
          this.parent = void 0;
          this._active = false;
        }
      }
    }
    function effectScope(detached) {
      return new EffectScope(detached);
    }
    function recordEffectScope(effect, scope = activeEffectScope) {
      if (scope && scope.active) {
        scope.effects.push(effect);
      }
    }
    function getCurrentScope() {
      return activeEffectScope;
    }
    function onScopeDispose(fn2) {
      if (activeEffectScope) {
        activeEffectScope.cleanups.push(fn2);
      }
    }
    const createDep = (effects) => {
      const dep = new Set(effects);
      dep.w = 0;
      dep.n = 0;
      return dep;
    };
    const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
    const newTracked = (dep) => (dep.n & trackOpBit) > 0;
    const initDepMarkers = ({ deps }) => {
      if (deps.length) {
        for (let i = 0; i < deps.length; i++) {
          deps[i].w |= trackOpBit;
        }
      }
    };
    const finalizeDepMarkers = (effect) => {
      const { deps } = effect;
      if (deps.length) {
        let ptr = 0;
        for (let i = 0; i < deps.length; i++) {
          const dep = deps[i];
          if (wasTracked(dep) && !newTracked(dep)) {
            dep.delete(effect);
          } else {
            deps[ptr++] = dep;
          }
          dep.w &= ~trackOpBit;
          dep.n &= ~trackOpBit;
        }
        deps.length = ptr;
      }
    };
    const targetMap = /* @__PURE__ */ new WeakMap();
    let effectTrackDepth = 0;
    let trackOpBit = 1;
    const maxMarkerBits = 30;
    let activeEffect;
    const ITERATE_KEY = Symbol("");
    const MAP_KEY_ITERATE_KEY = Symbol("");
    class ReactiveEffect {
      constructor(fn2, scheduler = null, scope) {
        this.fn = fn2;
        this.scheduler = scheduler;
        this.active = true;
        this.deps = [];
        this.parent = void 0;
        recordEffectScope(this, scope);
      }
      run() {
        if (!this.active) {
          return this.fn();
        }
        let parent = activeEffect;
        let lastShouldTrack = shouldTrack;
        while (parent) {
          if (parent === this) {
            return;
          }
          parent = parent.parent;
        }
        try {
          this.parent = activeEffect;
          activeEffect = this;
          shouldTrack = true;
          trackOpBit = 1 << ++effectTrackDepth;
          if (effectTrackDepth <= maxMarkerBits) {
            initDepMarkers(this);
          } else {
            cleanupEffect(this);
          }
          return this.fn();
        } finally {
          if (effectTrackDepth <= maxMarkerBits) {
            finalizeDepMarkers(this);
          }
          trackOpBit = 1 << --effectTrackDepth;
          activeEffect = this.parent;
          shouldTrack = lastShouldTrack;
          this.parent = void 0;
          if (this.deferStop) {
            this.stop();
          }
        }
      }
      stop() {
        if (activeEffect === this) {
          this.deferStop = true;
        } else if (this.active) {
          cleanupEffect(this);
          if (this.onStop) {
            this.onStop();
          }
          this.active = false;
        }
      }
    }
    function cleanupEffect(effect2) {
      const { deps } = effect2;
      if (deps.length) {
        for (let i = 0; i < deps.length; i++) {
          deps[i].delete(effect2);
        }
        deps.length = 0;
      }
    }
    let shouldTrack = true;
    const trackStack = [];
    function pauseTracking() {
      trackStack.push(shouldTrack);
      shouldTrack = false;
    }
    function resetTracking() {
      const last = trackStack.pop();
      shouldTrack = last === void 0 ? true : last;
    }
    function track(target, type2, key) {
      if (shouldTrack && activeEffect) {
        let depsMap = targetMap.get(target);
        if (!depsMap) {
          targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
        }
        let dep = depsMap.get(key);
        if (!dep) {
          depsMap.set(key, dep = createDep());
        }
        trackEffects(dep);
      }
    }
    function trackEffects(dep, debuggerEventExtraInfo) {
      let shouldTrack2 = false;
      if (effectTrackDepth <= maxMarkerBits) {
        if (!newTracked(dep)) {
          dep.n |= trackOpBit;
          shouldTrack2 = !wasTracked(dep);
        }
      } else {
        shouldTrack2 = !dep.has(activeEffect);
      }
      if (shouldTrack2) {
        dep.add(activeEffect);
        activeEffect.deps.push(dep);
      }
    }
    function trigger(target, type2, key, newValue, oldValue, oldTarget) {
      const depsMap = targetMap.get(target);
      if (!depsMap) {
        return;
      }
      let deps = [];
      if (type2 === "clear") {
        deps = [...depsMap.values()];
      } else if (key === "length" && isArray$3(target)) {
        const newLength = Number(newValue);
        depsMap.forEach((dep, key2) => {
          if (key2 === "length" || !isSymbol$1(key2) && key2 >= newLength) {
            deps.push(dep);
          }
        });
      } else {
        if (key !== void 0) {
          deps.push(depsMap.get(key));
        }
        switch (type2) {
          case "add":
            if (!isArray$3(target)) {
              deps.push(depsMap.get(ITERATE_KEY));
              if (isMap$2(target)) {
                deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
              }
            } else if (isIntegerKey(key)) {
              deps.push(depsMap.get("length"));
            }
            break;
          case "delete":
            if (!isArray$3(target)) {
              deps.push(depsMap.get(ITERATE_KEY));
              if (isMap$2(target)) {
                deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
              }
            }
            break;
          case "set":
            if (isMap$2(target)) {
              deps.push(depsMap.get(ITERATE_KEY));
            }
            break;
        }
      }
      if (deps.length === 1) {
        if (deps[0]) {
          {
            triggerEffects(deps[0]);
          }
        }
      } else {
        const effects = [];
        for (const dep of deps) {
          if (dep) {
            effects.push(...dep);
          }
        }
        {
          triggerEffects(createDep(effects));
        }
      }
    }
    function triggerEffects(dep, debuggerEventExtraInfo) {
      const effects = isArray$3(dep) ? dep : [...dep];
      for (const effect2 of effects) {
        if (effect2.computed) {
          triggerEffect(effect2);
        }
      }
      for (const effect2 of effects) {
        if (!effect2.computed) {
          triggerEffect(effect2);
        }
      }
    }
    function triggerEffect(effect2, debuggerEventExtraInfo) {
      if (effect2 !== activeEffect || effect2.allowRecurse) {
        if (effect2.scheduler) {
          effect2.scheduler();
        } else {
          effect2.run();
        }
      }
    }
    function getDepFromReactive(object2, key) {
      var _a2;
      return (_a2 = targetMap.get(object2)) == null ? void 0 : _a2.get(key);
    }
    const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
    const builtInSymbols = new Set(
      /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol$1)
    );
    const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
    function createArrayInstrumentations() {
      const instrumentations = {};
      ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
        instrumentations[key] = function(...args) {
          const arr = toRaw(this);
          for (let i = 0, l2 = this.length; i < l2; i++) {
            track(arr, "get", i + "");
          }
          const res = arr[key](...args);
          if (res === -1 || res === false) {
            return arr[key](...args.map(toRaw));
          } else {
            return res;
          }
        };
      });
      ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
        instrumentations[key] = function(...args) {
          pauseTracking();
          const res = toRaw(this)[key].apply(this, args);
          resetTracking();
          return res;
        };
      });
      return instrumentations;
    }
    function hasOwnProperty$d(key) {
      const obj = toRaw(this);
      track(obj, "has", key);
      return obj.hasOwnProperty(key);
    }
    class BaseReactiveHandler {
      constructor(_isReadonly = false, _shallow = false) {
        this._isReadonly = _isReadonly;
        this._shallow = _shallow;
      }
      get(target, key, receiver) {
        const isReadonly2 = this._isReadonly, shallow = this._shallow;
        if (key === "__v_isReactive") {
          return !isReadonly2;
        } else if (key === "__v_isReadonly") {
          return isReadonly2;
        } else if (key === "__v_isShallow") {
          return shallow;
        } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
          return target;
        }
        const targetIsArray = isArray$3(target);
        if (!isReadonly2) {
          if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
            return Reflect.get(arrayInstrumentations, key, receiver);
          }
          if (key === "hasOwnProperty") {
            return hasOwnProperty$d;
          }
        }
        const res = Reflect.get(target, key, receiver);
        if (isSymbol$1(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
          return res;
        }
        if (!isReadonly2) {
          track(target, "get", key);
        }
        if (shallow) {
          return res;
        }
        if (isRef(res)) {
          return targetIsArray && isIntegerKey(key) ? res : res.value;
        }
        if (isObject$1(res)) {
          return isReadonly2 ? readonly(res) : reactive(res);
        }
        return res;
      }
    }
    class MutableReactiveHandler extends BaseReactiveHandler {
      constructor(shallow = false) {
        super(false, shallow);
      }
      set(target, key, value, receiver) {
        let oldValue = target[key];
        if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
          return false;
        }
        if (!this._shallow) {
          if (!isShallow(value) && !isReadonly(value)) {
            oldValue = toRaw(oldValue);
            value = toRaw(value);
          }
          if (!isArray$3(target) && isRef(oldValue) && !isRef(value)) {
            oldValue.value = value;
            return true;
          }
        }
        const hadKey = isArray$3(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
        const result = Reflect.set(target, key, value, receiver);
        if (target === toRaw(receiver)) {
          if (!hadKey) {
            trigger(target, "add", key, value);
          } else if (hasChanged(value, oldValue)) {
            trigger(target, "set", key, value);
          }
        }
        return result;
      }
      deleteProperty(target, key) {
        const hadKey = hasOwn(target, key);
        target[key];
        const result = Reflect.deleteProperty(target, key);
        if (result && hadKey) {
          trigger(target, "delete", key, void 0);
        }
        return result;
      }
      has(target, key) {
        const result = Reflect.has(target, key);
        if (!isSymbol$1(key) || !builtInSymbols.has(key)) {
          track(target, "has", key);
        }
        return result;
      }
      ownKeys(target) {
        track(
          target,
          "iterate",
          isArray$3(target) ? "length" : ITERATE_KEY
        );
        return Reflect.ownKeys(target);
      }
    }
    class ReadonlyReactiveHandler extends BaseReactiveHandler {
      constructor(shallow = false) {
        super(true, shallow);
      }
      set(target, key) {
        return true;
      }
      deleteProperty(target, key) {
        return true;
      }
    }
    const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
    const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
    const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
      true
    );
    const toShallow = (value) => value;
    const getProto = (v2) => Reflect.getPrototypeOf(v2);
    function get$1(target, key, isReadonly2 = false, isShallow2 = false) {
      target = target["__v_raw"];
      const rawTarget = toRaw(target);
      const rawKey = toRaw(key);
      if (!isReadonly2) {
        if (hasChanged(key, rawKey)) {
          track(rawTarget, "get", key);
        }
        track(rawTarget, "get", rawKey);
      }
      const { has: has2 } = getProto(rawTarget);
      const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
      if (has2.call(rawTarget, key)) {
        return wrap(target.get(key));
      } else if (has2.call(rawTarget, rawKey)) {
        return wrap(target.get(rawKey));
      } else if (target !== rawTarget) {
        target.get(key);
      }
    }
    function has(key, isReadonly2 = false) {
      const target = this["__v_raw"];
      const rawTarget = toRaw(target);
      const rawKey = toRaw(key);
      if (!isReadonly2) {
        if (hasChanged(key, rawKey)) {
          track(rawTarget, "has", key);
        }
        track(rawTarget, "has", rawKey);
      }
      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
    }
    function size(target, isReadonly2 = false) {
      target = target["__v_raw"];
      !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
      return Reflect.get(target, "size", target);
    }
    function add(value) {
      value = toRaw(value);
      const target = toRaw(this);
      const proto = getProto(target);
      const hadKey = proto.has.call(target, value);
      if (!hadKey) {
        target.add(value);
        trigger(target, "add", value, value);
      }
      return this;
    }
    function set$1(key, value) {
      value = toRaw(value);
      const target = toRaw(this);
      const { has: has2, get: get2 } = getProto(target);
      let hadKey = has2.call(target, key);
      if (!hadKey) {
        key = toRaw(key);
        hadKey = has2.call(target, key);
      }
      const oldValue = get2.call(target, key);
      target.set(key, value);
      if (!hadKey) {
        trigger(target, "add", key, value);
      } else if (hasChanged(value, oldValue)) {
        trigger(target, "set", key, value);
      }
      return this;
    }
    function deleteEntry(key) {
      const target = toRaw(this);
      const { has: has2, get: get2 } = getProto(target);
      let hadKey = has2.call(target, key);
      if (!hadKey) {
        key = toRaw(key);
        hadKey = has2.call(target, key);
      }
      get2 ? get2.call(target, key) : void 0;
      const result = target.delete(key);
      if (hadKey) {
        trigger(target, "delete", key, void 0);
      }
      return result;
    }
    function clear() {
      const target = toRaw(this);
      const hadItems = target.size !== 0;
      const result = target.clear();
      if (hadItems) {
        trigger(target, "clear", void 0, void 0);
      }
      return result;
    }
    function createForEach(isReadonly2, isShallow2) {
      return function forEach(callback, thisArg) {
        const observed = this;
        const target = observed["__v_raw"];
        const rawTarget = toRaw(target);
        const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
        !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
        return target.forEach((value, key) => {
          return callback.call(thisArg, wrap(value), wrap(key), observed);
        });
      };
    }
    function createIterableMethod(method2, isReadonly2, isShallow2) {
      return function(...args) {
        const target = this["__v_raw"];
        const rawTarget = toRaw(target);
        const targetIsMap = isMap$2(rawTarget);
        const isPair = method2 === "entries" || method2 === Symbol.iterator && targetIsMap;
        const isKeyOnly = method2 === "keys" && targetIsMap;
        const innerIterator = target[method2](...args);
        const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
        !isReadonly2 && track(
          rawTarget,
          "iterate",
          isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
        );
        return {
          // iterator protocol
          next() {
            const { value, done } = innerIterator.next();
            return done ? { value, done } : {
              value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
              done
            };
          },
          // iterable protocol
          [Symbol.iterator]() {
            return this;
          }
        };
      };
    }
    function createReadonlyMethod(type2) {
      return function(...args) {
        return type2 === "delete" ? false : type2 === "clear" ? void 0 : this;
      };
    }
    function createInstrumentations() {
      const mutableInstrumentations2 = {
        get(key) {
          return get$1(this, key);
        },
        get size() {
          return size(this);
        },
        has,
        add,
        set: set$1,
        delete: deleteEntry,
        clear,
        forEach: createForEach(false, false)
      };
      const shallowInstrumentations2 = {
        get(key) {
          return get$1(this, key, false, true);
        },
        get size() {
          return size(this);
        },
        has,
        add,
        set: set$1,
        delete: deleteEntry,
        clear,
        forEach: createForEach(false, true)
      };
      const readonlyInstrumentations2 = {
        get(key) {
          return get$1(this, key, true);
        },
        get size() {
          return size(this, true);
        },
        has(key) {
          return has.call(this, key, true);
        },
        add: createReadonlyMethod("add"),
        set: createReadonlyMethod("set"),
        delete: createReadonlyMethod("delete"),
        clear: createReadonlyMethod("clear"),
        forEach: createForEach(true, false)
      };
      const shallowReadonlyInstrumentations2 = {
        get(key) {
          return get$1(this, key, true, true);
        },
        get size() {
          return size(this, true);
        },
        has(key) {
          return has.call(this, key, true);
        },
        add: createReadonlyMethod("add"),
        set: createReadonlyMethod("set"),
        delete: createReadonlyMethod("delete"),
        clear: createReadonlyMethod("clear"),
        forEach: createForEach(true, true)
      };
      const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
      iteratorMethods.forEach((method2) => {
        mutableInstrumentations2[method2] = createIterableMethod(
          method2,
          false,
          false
        );
        readonlyInstrumentations2[method2] = createIterableMethod(
          method2,
          true,
          false
        );
        shallowInstrumentations2[method2] = createIterableMethod(
          method2,
          false,
          true
        );
        shallowReadonlyInstrumentations2[method2] = createIterableMethod(
          method2,
          true,
          true
        );
      });
      return [
        mutableInstrumentations2,
        readonlyInstrumentations2,
        shallowInstrumentations2,
        shallowReadonlyInstrumentations2
      ];
    }
    const [
      mutableInstrumentations,
      readonlyInstrumentations,
      shallowInstrumentations,
      shallowReadonlyInstrumentations
    ] = /* @__PURE__ */ createInstrumentations();
    function createInstrumentationGetter(isReadonly2, shallow) {
      const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
      return (target, key, receiver) => {
        if (key === "__v_isReactive") {
          return !isReadonly2;
        } else if (key === "__v_isReadonly") {
          return isReadonly2;
        } else if (key === "__v_raw") {
          return target;
        }
        return Reflect.get(
          hasOwn(instrumentations, key) && key in target ? instrumentations : target,
          key,
          receiver
        );
      };
    }
    const mutableCollectionHandlers = {
      get: /* @__PURE__ */ createInstrumentationGetter(false, false)
    };
    const shallowCollectionHandlers = {
      get: /* @__PURE__ */ createInstrumentationGetter(false, true)
    };
    const readonlyCollectionHandlers = {
      get: /* @__PURE__ */ createInstrumentationGetter(true, false)
    };
    const reactiveMap = /* @__PURE__ */ new WeakMap();
    const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
    const readonlyMap = /* @__PURE__ */ new WeakMap();
    const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
    function targetTypeMap(rawType) {
      switch (rawType) {
        case "Object":
        case "Array":
          return 1;
        case "Map":
        case "Set":
        case "WeakMap":
        case "WeakSet":
          return 2;
        default:
          return 0;
      }
    }
    function getTargetType(value) {
      return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
    }
    function reactive(target) {
      if (isReadonly(target)) {
        return target;
      }
      return createReactiveObject(
        target,
        false,
        mutableHandlers,
        mutableCollectionHandlers,
        reactiveMap
      );
    }
    function shallowReactive(target) {
      return createReactiveObject(
        target,
        false,
        shallowReactiveHandlers,
        shallowCollectionHandlers,
        shallowReactiveMap
      );
    }
    function readonly(target) {
      return createReactiveObject(
        target,
        true,
        readonlyHandlers,
        readonlyCollectionHandlers,
        readonlyMap
      );
    }
    function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
      if (!isObject$1(target)) {
        return target;
      }
      if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
        return target;
      }
      const existingProxy = proxyMap.get(target);
      if (existingProxy) {
        return existingProxy;
      }
      const targetType = getTargetType(target);
      if (targetType === 0) {
        return target;
      }
      const proxy = new Proxy(
        target,
        targetType === 2 ? collectionHandlers : baseHandlers
      );
      proxyMap.set(target, proxy);
      return proxy;
    }
    function isReactive(value) {
      if (isReadonly(value)) {
        return isReactive(value["__v_raw"]);
      }
      return !!(value && value["__v_isReactive"]);
    }
    function isReadonly(value) {
      return !!(value && value["__v_isReadonly"]);
    }
    function isShallow(value) {
      return !!(value && value["__v_isShallow"]);
    }
    function isProxy(value) {
      return isReactive(value) || isReadonly(value);
    }
    function toRaw(observed) {
      const raw = observed && observed["__v_raw"];
      return raw ? toRaw(raw) : observed;
    }
    function markRaw(value) {
      def(value, "__v_skip", true);
      return value;
    }
    const toReactive = (value) => isObject$1(value) ? reactive(value) : value;
    const toReadonly = (value) => isObject$1(value) ? readonly(value) : value;
    function trackRefValue(ref2) {
      if (shouldTrack && activeEffect) {
        ref2 = toRaw(ref2);
        {
          trackEffects(ref2.dep || (ref2.dep = createDep()));
        }
      }
    }
    function triggerRefValue(ref2, newVal) {
      ref2 = toRaw(ref2);
      const dep = ref2.dep;
      if (dep) {
        {
          triggerEffects(dep);
        }
      }
    }
    function isRef(r) {
      return !!(r && r.__v_isRef === true);
    }
    function ref(value) {
      return createRef(value, false);
    }
    function shallowRef(value) {
      return createRef(value, true);
    }
    function createRef(rawValue, shallow) {
      if (isRef(rawValue)) {
        return rawValue;
      }
      return new RefImpl(rawValue, shallow);
    }
    class RefImpl {
      constructor(value, __v_isShallow) {
        this.__v_isShallow = __v_isShallow;
        this.dep = void 0;
        this.__v_isRef = true;
        this._rawValue = __v_isShallow ? value : toRaw(value);
        this._value = __v_isShallow ? value : toReactive(value);
      }
      get value() {
        trackRefValue(this);
        return this._value;
      }
      set value(newVal) {
        const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
        newVal = useDirectValue ? newVal : toRaw(newVal);
        if (hasChanged(newVal, this._rawValue)) {
          this._rawValue = newVal;
          this._value = useDirectValue ? newVal : toReactive(newVal);
          triggerRefValue(this);
        }
      }
    }
    function triggerRef(ref2) {
      triggerRefValue(ref2);
    }
    function unref(ref2) {
      return isRef(ref2) ? ref2.value : ref2;
    }
    const shallowUnwrapHandlers = {
      get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
      set: (target, key, value, receiver) => {
        const oldValue = target[key];
        if (isRef(oldValue) && !isRef(value)) {
          oldValue.value = value;
          return true;
        } else {
          return Reflect.set(target, key, value, receiver);
        }
      }
    };
    function proxyRefs(objectWithRefs) {
      return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
    }
    function toRefs(object2) {
      const ret = isArray$3(object2) ? new Array(object2.length) : {};
      for (const key in object2) {
        ret[key] = propertyToRef(object2, key);
      }
      return ret;
    }
    class ObjectRefImpl {
      constructor(_object, _key, _defaultValue) {
        this._object = _object;
        this._key = _key;
        this._defaultValue = _defaultValue;
        this.__v_isRef = true;
      }
      get value() {
        const val = this._object[this._key];
        return val === void 0 ? this._defaultValue : val;
      }
      set value(newVal) {
        this._object[this._key] = newVal;
      }
      get dep() {
        return getDepFromReactive(toRaw(this._object), this._key);
      }
    }
    class GetterRefImpl {
      constructor(_getter) {
        this._getter = _getter;
        this.__v_isRef = true;
        this.__v_isReadonly = true;
      }
      get value() {
        return this._getter();
      }
    }
    function toRef(source, key, defaultValue) {
      if (isRef(source)) {
        return source;
      } else if (isFunction$2(source)) {
        return new GetterRefImpl(source);
      } else if (isObject$1(source) && arguments.length > 1) {
        return propertyToRef(source, key, defaultValue);
      } else {
        return ref(source);
      }
    }
    function propertyToRef(source, key, defaultValue) {
      const val = source[key];
      return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
    }
    class ComputedRefImpl {
      constructor(getter, _setter, isReadonly2, isSSR) {
        this._setter = _setter;
        this.dep = void 0;
        this.__v_isRef = true;
        this["__v_isReadonly"] = false;
        this._dirty = true;
        this.effect = new ReactiveEffect(getter, () => {
          if (!this._dirty) {
            this._dirty = true;
            triggerRefValue(this);
          }
        });
        this.effect.computed = this;
        this.effect.active = this._cacheable = !isSSR;
        this["__v_isReadonly"] = isReadonly2;
      }
      get value() {
        const self2 = toRaw(this);
        trackRefValue(self2);
        if (self2._dirty || !self2._cacheable) {
          self2._dirty = false;
          self2._value = self2.effect.run();
        }
        return self2._value;
      }
      set value(newValue) {
        this._setter(newValue);
      }
    }
    function computed$1(getterOrOptions, debugOptions, isSSR = false) {
      let getter;
      let setter;
      const onlyGetter = isFunction$2(getterOrOptions);
      if (onlyGetter) {
        getter = getterOrOptions;
        setter = NOOP;
      } else {
        getter = getterOrOptions.get;
        setter = getterOrOptions.set;
      }
      const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
      return cRef;
    }
    function warn(msg, ...args) {
      return;
    }
    function callWithErrorHandling(fn2, instance, type2, args) {
      let res;
      try {
        res = args ? fn2(...args) : fn2();
      } catch (err) {
        handleError(err, instance, type2);
      }
      return res;
    }
    function callWithAsyncErrorHandling(fn2, instance, type2, args) {
      if (isFunction$2(fn2)) {
        const res = callWithErrorHandling(fn2, instance, type2, args);
        if (res && isPromise(res)) {
          res.catch((err) => {
            handleError(err, instance, type2);
          });
        }
        return res;
      }
      const values = [];
      for (let i = 0; i < fn2.length; i++) {
        values.push(callWithAsyncErrorHandling(fn2[i], instance, type2, args));
      }
      return values;
    }
    function handleError(err, instance, type2, throwInDev = true) {
      const contextVNode = instance ? instance.vnode : null;
      if (instance) {
        let cur = instance.parent;
        const exposedInstance = instance.proxy;
        const errorInfo = type2;
        while (cur) {
          const errorCapturedHooks = cur.ec;
          if (errorCapturedHooks) {
            for (let i = 0; i < errorCapturedHooks.length; i++) {
              if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
                return;
              }
            }
          }
          cur = cur.parent;
        }
        const appErrorHandler = instance.appContext.config.errorHandler;
        if (appErrorHandler) {
          callWithErrorHandling(
            appErrorHandler,
            null,
            10,
            [err, exposedInstance, errorInfo]
          );
          return;
        }
      }
      logError(err, type2, contextVNode, throwInDev);
    }
    function logError(err, type2, contextVNode, throwInDev = true) {
      {
        console.error(err);
      }
    }
    let isFlushing = false;
    let isFlushPending = false;
    const queue = [];
    let flushIndex = 0;
    const pendingPostFlushCbs = [];
    let activePostFlushCbs = null;
    let postFlushIndex = 0;
    const resolvedPromise = /* @__PURE__ */ Promise.resolve();
    let currentFlushPromise = null;
    function nextTick(fn2) {
      const p2 = currentFlushPromise || resolvedPromise;
      return fn2 ? p2.then(this ? fn2.bind(this) : fn2) : p2;
    }
    function findInsertionIndex(id) {
      let start = flushIndex + 1;
      let end2 = queue.length;
      while (start < end2) {
        const middle = start + end2 >>> 1;
        const middleJob = queue[middle];
        const middleJobId = getId(middleJob);
        if (middleJobId < id || middleJobId === id && middleJob.pre) {
          start = middle + 1;
        } else {
          end2 = middle;
        }
      }
      return start;
    }
    function queueJob(job) {
      if (!queue.length || !queue.includes(
        job,
        isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
      )) {
        if (job.id == null) {
          queue.push(job);
        } else {
          queue.splice(findInsertionIndex(job.id), 0, job);
        }
        queueFlush();
      }
    }
    function queueFlush() {
      if (!isFlushing && !isFlushPending) {
        isFlushPending = true;
        currentFlushPromise = resolvedPromise.then(flushJobs);
      }
    }
    function invalidateJob(job) {
      const i = queue.indexOf(job);
      if (i > flushIndex) {
        queue.splice(i, 1);
      }
    }
    function queuePostFlushCb(cb) {
      if (!isArray$3(cb)) {
        if (!activePostFlushCbs || !activePostFlushCbs.includes(
          cb,
          cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
        )) {
          pendingPostFlushCbs.push(cb);
        }
      } else {
        pendingPostFlushCbs.push(...cb);
      }
      queueFlush();
    }
    function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
      for (; i < queue.length; i++) {
        const cb = queue[i];
        if (cb && cb.pre) {
          queue.splice(i, 1);
          i--;
          cb();
        }
      }
    }
    function flushPostFlushCbs(seen) {
      if (pendingPostFlushCbs.length) {
        const deduped = [...new Set(pendingPostFlushCbs)];
        pendingPostFlushCbs.length = 0;
        if (activePostFlushCbs) {
          activePostFlushCbs.push(...deduped);
          return;
        }
        activePostFlushCbs = deduped;
        activePostFlushCbs.sort((a2, b2) => getId(a2) - getId(b2));
        for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
          activePostFlushCbs[postFlushIndex]();
        }
        activePostFlushCbs = null;
        postFlushIndex = 0;
      }
    }
    const getId = (job) => job.id == null ? Infinity : job.id;
    const comparator = (a2, b2) => {
      const diff = getId(a2) - getId(b2);
      if (diff === 0) {
        if (a2.pre && !b2.pre)
          return -1;
        if (b2.pre && !a2.pre)
          return 1;
      }
      return diff;
    };
    function flushJobs(seen) {
      isFlushPending = false;
      isFlushing = true;
      queue.sort(comparator);
      const check = NOOP;
      try {
        for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
          const job = queue[flushIndex];
          if (job && job.active !== false) {
            if (false)
              ;
            callWithErrorHandling(job, null, 14);
          }
        }
      } finally {
        flushIndex = 0;
        queue.length = 0;
        flushPostFlushCbs();
        isFlushing = false;
        currentFlushPromise = null;
        if (queue.length || pendingPostFlushCbs.length) {
          flushJobs();
        }
      }
    }
    function emit(instance, event, ...rawArgs) {
      if (instance.isUnmounted)
        return;
      const props = instance.vnode.props || EMPTY_OBJ;
      let args = rawArgs;
      const isModelListener2 = event.startsWith("update:");
      const modelArg = isModelListener2 && event.slice(7);
      if (modelArg && modelArg in props) {
        const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
        const { number: number2, trim } = props[modifiersKey] || EMPTY_OBJ;
        if (trim) {
          args = rawArgs.map((a2) => isString$1(a2) ? a2.trim() : a2);
        }
        if (number2) {
          args = rawArgs.map(looseToNumber);
        }
      }
      let handlerName;
      let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
      props[handlerName = toHandlerKey(camelize(event))];
      if (!handler && isModelListener2) {
        handler = props[handlerName = toHandlerKey(hyphenate(event))];
      }
      if (handler) {
        callWithAsyncErrorHandling(
          handler,
          instance,
          6,
          args
        );
      }
      const onceHandler = props[handlerName + `Once`];
      if (onceHandler) {
        if (!instance.emitted) {
          instance.emitted = {};
        } else if (instance.emitted[handlerName]) {
          return;
        }
        instance.emitted[handlerName] = true;
        callWithAsyncErrorHandling(
          onceHandler,
          instance,
          6,
          args
        );
      }
    }
    function normalizeEmitsOptions(comp, appContext, asMixin = false) {
      const cache2 = appContext.emitsCache;
      const cached = cache2.get(comp);
      if (cached !== void 0) {
        return cached;
      }
      const raw = comp.emits;
      let normalized = {};
      let hasExtends = false;
      if (!isFunction$2(comp)) {
        const extendEmits = (raw2) => {
          const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
          if (normalizedFromExtend) {
            hasExtends = true;
            extend(normalized, normalizedFromExtend);
          }
        };
        if (!asMixin && appContext.mixins.length) {
          appContext.mixins.forEach(extendEmits);
        }
        if (comp.extends) {
          extendEmits(comp.extends);
        }
        if (comp.mixins) {
          comp.mixins.forEach(extendEmits);
        }
      }
      if (!raw && !hasExtends) {
        if (isObject$1(comp)) {
          cache2.set(comp, null);
        }
        return null;
      }
      if (isArray$3(raw)) {
        raw.forEach((key) => normalized[key] = null);
      } else {
        extend(normalized, raw);
      }
      if (isObject$1(comp)) {
        cache2.set(comp, normalized);
      }
      return normalized;
    }
    function isEmitListener(options, key) {
      if (!options || !isOn(key)) {
        return false;
      }
      key = key.slice(2).replace(/Once$/, "");
      return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
    }
    let currentRenderingInstance = null;
    let currentScopeId = null;
    function setCurrentRenderingInstance(instance) {
      const prev = currentRenderingInstance;
      currentRenderingInstance = instance;
      currentScopeId = instance && instance.type.__scopeId || null;
      return prev;
    }
    function pushScopeId(id) {
      currentScopeId = id;
    }
    function popScopeId() {
      currentScopeId = null;
    }
    function withCtx(fn2, ctx = currentRenderingInstance, isNonScopedSlot) {
      if (!ctx)
        return fn2;
      if (fn2._n) {
        return fn2;
      }
      const renderFnWithContext = (...args) => {
        if (renderFnWithContext._d) {
          setBlockTracking(-1);
        }
        const prevInstance = setCurrentRenderingInstance(ctx);
        let res;
        try {
          res = fn2(...args);
        } finally {
          setCurrentRenderingInstance(prevInstance);
          if (renderFnWithContext._d) {
            setBlockTracking(1);
          }
        }
        return res;
      };
      renderFnWithContext._n = true;
      renderFnWithContext._c = true;
      renderFnWithContext._d = true;
      return renderFnWithContext;
    }
    function markAttrsAccessed() {
    }
    function renderComponentRoot(instance) {
      const {
        type: Component,
        vnode,
        proxy,
        withProxy,
        props,
        propsOptions: [propsOptions],
        slots,
        attrs,
        emit: emit2,
        render: render2,
        renderCache,
        data,
        setupState,
        ctx,
        inheritAttrs
      } = instance;
      let result;
      let fallthroughAttrs;
      const prev = setCurrentRenderingInstance(instance);
      try {
        if (vnode.shapeFlag & 4) {
          const proxyToUse = withProxy || proxy;
          const thisProxy = false ? new Proxy(proxyToUse, {
            get(target, key, receiver) {
              warn(
                `Property '${String(
                  key
                )}' was accessed via 'this'. Avoid using 'this' in templates.`
              );
              return Reflect.get(target, key, receiver);
            }
          }) : proxyToUse;
          result = normalizeVNode(
            render2.call(
              thisProxy,
              proxyToUse,
              renderCache,
              props,
              setupState,
              data,
              ctx
            )
          );
          fallthroughAttrs = attrs;
        } else {
          const render22 = Component;
          if (false)
            ;
          result = normalizeVNode(
            render22.length > 1 ? render22(
              props,
              false ? {
                get attrs() {
                  markAttrsAccessed();
                  return attrs;
                },
                slots,
                emit: emit2
              } : { attrs, slots, emit: emit2 }
            ) : render22(
              props,
              null
              /* we know it doesn't need it */
            )
          );
          fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
        }
      } catch (err) {
        blockStack.length = 0;
        handleError(err, instance, 1);
        result = createVNode(Comment);
      }
      let root2 = result;
      if (fallthroughAttrs && inheritAttrs !== false) {
        const keys2 = Object.keys(fallthroughAttrs);
        const { shapeFlag } = root2;
        if (keys2.length) {
          if (shapeFlag & (1 | 6)) {
            if (propsOptions && keys2.some(isModelListener)) {
              fallthroughAttrs = filterModelListeners(
                fallthroughAttrs,
                propsOptions
              );
            }
            root2 = cloneVNode(root2, fallthroughAttrs);
          }
        }
      }
      if (vnode.dirs) {
        root2 = cloneVNode(root2);
        root2.dirs = root2.dirs ? root2.dirs.concat(vnode.dirs) : vnode.dirs;
      }
      if (vnode.transition) {
        root2.transition = vnode.transition;
      }
      {
        result = root2;
      }
      setCurrentRenderingInstance(prev);
      return result;
    }
    const getFunctionalFallthrough = (attrs) => {
      let res;
      for (const key in attrs) {
        if (key === "class" || key === "style" || isOn(key)) {
          (res || (res = {}))[key] = attrs[key];
        }
      }
      return res;
    };
    const filterModelListeners = (attrs, props) => {
      const res = {};
      for (const key in attrs) {
        if (!isModelListener(key) || !(key.slice(9) in props)) {
          res[key] = attrs[key];
        }
      }
      return res;
    };
    function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
      const { props: prevProps, children: prevChildren, component: component2 } = prevVNode;
      const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
      const emits = component2.emitsOptions;
      if (nextVNode.dirs || nextVNode.transition) {
        return true;
      }
      if (optimized && patchFlag >= 0) {
        if (patchFlag & 1024) {
          return true;
        }
        if (patchFlag & 16) {
          if (!prevProps) {
            return !!nextProps;
          }
          return hasPropsChanged(prevProps, nextProps, emits);
        } else if (patchFlag & 8) {
          const dynamicProps = nextVNode.dynamicProps;
          for (let i = 0; i < dynamicProps.length; i++) {
            const key = dynamicProps[i];
            if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
              return true;
            }
          }
        }
      } else {
        if (prevChildren || nextChildren) {
          if (!nextChildren || !nextChildren.$stable) {
            return true;
          }
        }
        if (prevProps === nextProps) {
          return false;
        }
        if (!prevProps) {
          return !!nextProps;
        }
        if (!nextProps) {
          return true;
        }
        return hasPropsChanged(prevProps, nextProps, emits);
      }
      return false;
    }
    function hasPropsChanged(prevProps, nextProps, emitsOptions) {
      const nextKeys = Object.keys(nextProps);
      if (nextKeys.length !== Object.keys(prevProps).length) {
        return true;
      }
      for (let i = 0; i < nextKeys.length; i++) {
        const key = nextKeys[i];
        if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
          return true;
        }
      }
      return false;
    }
    function updateHOCHostEl({ vnode, parent }, el) {
      while (parent && parent.subTree === vnode) {
        (vnode = parent.vnode).el = el;
        parent = parent.parent;
      }
    }
    const COMPONENTS = "components";
    const DIRECTIVES = "directives";
    function resolveComponent(name, maybeSelfReference) {
      return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
    }
    const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
    function resolveDynamicComponent(component2) {
      if (isString$1(component2)) {
        return resolveAsset(COMPONENTS, component2, false) || component2;
      } else {
        return component2 || NULL_DYNAMIC_COMPONENT;
      }
    }
    function resolveDirective(name) {
      return resolveAsset(DIRECTIVES, name);
    }
    function resolveAsset(type2, name, warnMissing = true, maybeSelfReference = false) {
      const instance = currentRenderingInstance || currentInstance;
      if (instance) {
        const Component = instance.type;
        if (type2 === COMPONENTS) {
          const selfName = getComponentName(
            Component,
            false
            /* do not include inferred name to avoid breaking existing code */
          );
          if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize$1(camelize(name)))) {
            return Component;
          }
        }
        const res = (
          // local registration
          // check instance[type] first which is resolved for options API
          resolve(instance[type2] || Component[type2], name) || // global registration
          resolve(instance.appContext[type2], name)
        );
        if (!res && maybeSelfReference) {
          return Component;
        }
        return res;
      }
    }
    function resolve(registry, name) {
      return registry && (registry[name] || registry[camelize(name)] || registry[capitalize$1(camelize(name))]);
    }
    const isSuspense = (type2) => type2.__isSuspense;
    function queueEffectWithSuspense(fn2, suspense) {
      if (suspense && suspense.pendingBranch) {
        if (isArray$3(fn2)) {
          suspense.effects.push(...fn2);
        } else {
          suspense.effects.push(fn2);
        }
      } else {
        queuePostFlushCb(fn2);
      }
    }
    function watchEffect(effect, options) {
      return doWatch(effect, null, options);
    }
    const INITIAL_WATCHER_VALUE = {};
    function watch(source, cb, options) {
      return doWatch(source, cb, options);
    }
    function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
      var _a2;
      const instance = getCurrentScope() === ((_a2 = currentInstance) == null ? void 0 : _a2.scope) ? currentInstance : null;
      let getter;
      let forceTrigger = false;
      let isMultiSource = false;
      if (isRef(source)) {
        getter = () => source.value;
        forceTrigger = isShallow(source);
      } else if (isReactive(source)) {
        getter = () => source;
        deep = true;
      } else if (isArray$3(source)) {
        isMultiSource = true;
        forceTrigger = source.some((s2) => isReactive(s2) || isShallow(s2));
        getter = () => source.map((s2) => {
          if (isRef(s2)) {
            return s2.value;
          } else if (isReactive(s2)) {
            return traverse(s2);
          } else if (isFunction$2(s2)) {
            return callWithErrorHandling(s2, instance, 2);
          } else
            ;
        });
      } else if (isFunction$2(source)) {
        if (cb) {
          getter = () => callWithErrorHandling(source, instance, 2);
        } else {
          getter = () => {
            if (instance && instance.isUnmounted) {
              return;
            }
            if (cleanup) {
              cleanup();
            }
            return callWithAsyncErrorHandling(
              source,
              instance,
              3,
              [onCleanup]
            );
          };
        }
      } else {
        getter = NOOP;
      }
      if (cb && deep) {
        const baseGetter = getter;
        getter = () => traverse(baseGetter());
      }
      let cleanup;
      let onCleanup = (fn2) => {
        cleanup = effect.onStop = () => {
          callWithErrorHandling(fn2, instance, 4);
          cleanup = effect.onStop = void 0;
        };
      };
      let ssrCleanup;
      if (isInSSRComponentSetup) {
        onCleanup = NOOP;
        if (!cb) {
          getter();
        } else if (immediate) {
          callWithAsyncErrorHandling(cb, instance, 3, [
            getter(),
            isMultiSource ? [] : void 0,
            onCleanup
          ]);
        }
        if (flush === "sync") {
          const ctx = useSSRContext();
          ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
        } else {
          return NOOP;
        }
      }
      let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
      const job = () => {
        if (!effect.active) {
          return;
        }
        if (cb) {
          const newValue = effect.run();
          if (deep || forceTrigger || (isMultiSource ? newValue.some((v2, i) => hasChanged(v2, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
            if (cleanup) {
              cleanup();
            }
            callWithAsyncErrorHandling(cb, instance, 3, [
              newValue,
              // pass undefined as the old value when it's changed for the first time
              oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
              onCleanup
            ]);
            oldValue = newValue;
          }
        } else {
          effect.run();
        }
      };
      job.allowRecurse = !!cb;
      let scheduler;
      if (flush === "sync") {
        scheduler = job;
      } else if (flush === "post") {
        scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
      } else {
        job.pre = true;
        if (instance)
          job.id = instance.uid;
        scheduler = () => queueJob(job);
      }
      const effect = new ReactiveEffect(getter, scheduler);
      if (cb) {
        if (immediate) {
          job();
        } else {
          oldValue = effect.run();
        }
      } else if (flush === "post") {
        queuePostRenderEffect(
          effect.run.bind(effect),
          instance && instance.suspense
        );
      } else {
        effect.run();
      }
      const unwatch = () => {
        effect.stop();
        if (instance && instance.scope) {
          remove(instance.scope.effects, effect);
        }
      };
      if (ssrCleanup)
        ssrCleanup.push(unwatch);
      return unwatch;
    }
    function instanceWatch(source, value, options) {
      const publicThis = this.proxy;
      const getter = isString$1(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
      let cb;
      if (isFunction$2(value)) {
        cb = value;
      } else {
        cb = value.handler;
        options = value;
      }
      const cur = currentInstance;
      setCurrentInstance(this);
      const res = doWatch(getter, cb.bind(publicThis), options);
      if (cur) {
        setCurrentInstance(cur);
      } else {
        unsetCurrentInstance();
      }
      return res;
    }
    function createPathGetter(ctx, path) {
      const segments = path.split(".");
      return () => {
        let cur = ctx;
        for (let i = 0; i < segments.length && cur; i++) {
          cur = cur[segments[i]];
        }
        return cur;
      };
    }
    function traverse(value, seen) {
      if (!isObject$1(value) || value["__v_skip"]) {
        return value;
      }
      seen = seen || /* @__PURE__ */ new Set();
      if (seen.has(value)) {
        return value;
      }
      seen.add(value);
      if (isRef(value)) {
        traverse(value.value, seen);
      } else if (isArray$3(value)) {
        for (let i = 0; i < value.length; i++) {
          traverse(value[i], seen);
        }
      } else if (isSet$2(value) || isMap$2(value)) {
        value.forEach((v2) => {
          traverse(v2, seen);
        });
      } else if (isPlainObject$2(value)) {
        for (const key in value) {
          traverse(value[key], seen);
        }
      }
      return value;
    }
    function withDirectives(vnode, directives) {
      const internalInstance = currentRenderingInstance;
      if (internalInstance === null) {
        return vnode;
      }
      const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
      const bindings = vnode.dirs || (vnode.dirs = []);
      for (let i = 0; i < directives.length; i++) {
        let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
        if (dir) {
          if (isFunction$2(dir)) {
            dir = {
              mounted: dir,
              updated: dir
            };
          }
          if (dir.deep) {
            traverse(value);
          }
          bindings.push({
            dir,
            instance,
            value,
            oldValue: void 0,
            arg,
            modifiers
          });
        }
      }
      return vnode;
    }
    function invokeDirectiveHook(vnode, prevVNode, instance, name) {
      const bindings = vnode.dirs;
      const oldBindings = prevVNode && prevVNode.dirs;
      for (let i = 0; i < bindings.length; i++) {
        const binding = bindings[i];
        if (oldBindings) {
          binding.oldValue = oldBindings[i].value;
        }
        let hook = binding.dir[name];
        if (hook) {
          pauseTracking();
          callWithAsyncErrorHandling(hook, instance, 8, [
            vnode.el,
            binding,
            vnode,
            prevVNode
          ]);
          resetTracking();
        }
      }
    }
    const leaveCbKey = Symbol("_leaveCb");
    const enterCbKey$1 = Symbol("_enterCb");
    function useTransitionState() {
      const state = {
        isMounted: false,
        isLeaving: false,
        isUnmounting: false,
        leavingVNodes: /* @__PURE__ */ new Map()
      };
      onMounted(() => {
        state.isMounted = true;
      });
      onBeforeUnmount(() => {
        state.isUnmounting = true;
      });
      return state;
    }
    const TransitionHookValidator = [Function, Array];
    const BaseTransitionPropsValidators = {
      mode: String,
      appear: Boolean,
      persisted: Boolean,
      // enter
      onBeforeEnter: TransitionHookValidator,
      onEnter: TransitionHookValidator,
      onAfterEnter: TransitionHookValidator,
      onEnterCancelled: TransitionHookValidator,
      // leave
      onBeforeLeave: TransitionHookValidator,
      onLeave: TransitionHookValidator,
      onAfterLeave: TransitionHookValidator,
      onLeaveCancelled: TransitionHookValidator,
      // appear
      onBeforeAppear: TransitionHookValidator,
      onAppear: TransitionHookValidator,
      onAfterAppear: TransitionHookValidator,
      onAppearCancelled: TransitionHookValidator
    };
    const BaseTransitionImpl = {
      name: `BaseTransition`,
      props: BaseTransitionPropsValidators,
      setup(props, { slots }) {
        const instance = getCurrentInstance();
        const state = useTransitionState();
        let prevTransitionKey;
        return () => {
          const children = slots.default && getTransitionRawChildren(slots.default(), true);
          if (!children || !children.length) {
            return;
          }
          let child = children[0];
          if (children.length > 1) {
            for (const c2 of children) {
              if (c2.type !== Comment) {
                child = c2;
                break;
              }
            }
          }
          const rawProps = toRaw(props);
          const { mode } = rawProps;
          if (state.isLeaving) {
            return emptyPlaceholder(child);
          }
          const innerChild = getKeepAliveChild(child);
          if (!innerChild) {
            return emptyPlaceholder(child);
          }
          const enterHooks = resolveTransitionHooks(
            innerChild,
            rawProps,
            state,
            instance
          );
          setTransitionHooks(innerChild, enterHooks);
          const oldChild = instance.subTree;
          const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
          let transitionKeyChanged = false;
          const { getTransitionKey } = innerChild.type;
          if (getTransitionKey) {
            const key = getTransitionKey();
            if (prevTransitionKey === void 0) {
              prevTransitionKey = key;
            } else if (key !== prevTransitionKey) {
              prevTransitionKey = key;
              transitionKeyChanged = true;
            }
          }
          if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
            const leavingHooks = resolveTransitionHooks(
              oldInnerChild,
              rawProps,
              state,
              instance
            );
            setTransitionHooks(oldInnerChild, leavingHooks);
            if (mode === "out-in") {
              state.isLeaving = true;
              leavingHooks.afterLeave = () => {
                state.isLeaving = false;
                if (instance.update.active !== false) {
                  instance.update();
                }
              };
              return emptyPlaceholder(child);
            } else if (mode === "in-out" && innerChild.type !== Comment) {
              leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
                const leavingVNodesCache = getLeavingNodesForType(
                  state,
                  oldInnerChild
                );
                leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
                el[leaveCbKey] = () => {
                  earlyRemove();
                  el[leaveCbKey] = void 0;
                  delete enterHooks.delayedLeave;
                };
                enterHooks.delayedLeave = delayedLeave;
              };
            }
          }
          return child;
        };
      }
    };
    const BaseTransition = BaseTransitionImpl;
    function getLeavingNodesForType(state, vnode) {
      const { leavingVNodes } = state;
      let leavingVNodesCache = leavingVNodes.get(vnode.type);
      if (!leavingVNodesCache) {
        leavingVNodesCache = /* @__PURE__ */ Object.create(null);
        leavingVNodes.set(vnode.type, leavingVNodesCache);
      }
      return leavingVNodesCache;
    }
    function resolveTransitionHooks(vnode, props, state, instance) {
      const {
        appear,
        mode,
        persisted = false,
        onBeforeEnter,
        onEnter,
        onAfterEnter,
        onEnterCancelled,
        onBeforeLeave,
        onLeave,
        onAfterLeave,
        onLeaveCancelled,
        onBeforeAppear,
        onAppear,
        onAfterAppear,
        onAppearCancelled
      } = props;
      const key = String(vnode.key);
      const leavingVNodesCache = getLeavingNodesForType(state, vnode);
      const callHook2 = (hook, args) => {
        hook && callWithAsyncErrorHandling(
          hook,
          instance,
          9,
          args
        );
      };
      const callAsyncHook = (hook, args) => {
        const done = args[1];
        callHook2(hook, args);
        if (isArray$3(hook)) {
          if (hook.every((hook2) => hook2.length <= 1))
            done();
        } else if (hook.length <= 1) {
          done();
        }
      };
      const hooks = {
        mode,
        persisted,
        beforeEnter(el) {
          let hook = onBeforeEnter;
          if (!state.isMounted) {
            if (appear) {
              hook = onBeforeAppear || onBeforeEnter;
            } else {
              return;
            }
          }
          if (el[leaveCbKey]) {
            el[leaveCbKey](
              true
              /* cancelled */
            );
          }
          const leavingVNode = leavingVNodesCache[key];
          if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
            leavingVNode.el[leaveCbKey]();
          }
          callHook2(hook, [el]);
        },
        enter(el) {
          let hook = onEnter;
          let afterHook = onAfterEnter;
          let cancelHook = onEnterCancelled;
          if (!state.isMounted) {
            if (appear) {
              hook = onAppear || onEnter;
              afterHook = onAfterAppear || onAfterEnter;
              cancelHook = onAppearCancelled || onEnterCancelled;
            } else {
              return;
            }
          }
          let called = false;
          const done = el[enterCbKey$1] = (cancelled) => {
            if (called)
              return;
            called = true;
            if (cancelled) {
              callHook2(cancelHook, [el]);
            } else {
              callHook2(afterHook, [el]);
            }
            if (hooks.delayedLeave) {
              hooks.delayedLeave();
            }
            el[enterCbKey$1] = void 0;
          };
          if (hook) {
            callAsyncHook(hook, [el, done]);
          } else {
            done();
          }
        },
        leave(el, remove2) {
          const key2 = String(vnode.key);
          if (el[enterCbKey$1]) {
            el[enterCbKey$1](
              true
              /* cancelled */
            );
          }
          if (state.isUnmounting) {
            return remove2();
          }
          callHook2(onBeforeLeave, [el]);
          let called = false;
          const done = el[leaveCbKey] = (cancelled) => {
            if (called)
              return;
            called = true;
            remove2();
            if (cancelled) {
              callHook2(onLeaveCancelled, [el]);
            } else {
              callHook2(onAfterLeave, [el]);
            }
            el[leaveCbKey] = void 0;
            if (leavingVNodesCache[key2] === vnode) {
              delete leavingVNodesCache[key2];
            }
          };
          leavingVNodesCache[key2] = vnode;
          if (onLeave) {
            callAsyncHook(onLeave, [el, done]);
          } else {
            done();
          }
        },
        clone(vnode2) {
          return resolveTransitionHooks(vnode2, props, state, instance);
        }
      };
      return hooks;
    }
    function emptyPlaceholder(vnode) {
      if (isKeepAlive(vnode)) {
        vnode = cloneVNode(vnode);
        vnode.children = null;
        return vnode;
      }
    }
    function getKeepAliveChild(vnode) {
      return isKeepAlive(vnode) ? (
        // #7121 ensure get the child component subtree in case
        // it's been replaced during HMR
        vnode.children ? vnode.children[0] : void 0
      ) : vnode;
    }
    function setTransitionHooks(vnode, hooks) {
      if (vnode.shapeFlag & 6 && vnode.component) {
        setTransitionHooks(vnode.component.subTree, hooks);
      } else if (vnode.shapeFlag & 128) {
        vnode.ssContent.transition = hooks.clone(vnode.ssContent);
        vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
      } else {
        vnode.transition = hooks;
      }
    }
    function getTransitionRawChildren(children, keepComment = false, parentKey) {
      let ret = [];
      let keyedFragmentCount = 0;
      for (let i = 0; i < children.length; i++) {
        let child = children[i];
        const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
        if (child.type === Fragment) {
          if (child.patchFlag & 128)
            keyedFragmentCount++;
          ret = ret.concat(
            getTransitionRawChildren(child.children, keepComment, key)
          );
        } else if (keepComment || child.type !== Comment) {
          ret.push(key != null ? cloneVNode(child, { key }) : child);
        }
      }
      if (keyedFragmentCount > 1) {
        for (let i = 0; i < ret.length; i++) {
          ret[i].patchFlag = -2;
        }
      }
      return ret;
    }
    /*! #__NO_SIDE_EFFECTS__ */
    // @__NO_SIDE_EFFECTS__
    function defineComponent(options, extraOptions) {
      return isFunction$2(options) ? (
        // #8326: extend call and options.name access are considered side-effects
        // by Rollup, so we have to wrap it in a pure-annotated IIFE.
        /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
      ) : options;
    }
    const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
    const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
    function onActivated(hook, target) {
      registerKeepAliveHook(hook, "a", target);
    }
    function onDeactivated(hook, target) {
      registerKeepAliveHook(hook, "da", target);
    }
    function registerKeepAliveHook(hook, type2, target = currentInstance) {
      const wrappedHook = hook.__wdc || (hook.__wdc = () => {
        let current = target;
        while (current) {
          if (current.isDeactivated) {
            return;
          }
          current = current.parent;
        }
        return hook();
      });
      injectHook(type2, wrappedHook, target);
      if (target) {
        let current = target.parent;
        while (current && current.parent) {
          if (isKeepAlive(current.parent.vnode)) {
            injectToKeepAliveRoot(wrappedHook, type2, target, current);
          }
          current = current.parent;
        }
      }
    }
    function injectToKeepAliveRoot(hook, type2, target, keepAliveRoot) {
      const injected = injectHook(
        type2,
        hook,
        keepAliveRoot,
        true
        /* prepend */
      );
      onUnmounted(() => {
        remove(keepAliveRoot[type2], injected);
      }, target);
    }
    function injectHook(type2, hook, target = currentInstance, prepend = false) {
      if (target) {
        const hooks = target[type2] || (target[type2] = []);
        const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
          if (target.isUnmounted) {
            return;
          }
          pauseTracking();
          setCurrentInstance(target);
          const res = callWithAsyncErrorHandling(hook, target, type2, args);
          unsetCurrentInstance();
          resetTracking();
          return res;
        });
        if (prepend) {
          hooks.unshift(wrappedHook);
        } else {
          hooks.push(wrappedHook);
        }
        return wrappedHook;
      }
    }
    const createHook = (lifecycle) => (hook, target = currentInstance) => (
      // post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
      (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target)
    );
    const onBeforeMount = createHook("bm");
    const onMounted = createHook("m");
    const onBeforeUpdate = createHook("bu");
    const onUpdated = createHook("u");
    const onBeforeUnmount = createHook("bum");
    const onUnmounted = createHook("um");
    const onServerPrefetch = createHook("sp");
    const onRenderTriggered = createHook(
      "rtg"
    );
    const onRenderTracked = createHook(
      "rtc"
    );
    function onErrorCaptured(hook, target = currentInstance) {
      injectHook("ec", hook, target);
    }
    function renderList(source, renderItem, cache2, index2) {
      let ret;
      const cached = cache2 && cache2[index2];
      if (isArray$3(source) || isString$1(source)) {
        ret = new Array(source.length);
        for (let i = 0, l2 = source.length; i < l2; i++) {
          ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
        }
      } else if (typeof source === "number") {
        ret = new Array(source);
        for (let i = 0; i < source; i++) {
          ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
        }
      } else if (isObject$1(source)) {
        if (source[Symbol.iterator]) {
          ret = Array.from(
            source,
            (item, i) => renderItem(item, i, void 0, cached && cached[i])
          );
        } else {
          const keys2 = Object.keys(source);
          ret = new Array(keys2.length);
          for (let i = 0, l2 = keys2.length; i < l2; i++) {
            const key = keys2[i];
            ret[i] = renderItem(source[key], key, i, cached && cached[i]);
          }
        }
      } else {
        ret = [];
      }
      if (cache2) {
        cache2[index2] = ret;
      }
      return ret;
    }
    function createSlots(slots, dynamicSlots) {
      for (let i = 0; i < dynamicSlots.length; i++) {
        const slot = dynamicSlots[i];
        if (isArray$3(slot)) {
          for (let j = 0; j < slot.length; j++) {
            slots[slot[j].name] = slot[j].fn;
          }
        } else if (slot) {
          slots[slot.name] = slot.key ? (...args) => {
            const res = slot.fn(...args);
            if (res)
              res.key = slot.key;
            return res;
          } : slot.fn;
        }
      }
      return slots;
    }
    function renderSlot(slots, name, props = {}, fallback, noSlotted) {
      if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
        if (name !== "default")
          props.name = name;
        return createVNode("slot", props, fallback && fallback());
      }
      let slot = slots[name];
      if (slot && slot._c) {
        slot._d = false;
      }
      openBlock();
      const validSlotContent = slot && ensureValidVNode(slot(props));
      const rendered = createBlock(
        Fragment,
        {
          key: props.key || // slot content array of a dynamic conditional slot may have a branch
          // key attached in the `createSlots` helper, respect that
          validSlotContent && validSlotContent.key || `_${name}`
        },
        validSlotContent || (fallback ? fallback() : []),
        validSlotContent && slots._ === 1 ? 64 : -2
      );
      if (!noSlotted && rendered.scopeId) {
        rendered.slotScopeIds = [rendered.scopeId + "-s"];
      }
      if (slot && slot._c) {
        slot._d = true;
      }
      return rendered;
    }
    function ensureValidVNode(vnodes) {
      return vnodes.some((child) => {
        if (!isVNode(child))
          return true;
        if (child.type === Comment)
          return false;
        if (child.type === Fragment && !ensureValidVNode(child.children))
          return false;
        return true;
      }) ? vnodes : null;
    }
    function toHandlers(obj, preserveCaseIfNecessary) {
      const ret = {};
      for (const key in obj) {
        ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
      }
      return ret;
    }
    const getPublicInstance = (i) => {
      if (!i)
        return null;
      if (isStatefulComponent(i))
        return getExposeProxy(i) || i.proxy;
      return getPublicInstance(i.parent);
    };
    const publicPropertiesMap = (
      // Move PURE marker to new line to workaround compiler discarding it
      // due to type annotation
      /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
        $: (i) => i,
        $el: (i) => i.vnode.el,
        $data: (i) => i.data,
        $props: (i) => i.props,
        $attrs: (i) => i.attrs,
        $slots: (i) => i.slots,
        $refs: (i) => i.refs,
        $parent: (i) => getPublicInstance(i.parent),
        $root: (i) => getPublicInstance(i.root),
        $emit: (i) => i.emit,
        $options: (i) => resolveMergedOptions(i),
        $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
        $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
        $watch: (i) => instanceWatch.bind(i)
      })
    );
    const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
    const PublicInstanceProxyHandlers = {
      get({ _: instance }, key) {
        const { ctx, setupState, data, props, accessCache, type: type2, appContext } = instance;
        let normalizedProps;
        if (key[0] !== "$") {
          const n = accessCache[key];
          if (n !== void 0) {
            switch (n) {
              case 1:
                return setupState[key];
              case 2:
                return data[key];
              case 4:
                return ctx[key];
              case 3:
                return props[key];
            }
          } else if (hasSetupBinding(setupState, key)) {
            accessCache[key] = 1;
            return setupState[key];
          } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
            accessCache[key] = 2;
            return data[key];
          } else if (
            // only cache other properties when instance has declared (thus stable)
            // props
            (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
          ) {
            accessCache[key] = 3;
            return props[key];
          } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
            accessCache[key] = 4;
            return ctx[key];
          } else if (shouldCacheAccess) {
            accessCache[key] = 0;
          }
        }
        const publicGetter = publicPropertiesMap[key];
        let cssModule, globalProperties;
        if (publicGetter) {
          if (key === "$attrs") {
            track(instance, "get", key);
          }
          return publicGetter(instance);
        } else if (
          // css module (injected by vue-loader)
          (cssModule = type2.__cssModules) && (cssModule = cssModule[key])
        ) {
          return cssModule;
        } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
          accessCache[key] = 4;
          return ctx[key];
        } else if (
          // global properties
          globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
        ) {
          {
            return globalProperties[key];
          }
        } else
          ;
      },
      set({ _: instance }, key, value) {
        const { data, setupState, ctx } = instance;
        if (hasSetupBinding(setupState, key)) {
          setupState[key] = value;
          return true;
        } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
          data[key] = value;
          return true;
        } else if (hasOwn(instance.props, key)) {
          return false;
        }
        if (key[0] === "$" && key.slice(1) in instance) {
          return false;
        } else {
          {
            ctx[key] = value;
          }
        }
        return true;
      },
      has({
        _: { data, setupState, accessCache, ctx, appContext, propsOptions }
      }, key) {
        let normalizedProps;
        return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
      },
      defineProperty(target, key, descriptor) {
        if (descriptor.get != null) {
          target._.accessCache[key] = 0;
        } else if (hasOwn(descriptor, "value")) {
          this.set(target, key, descriptor.value, null);
        }
        return Reflect.defineProperty(target, key, descriptor);
      }
    };
    function useSlots() {
      return getContext().slots;
    }
    function useAttrs$1() {
      return getContext().attrs;
    }
    function getContext() {
      const i = getCurrentInstance();
      return i.setupContext || (i.setupContext = createSetupContext(i));
    }
    function normalizePropsOrEmits(props) {
      return isArray$3(props) ? props.reduce(
        (normalized, p2) => (normalized[p2] = null, normalized),
        {}
      ) : props;
    }
    let shouldCacheAccess = true;
    function applyOptions(instance) {
      const options = resolveMergedOptions(instance);
      const publicThis = instance.proxy;
      const ctx = instance.ctx;
      shouldCacheAccess = false;
      if (options.beforeCreate) {
        callHook$1(options.beforeCreate, instance, "bc");
      }
      const {
        // state
        data: dataOptions,
        computed: computedOptions,
        methods,
        watch: watchOptions,
        provide: provideOptions,
        inject: injectOptions,
        // lifecycle
        created,
        beforeMount,
        mounted,
        beforeUpdate,
        updated,
        activated,
        deactivated,
        beforeDestroy,
        beforeUnmount,
        destroyed,
        unmounted,
        render: render2,
        renderTracked,
        renderTriggered,
        errorCaptured,
        serverPrefetch,
        // public API
        expose,
        inheritAttrs,
        // assets
        components,
        directives,
        filters
      } = options;
      const checkDuplicateProperties = null;
      if (injectOptions) {
        resolveInjections(injectOptions, ctx, checkDuplicateProperties);
      }
      if (methods) {
        for (const key in methods) {
          const methodHandler = methods[key];
          if (isFunction$2(methodHandler)) {
            {
              ctx[key] = methodHandler.bind(publicThis);
            }
          }
        }
      }
      if (dataOptions) {
        const data = dataOptions.call(publicThis, publicThis);
        if (!isObject$1(data))
          ;
        else {
          instance.data = reactive(data);
        }
      }
      shouldCacheAccess = true;
      if (computedOptions) {
        for (const key in computedOptions) {
          const opt = computedOptions[key];
          const get2 = isFunction$2(opt) ? opt.bind(publicThis, publicThis) : isFunction$2(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
          const set2 = !isFunction$2(opt) && isFunction$2(opt.set) ? opt.set.bind(publicThis) : NOOP;
          const c2 = computed({
            get: get2,
            set: set2
          });
          Object.defineProperty(ctx, key, {
            enumerable: true,
            configurable: true,
            get: () => c2.value,
            set: (v2) => c2.value = v2
          });
        }
      }
      if (watchOptions) {
        for (const key in watchOptions) {
          createWatcher(watchOptions[key], ctx, publicThis, key);
        }
      }
      if (provideOptions) {
        const provides = isFunction$2(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
        Reflect.ownKeys(provides).forEach((key) => {
          provide(key, provides[key]);
        });
      }
      if (created) {
        callHook$1(created, instance, "c");
      }
      function registerLifecycleHook(register, hook) {
        if (isArray$3(hook)) {
          hook.forEach((_hook) => register(_hook.bind(publicThis)));
        } else if (hook) {
          register(hook.bind(publicThis));
        }
      }
      registerLifecycleHook(onBeforeMount, beforeMount);
      registerLifecycleHook(onMounted, mounted);
      registerLifecycleHook(onBeforeUpdate, beforeUpdate);
      registerLifecycleHook(onUpdated, updated);
      registerLifecycleHook(onActivated, activated);
      registerLifecycleHook(onDeactivated, deactivated);
      registerLifecycleHook(onErrorCaptured, errorCaptured);
      registerLifecycleHook(onRenderTracked, renderTracked);
      registerLifecycleHook(onRenderTriggered, renderTriggered);
      registerLifecycleHook(onBeforeUnmount, beforeUnmount);
      registerLifecycleHook(onUnmounted, unmounted);
      registerLifecycleHook(onServerPrefetch, serverPrefetch);
      if (isArray$3(expose)) {
        if (expose.length) {
          const exposed = instance.exposed || (instance.exposed = {});
          expose.forEach((key) => {
            Object.defineProperty(exposed, key, {
              get: () => publicThis[key],
              set: (val) => publicThis[key] = val
            });
          });
        } else if (!instance.exposed) {
          instance.exposed = {};
        }
      }
      if (render2 && instance.render === NOOP) {
        instance.render = render2;
      }
      if (inheritAttrs != null) {
        instance.inheritAttrs = inheritAttrs;
      }
      if (components)
        instance.components = components;
      if (directives)
        instance.directives = directives;
    }
    function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
      if (isArray$3(injectOptions)) {
        injectOptions = normalizeInject(injectOptions);
      }
      for (const key in injectOptions) {
        const opt = injectOptions[key];
        let injected;
        if (isObject$1(opt)) {
          if ("default" in opt) {
            injected = inject(
              opt.from || key,
              opt.default,
              true
              /* treat default function as factory */
            );
          } else {
            injected = inject(opt.from || key);
          }
        } else {
          injected = inject(opt);
        }
        if (isRef(injected)) {
          Object.defineProperty(ctx, key, {
            enumerable: true,
            configurable: true,
            get: () => injected.value,
            set: (v2) => injected.value = v2
          });
        } else {
          ctx[key] = injected;
        }
      }
    }
    function callHook$1(hook, instance, type2) {
      callWithAsyncErrorHandling(
        isArray$3(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy),
        instance,
        type2
      );
    }
    function createWatcher(raw, ctx, publicThis, key) {
      const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
      if (isString$1(raw)) {
        const handler = ctx[raw];
        if (isFunction$2(handler)) {
          watch(getter, handler);
        }
      } else if (isFunction$2(raw)) {
        watch(getter, raw.bind(publicThis));
      } else if (isObject$1(raw)) {
        if (isArray$3(raw)) {
          raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
        } else {
          const handler = isFunction$2(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
          if (isFunction$2(handler)) {
            watch(getter, handler, raw);
          }
        }
      } else
        ;
    }
    function resolveMergedOptions(instance) {
      const base = instance.type;
      const { mixins, extends: extendsOptions } = base;
      const {
        mixins: globalMixins,
        optionsCache: cache2,
        config: { optionMergeStrategies }
      } = instance.appContext;
      const cached = cache2.get(base);
      let resolved;
      if (cached) {
        resolved = cached;
      } else if (!globalMixins.length && !mixins && !extendsOptions) {
        {
          resolved = base;
        }
      } else {
        resolved = {};
        if (globalMixins.length) {
          globalMixins.forEach(
            (m2) => mergeOptions$2(resolved, m2, optionMergeStrategies, true)
          );
        }
        mergeOptions$2(resolved, base, optionMergeStrategies);
      }
      if (isObject$1(base)) {
        cache2.set(base, resolved);
      }
      return resolved;
    }
    function mergeOptions$2(to, from, strats, asMixin = false) {
      const { mixins, extends: extendsOptions } = from;
      if (extendsOptions) {
        mergeOptions$2(to, extendsOptions, strats, true);
      }
      if (mixins) {
        mixins.forEach(
          (m2) => mergeOptions$2(to, m2, strats, true)
        );
      }
      for (const key in from) {
        if (asMixin && key === "expose")
          ;
        else {
          const strat = internalOptionMergeStrats[key] || strats && strats[key];
          to[key] = strat ? strat(to[key], from[key]) : from[key];
        }
      }
      return to;
    }
    const internalOptionMergeStrats = {
      data: mergeDataFn,
      props: mergeEmitsOrPropsOptions,
      emits: mergeEmitsOrPropsOptions,
      // objects
      methods: mergeObjectOptions,
      computed: mergeObjectOptions,
      // lifecycle
      beforeCreate: mergeAsArray,
      created: mergeAsArray,
      beforeMount: mergeAsArray,
      mounted: mergeAsArray,
      beforeUpdate: mergeAsArray,
      updated: mergeAsArray,
      beforeDestroy: mergeAsArray,
      beforeUnmount: mergeAsArray,
      destroyed: mergeAsArray,
      unmounted: mergeAsArray,
      activated: mergeAsArray,
      deactivated: mergeAsArray,
      errorCaptured: mergeAsArray,
      serverPrefetch: mergeAsArray,
      // assets
      components: mergeObjectOptions,
      directives: mergeObjectOptions,
      // watch
      watch: mergeWatchOptions,
      // provide / inject
      provide: mergeDataFn,
      inject: mergeInject
    };
    function mergeDataFn(to, from) {
      if (!from) {
        return to;
      }
      if (!to) {
        return from;
      }
      return function mergedDataFn() {
        return extend(
          isFunction$2(to) ? to.call(this, this) : to,
          isFunction$2(from) ? from.call(this, this) : from
        );
      };
    }
    function mergeInject(to, from) {
      return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
    }
    function normalizeInject(raw) {
      if (isArray$3(raw)) {
        const res = {};
        for (let i = 0; i < raw.length; i++) {
          res[raw[i]] = raw[i];
        }
        return res;
      }
      return raw;
    }
    function mergeAsArray(to, from) {
      return to ? [...new Set([].concat(to, from))] : from;
    }
    function mergeObjectOptions(to, from) {
      return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
    }
    function mergeEmitsOrPropsOptions(to, from) {
      if (to) {
        if (isArray$3(to) && isArray$3(from)) {
          return [.../* @__PURE__ */ new Set([...to, ...from])];
        }
        return extend(
          /* @__PURE__ */ Object.create(null),
          normalizePropsOrEmits(to),
          normalizePropsOrEmits(from != null ? from : {})
        );
      } else {
        return from;
      }
    }
    function mergeWatchOptions(to, from) {
      if (!to)
        return from;
      if (!from)
        return to;
      const merged = extend(/* @__PURE__ */ Object.create(null), to);
      for (const key in from) {
        merged[key] = mergeAsArray(to[key], from[key]);
      }
      return merged;
    }
    function createAppContext() {
      return {
        app: null,
        config: {
          isNativeTag: NO,
          performance: false,
          globalProperties: {},
          optionMergeStrategies: {},
          errorHandler: void 0,
          warnHandler: void 0,
          compilerOptions: {}
        },
        mixins: [],
        components: {},
        directives: {},
        provides: /* @__PURE__ */ Object.create(null),
        optionsCache: /* @__PURE__ */ new WeakMap(),
        propsCache: /* @__PURE__ */ new WeakMap(),
        emitsCache: /* @__PURE__ */ new WeakMap()
      };
    }
    let uid$1 = 0;
    function createAppAPI(render2, hydrate) {
      return function createApp2(rootComponent, rootProps = null) {
        if (!isFunction$2(rootComponent)) {
          rootComponent = extend({}, rootComponent);
        }
        if (rootProps != null && !isObject$1(rootProps)) {
          rootProps = null;
        }
        const context = createAppContext();
        const installedPlugins = /* @__PURE__ */ new WeakSet();
        let isMounted = false;
        const app = context.app = {
          _uid: uid$1++,
          _component: rootComponent,
          _props: rootProps,
          _container: null,
          _context: context,
          _instance: null,
          version: version$1,
          get config() {
            return context.config;
          },
          set config(v2) {
          },
          use(plugin, ...options) {
            if (installedPlugins.has(plugin))
              ;
            else if (plugin && isFunction$2(plugin.install)) {
              installedPlugins.add(plugin);
              plugin.install(app, ...options);
            } else if (isFunction$2(plugin)) {
              installedPlugins.add(plugin);
              plugin(app, ...options);
            } else
              ;
            return app;
          },
          mixin(mixin) {
            {
              if (!context.mixins.includes(mixin)) {
                context.mixins.push(mixin);
              }
            }
            return app;
          },
          component(name, component2) {
            if (!component2) {
              return context.components[name];
            }
            context.components[name] = component2;
            return app;
          },
          directive(name, directive) {
            if (!directive) {
              return context.directives[name];
            }
            context.directives[name] = directive;
            return app;
          },
          mount(rootContainer, isHydrate, isSVG) {
            if (!isMounted) {
              const vnode = createVNode(rootComponent, rootProps);
              vnode.appContext = context;
              if (isHydrate && hydrate) {
                hydrate(vnode, rootContainer);
              } else {
                render2(vnode, rootContainer, isSVG);
              }
              isMounted = true;
              app._container = rootContainer;
              rootContainer.__vue_app__ = app;
              return getExposeProxy(vnode.component) || vnode.component.proxy;
            }
          },
          unmount() {
            if (isMounted) {
              render2(null, app._container);
              delete app._container.__vue_app__;
            }
          },
          provide(key, value) {
            context.provides[key] = value;
            return app;
          },
          runWithContext(fn2) {
            currentApp = app;
            try {
              return fn2();
            } finally {
              currentApp = null;
            }
          }
        };
        return app;
      };
    }
    let currentApp = null;
    function provide(key, value) {
      if (!currentInstance)
        ;
      else {
        let provides = currentInstance.provides;
        const parentProvides = currentInstance.parent && currentInstance.parent.provides;
        if (parentProvides === provides) {
          provides = currentInstance.provides = Object.create(parentProvides);
        }
        provides[key] = value;
      }
    }
    function inject(key, defaultValue, treatDefaultAsFactory = false) {
      const instance = currentInstance || currentRenderingInstance;
      if (instance || currentApp) {
        const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
        if (provides && key in provides) {
          return provides[key];
        } else if (arguments.length > 1) {
          return treatDefaultAsFactory && isFunction$2(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
        } else
          ;
      }
    }
    function hasInjectionContext() {
      return !!(currentInstance || currentRenderingInstance || currentApp);
    }
    function initProps(instance, rawProps, isStateful, isSSR = false) {
      const props = {};
      const attrs = {};
      def(attrs, InternalObjectKey, 1);
      instance.propsDefaults = /* @__PURE__ */ Object.create(null);
      setFullProps(instance, rawProps, props, attrs);
      for (const key in instance.propsOptions[0]) {
        if (!(key in props)) {
          props[key] = void 0;
        }
      }
      if (isStateful) {
        instance.props = isSSR ? props : shallowReactive(props);
      } else {
        if (!instance.type.props) {
          instance.props = attrs;
        } else {
          instance.props = props;
        }
      }
      instance.attrs = attrs;
    }
    function updateProps(instance, rawProps, rawPrevProps, optimized) {
      const {
        props,
        attrs,
        vnode: { patchFlag }
      } = instance;
      const rawCurrentProps = toRaw(props);
      const [options] = instance.propsOptions;
      let hasAttrsChanged = false;
      if (
        // always force full diff in dev
        // - #1942 if hmr is enabled with sfc component
        // - vite#872 non-sfc component used by sfc component
        (optimized || patchFlag > 0) && !(patchFlag & 16)
      ) {
        if (patchFlag & 8) {
          const propsToUpdate = instance.vnode.dynamicProps;
          for (let i = 0; i < propsToUpdate.length; i++) {
            let key = propsToUpdate[i];
            if (isEmitListener(instance.emitsOptions, key)) {
              continue;
            }
            const value = rawProps[key];
            if (options) {
              if (hasOwn(attrs, key)) {
                if (value !== attrs[key]) {
                  attrs[key] = value;
                  hasAttrsChanged = true;
                }
              } else {
                const camelizedKey = camelize(key);
                props[camelizedKey] = resolvePropValue(
                  options,
                  rawCurrentProps,
                  camelizedKey,
                  value,
                  instance,
                  false
                  /* isAbsent */
                );
              }
            } else {
              if (value !== attrs[key]) {
                attrs[key] = value;
                hasAttrsChanged = true;
              }
            }
          }
        }
      } else {
        if (setFullProps(instance, rawProps, props, attrs)) {
          hasAttrsChanged = true;
        }
        let kebabKey;
        for (const key in rawCurrentProps) {
          if (!rawProps || // for camelCase
          !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
          // and converted to camelCase (#955)
          ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
            if (options) {
              if (rawPrevProps && // for camelCase
              (rawPrevProps[key] !== void 0 || // for kebab-case
              rawPrevProps[kebabKey] !== void 0)) {
                props[key] = resolvePropValue(
                  options,
                  rawCurrentProps,
                  key,
                  void 0,
                  instance,
                  true
                  /* isAbsent */
                );
              }
            } else {
              delete props[key];
            }
          }
        }
        if (attrs !== rawCurrentProps) {
          for (const key in attrs) {
            if (!rawProps || !hasOwn(rawProps, key) && true) {
              delete attrs[key];
              hasAttrsChanged = true;
            }
          }
        }
      }
      if (hasAttrsChanged) {
        trigger(instance, "set", "$attrs");
      }
    }
    function setFullProps(instance, rawProps, props, attrs) {
      const [options, needCastKeys] = instance.propsOptions;
      let hasAttrsChanged = false;
      let rawCastValues;
      if (rawProps) {
        for (let key in rawProps) {
          if (isReservedProp(key)) {
            continue;
          }
          const value = rawProps[key];
          let camelKey;
          if (options && hasOwn(options, camelKey = camelize(key))) {
            if (!needCastKeys || !needCastKeys.includes(camelKey)) {
              props[camelKey] = value;
            } else {
              (rawCastValues || (rawCastValues = {}))[camelKey] = value;
            }
          } else if (!isEmitListener(instance.emitsOptions, key)) {
            if (!(key in attrs) || value !== attrs[key]) {
              attrs[key] = value;
              hasAttrsChanged = true;
            }
          }
        }
      }
      if (needCastKeys) {
        const rawCurrentProps = toRaw(props);
        const castValues = rawCastValues || EMPTY_OBJ;
        for (let i = 0; i < needCastKeys.length; i++) {
          const key = needCastKeys[i];
          props[key] = resolvePropValue(
            options,
            rawCurrentProps,
            key,
            castValues[key],
            instance,
            !hasOwn(castValues, key)
          );
        }
      }
      return hasAttrsChanged;
    }
    function resolvePropValue(options, props, key, value, instance, isAbsent2) {
      const opt = options[key];
      if (opt != null) {
        const hasDefault = hasOwn(opt, "default");
        if (hasDefault && value === void 0) {
          const defaultValue = opt.default;
          if (opt.type !== Function && !opt.skipFactory && isFunction$2(defaultValue)) {
            const { propsDefaults } = instance;
            if (key in propsDefaults) {
              value = propsDefaults[key];
            } else {
              setCurrentInstance(instance);
              value = propsDefaults[key] = defaultValue.call(
                null,
                props
              );
              unsetCurrentInstance();
            }
          } else {
            value = defaultValue;
          }
        }
        if (opt[
          0
          /* shouldCast */
        ]) {
          if (isAbsent2 && !hasDefault) {
            value = false;
          } else if (opt[
            1
            /* shouldCastTrue */
          ] && (value === "" || value === hyphenate(key))) {
            value = true;
          }
        }
      }
      return value;
    }
    function normalizePropsOptions(comp, appContext, asMixin = false) {
      const cache2 = appContext.propsCache;
      const cached = cache2.get(comp);
      if (cached) {
        return cached;
      }
      const raw = comp.props;
      const normalized = {};
      const needCastKeys = [];
      let hasExtends = false;
      if (!isFunction$2(comp)) {
        const extendProps = (raw2) => {
          hasExtends = true;
          const [props, keys2] = normalizePropsOptions(raw2, appContext, true);
          extend(normalized, props);
          if (keys2)
            needCastKeys.push(...keys2);
        };
        if (!asMixin && appContext.mixins.length) {
          appContext.mixins.forEach(extendProps);
        }
        if (comp.extends) {
          extendProps(comp.extends);
        }
        if (comp.mixins) {
          comp.mixins.forEach(extendProps);
        }
      }
      if (!raw && !hasExtends) {
        if (isObject$1(comp)) {
          cache2.set(comp, EMPTY_ARR);
        }
        return EMPTY_ARR;
      }
      if (isArray$3(raw)) {
        for (let i = 0; i < raw.length; i++) {
          const normalizedKey = camelize(raw[i]);
          if (validatePropName(normalizedKey)) {
            normalized[normalizedKey] = EMPTY_OBJ;
          }
        }
      } else if (raw) {
        for (const key in raw) {
          const normalizedKey = camelize(key);
          if (validatePropName(normalizedKey)) {
            const opt = raw[key];
            const prop = normalized[normalizedKey] = isArray$3(opt) || isFunction$2(opt) ? { type: opt } : extend({}, opt);
            if (prop) {
              const booleanIndex = getTypeIndex(Boolean, prop.type);
              const stringIndex = getTypeIndex(String, prop.type);
              prop[
                0
                /* shouldCast */
              ] = booleanIndex > -1;
              prop[
                1
                /* shouldCastTrue */
              ] = stringIndex < 0 || booleanIndex < stringIndex;
              if (booleanIndex > -1 || hasOwn(prop, "default")) {
                needCastKeys.push(normalizedKey);
              }
            }
          }
        }
      }
      const res = [normalized, needCastKeys];
      if (isObject$1(comp)) {
        cache2.set(comp, res);
      }
      return res;
    }
    function validatePropName(key) {
      if (key[0] !== "$") {
        return true;
      }
      return false;
    }
    function getType(ctor) {
      const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
      return match ? match[2] : ctor === null ? "null" : "";
    }
    function isSameType(a2, b2) {
      return getType(a2) === getType(b2);
    }
    function getTypeIndex(type2, expectedTypes) {
      if (isArray$3(expectedTypes)) {
        return expectedTypes.findIndex((t) => isSameType(t, type2));
      } else if (isFunction$2(expectedTypes)) {
        return isSameType(expectedTypes, type2) ? 0 : -1;
      }
      return -1;
    }
    const isInternalKey = (key) => key[0] === "_" || key === "$stable";
    const normalizeSlotValue = (value) => isArray$3(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
    const normalizeSlot$1 = (key, rawSlot, ctx) => {
      if (rawSlot._n) {
        return rawSlot;
      }
      const normalized = withCtx((...args) => {
        if (false)
          ;
        return normalizeSlotValue(rawSlot(...args));
      }, ctx);
      normalized._c = false;
      return normalized;
    };
    const normalizeObjectSlots = (rawSlots, slots, instance) => {
      const ctx = rawSlots._ctx;
      for (const key in rawSlots) {
        if (isInternalKey(key))
          continue;
        const value = rawSlots[key];
        if (isFunction$2(value)) {
          slots[key] = normalizeSlot$1(key, value, ctx);
        } else if (value != null) {
          const normalized = normalizeSlotValue(value);
          slots[key] = () => normalized;
        }
      }
    };
    const normalizeVNodeSlots = (instance, children) => {
      const normalized = normalizeSlotValue(children);
      instance.slots.default = () => normalized;
    };
    const initSlots = (instance, children) => {
      if (instance.vnode.shapeFlag & 32) {
        const type2 = children._;
        if (type2) {
          instance.slots = toRaw(children);
          def(children, "_", type2);
        } else {
          normalizeObjectSlots(
            children,
            instance.slots = {}
          );
        }
      } else {
        instance.slots = {};
        if (children) {
          normalizeVNodeSlots(instance, children);
        }
      }
      def(instance.slots, InternalObjectKey, 1);
    };
    const updateSlots = (instance, children, optimized) => {
      const { vnode, slots } = instance;
      let needDeletionCheck = true;
      let deletionComparisonTarget = EMPTY_OBJ;
      if (vnode.shapeFlag & 32) {
        const type2 = children._;
        if (type2) {
          if (optimized && type2 === 1) {
            needDeletionCheck = false;
          } else {
            extend(slots, children);
            if (!optimized && type2 === 1) {
              delete slots._;
            }
          }
        } else {
          needDeletionCheck = !children.$stable;
          normalizeObjectSlots(children, slots);
        }
        deletionComparisonTarget = children;
      } else if (children) {
        normalizeVNodeSlots(instance, children);
        deletionComparisonTarget = { default: 1 };
      }
      if (needDeletionCheck) {
        for (const key in slots) {
          if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
            delete slots[key];
          }
        }
      }
    };
    function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
      if (isArray$3(rawRef)) {
        rawRef.forEach(
          (r, i) => setRef(
            r,
            oldRawRef && (isArray$3(oldRawRef) ? oldRawRef[i] : oldRawRef),
            parentSuspense,
            vnode,
            isUnmount
          )
        );
        return;
      }
      if (isAsyncWrapper(vnode) && !isUnmount) {
        return;
      }
      const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
      const value = isUnmount ? null : refValue;
      const { i: owner, r: ref2 } = rawRef;
      const oldRef = oldRawRef && oldRawRef.r;
      const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
      const setupState = owner.setupState;
      if (oldRef != null && oldRef !== ref2) {
        if (isString$1(oldRef)) {
          refs[oldRef] = null;
          if (hasOwn(setupState, oldRef)) {
            setupState[oldRef] = null;
          }
        } else if (isRef(oldRef)) {
          oldRef.value = null;
        }
      }
      if (isFunction$2(ref2)) {
        callWithErrorHandling(ref2, owner, 12, [value, refs]);
      } else {
        const _isString = isString$1(ref2);
        const _isRef = isRef(ref2);
        if (_isString || _isRef) {
          const doSet = () => {
            if (rawRef.f) {
              const existing = _isString ? hasOwn(setupState, ref2) ? setupState[ref2] : refs[ref2] : ref2.value;
              if (isUnmount) {
                isArray$3(existing) && remove(existing, refValue);
              } else {
                if (!isArray$3(existing)) {
                  if (_isString) {
                    refs[ref2] = [refValue];
                    if (hasOwn(setupState, ref2)) {
                      setupState[ref2] = refs[ref2];
                    }
                  } else {
                    ref2.value = [refValue];
                    if (rawRef.k)
                      refs[rawRef.k] = ref2.value;
                  }
                } else if (!existing.includes(refValue)) {
                  existing.push(refValue);
                }
              }
            } else if (_isString) {
              refs[ref2] = value;
              if (hasOwn(setupState, ref2)) {
                setupState[ref2] = value;
              }
            } else if (_isRef) {
              ref2.value = value;
              if (rawRef.k)
                refs[rawRef.k] = value;
            } else
              ;
          };
          if (value) {
            doSet.id = -1;
            queuePostRenderEffect(doSet, parentSuspense);
          } else {
            doSet();
          }
        }
      }
    }
    const queuePostRenderEffect = queueEffectWithSuspense;
    function createRenderer(options) {
      return baseCreateRenderer(options);
    }
    function baseCreateRenderer(options, createHydrationFns) {
      const target = getGlobalThis();
      target.__VUE__ = true;
      const {
        insert: hostInsert,
        remove: hostRemove,
        patchProp: hostPatchProp,
        createElement: hostCreateElement,
        createText: hostCreateText,
        createComment: hostCreateComment,
        setText: hostSetText,
        setElementText: hostSetElementText,
        parentNode: hostParentNode,
        nextSibling: hostNextSibling,
        setScopeId: hostSetScopeId = NOOP,
        insertStaticContent: hostInsertStaticContent
      } = options;
      const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
        if (n1 === n2) {
          return;
        }
        if (n1 && !isSameVNodeType(n1, n2)) {
          anchor = getNextHostNode(n1);
          unmount(n1, parentComponent, parentSuspense, true);
          n1 = null;
        }
        if (n2.patchFlag === -2) {
          optimized = false;
          n2.dynamicChildren = null;
        }
        const { type: type2, ref: ref2, shapeFlag } = n2;
        switch (type2) {
          case Text$1:
            processText(n1, n2, container, anchor);
            break;
          case Comment:
            processCommentNode(n1, n2, container, anchor);
            break;
          case Static:
            if (n1 == null) {
              mountStaticNode(n2, container, anchor, isSVG);
            }
            break;
          case Fragment:
            processFragment(
              n1,
              n2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds,
              optimized
            );
            break;
          default:
            if (shapeFlag & 1) {
              processElement(
                n1,
                n2,
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
            } else if (shapeFlag & 6) {
              processComponent(
                n1,
                n2,
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
            } else if (shapeFlag & 64) {
              type2.process(
                n1,
                n2,
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized,
                internals
              );
            } else if (shapeFlag & 128) {
              type2.process(
                n1,
                n2,
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized,
                internals
              );
            } else
              ;
        }
        if (ref2 != null && parentComponent) {
          setRef(ref2, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
        }
      };
      const processText = (n1, n2, container, anchor) => {
        if (n1 == null) {
          hostInsert(
            n2.el = hostCreateText(n2.children),
            container,
            anchor
          );
        } else {
          const el = n2.el = n1.el;
          if (n2.children !== n1.children) {
            hostSetText(el, n2.children);
          }
        }
      };
      const processCommentNode = (n1, n2, container, anchor) => {
        if (n1 == null) {
          hostInsert(
            n2.el = hostCreateComment(n2.children || ""),
            container,
            anchor
          );
        } else {
          n2.el = n1.el;
        }
      };
      const mountStaticNode = (n2, container, anchor, isSVG) => {
        [n2.el, n2.anchor] = hostInsertStaticContent(
          n2.children,
          container,
          anchor,
          isSVG,
          n2.el,
          n2.anchor
        );
      };
      const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
        let next;
        while (el && el !== anchor) {
          next = hostNextSibling(el);
          hostInsert(el, container, nextSibling);
          el = next;
        }
        hostInsert(anchor, container, nextSibling);
      };
      const removeStaticNode = ({ el, anchor }) => {
        let next;
        while (el && el !== anchor) {
          next = hostNextSibling(el);
          hostRemove(el);
          el = next;
        }
        hostRemove(anchor);
      };
      const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
        isSVG = isSVG || n2.type === "svg";
        if (n1 == null) {
          mountElement(
            n2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            isSVG,
            slotScopeIds,
            optimized
          );
        } else {
          patchElement(
            n1,
            n2,
            parentComponent,
            parentSuspense,
            isSVG,
            slotScopeIds,
            optimized
          );
        }
      };
      const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
        let el;
        let vnodeHook;
        const { type: type2, props, shapeFlag, transition, dirs } = vnode;
        el = vnode.el = hostCreateElement(
          vnode.type,
          isSVG,
          props && props.is,
          props
        );
        if (shapeFlag & 8) {
          hostSetElementText(el, vnode.children);
        } else if (shapeFlag & 16) {
          mountChildren(
            vnode.children,
            el,
            null,
            parentComponent,
            parentSuspense,
            isSVG && type2 !== "foreignObject",
            slotScopeIds,
            optimized
          );
        }
        if (dirs) {
          invokeDirectiveHook(vnode, null, parentComponent, "created");
        }
        setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
        if (props) {
          for (const key in props) {
            if (key !== "value" && !isReservedProp(key)) {
              hostPatchProp(
                el,
                key,
                null,
                props[key],
                isSVG,
                vnode.children,
                parentComponent,
                parentSuspense,
                unmountChildren
              );
            }
          }
          if ("value" in props) {
            hostPatchProp(el, "value", null, props.value);
          }
          if (vnodeHook = props.onVnodeBeforeMount) {
            invokeVNodeHook(vnodeHook, parentComponent, vnode);
          }
        }
        if (dirs) {
          invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
        }
        const needCallTransitionHooks = needTransition(parentSuspense, transition);
        if (needCallTransitionHooks) {
          transition.beforeEnter(el);
        }
        hostInsert(el, container, anchor);
        if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
          queuePostRenderEffect(() => {
            vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
            needCallTransitionHooks && transition.enter(el);
            dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
          }, parentSuspense);
        }
      };
      const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
        if (scopeId) {
          hostSetScopeId(el, scopeId);
        }
        if (slotScopeIds) {
          for (let i = 0; i < slotScopeIds.length; i++) {
            hostSetScopeId(el, slotScopeIds[i]);
          }
        }
        if (parentComponent) {
          let subTree = parentComponent.subTree;
          if (vnode === subTree) {
            const parentVNode = parentComponent.vnode;
            setScopeId(
              el,
              parentVNode,
              parentVNode.scopeId,
              parentVNode.slotScopeIds,
              parentComponent.parent
            );
          }
        }
      };
      const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => {
        for (let i = start; i < children.length; i++) {
          const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
          patch(
            null,
            child,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            isSVG,
            slotScopeIds,
            optimized
          );
        }
      };
      const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
        const el = n2.el = n1.el;
        let { patchFlag, dynamicChildren, dirs } = n2;
        patchFlag |= n1.patchFlag & 16;
        const oldProps = n1.props || EMPTY_OBJ;
        const newProps = n2.props || EMPTY_OBJ;
        let vnodeHook;
        parentComponent && toggleRecurse(parentComponent, false);
        if (vnodeHook = newProps.onVnodeBeforeUpdate) {
          invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
        }
        if (dirs) {
          invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
        }
        parentComponent && toggleRecurse(parentComponent, true);
        const areChildrenSVG = isSVG && n2.type !== "foreignObject";
        if (dynamicChildren) {
          patchBlockChildren(
            n1.dynamicChildren,
            dynamicChildren,
            el,
            parentComponent,
            parentSuspense,
            areChildrenSVG,
            slotScopeIds
          );
        } else if (!optimized) {
          patchChildren(
            n1,
            n2,
            el,
            null,
            parentComponent,
            parentSuspense,
            areChildrenSVG,
            slotScopeIds,
            false
          );
        }
        if (patchFlag > 0) {
          if (patchFlag & 16) {
            patchProps(
              el,
              n2,
              oldProps,
              newProps,
              parentComponent,
              parentSuspense,
              isSVG
            );
          } else {
            if (patchFlag & 2) {
              if (oldProps.class !== newProps.class) {
                hostPatchProp(el, "class", null, newProps.class, isSVG);
              }
            }
            if (patchFlag & 4) {
              hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG);
            }
            if (patchFlag & 8) {
              const propsToUpdate = n2.dynamicProps;
              for (let i = 0; i < propsToUpdate.length; i++) {
                const key = propsToUpdate[i];
                const prev = oldProps[key];
                const next = newProps[key];
                if (next !== prev || key === "value") {
                  hostPatchProp(
                    el,
                    key,
                    prev,
                    next,
                    isSVG,
                    n1.children,
                    parentComponent,
                    parentSuspense,
                    unmountChildren
                  );
                }
              }
            }
          }
          if (patchFlag & 1) {
            if (n1.children !== n2.children) {
              hostSetElementText(el, n2.children);
            }
          }
        } else if (!optimized && dynamicChildren == null) {
          patchProps(
            el,
            n2,
            oldProps,
            newProps,
            parentComponent,
            parentSuspense,
            isSVG
          );
        }
        if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
          queuePostRenderEffect(() => {
            vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
            dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
          }, parentSuspense);
        }
      };
      const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => {
        for (let i = 0; i < newChildren.length; i++) {
          const oldVNode = oldChildren[i];
          const newVNode = newChildren[i];
          const container = (
            // oldVNode may be an errored async setup() component inside Suspense
            // which will not have a mounted element
            oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
            // of the Fragment itself so it can move its children.
            (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
            // which also requires the correct parent container
            !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
            oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
              // In other cases, the parent container is not actually used so we
              // just pass the block element here to avoid a DOM parentNode call.
              fallbackContainer
            )
          );
          patch(
            oldVNode,
            newVNode,
            container,
            null,
            parentComponent,
            parentSuspense,
            isSVG,
            slotScopeIds,
            true
          );
        }
      };
      const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
        if (oldProps !== newProps) {
          if (oldProps !== EMPTY_OBJ) {
            for (const key in oldProps) {
              if (!isReservedProp(key) && !(key in newProps)) {
                hostPatchProp(
                  el,
                  key,
                  oldProps[key],
                  null,
                  isSVG,
                  vnode.children,
                  parentComponent,
                  parentSuspense,
                  unmountChildren
                );
              }
            }
          }
          for (const key in newProps) {
            if (isReservedProp(key))
              continue;
            const next = newProps[key];
            const prev = oldProps[key];
            if (next !== prev && key !== "value") {
              hostPatchProp(
                el,
                key,
                prev,
                next,
                isSVG,
                vnode.children,
                parentComponent,
                parentSuspense,
                unmountChildren
              );
            }
          }
          if ("value" in newProps) {
            hostPatchProp(el, "value", oldProps.value, newProps.value);
          }
        }
      };
      const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
        const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
        const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
        let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
        if (fragmentSlotScopeIds) {
          slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
        }
        if (n1 == null) {
          hostInsert(fragmentStartAnchor, container, anchor);
          hostInsert(fragmentEndAnchor, container, anchor);
          mountChildren(
            n2.children,
            container,
            fragmentEndAnchor,
            parentComponent,
            parentSuspense,
            isSVG,
            slotScopeIds,
            optimized
          );
        } else {
          if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
          // of renderSlot() with no valid children
          n1.dynamicChildren) {
            patchBlockChildren(
              n1.dynamicChildren,
              dynamicChildren,
              container,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds
            );
            if (
              // #2080 if the stable fragment has a key, it's a <template v-for> that may
              //  get moved around. Make sure all root level vnodes inherit el.
              // #2134 or if it's a component root, it may also get moved around
              // as the component is being moved.
              n2.key != null || parentComponent && n2 === parentComponent.subTree
            ) {
              traverseStaticChildren(
                n1,
                n2,
                true
                /* shallow */
              );
            }
          } else {
            patchChildren(
              n1,
              n2,
              container,
              fragmentEndAnchor,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds,
              optimized
            );
          }
        }
      };
      const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
        n2.slotScopeIds = slotScopeIds;
        if (n1 == null) {
          if (n2.shapeFlag & 512) {
            parentComponent.ctx.activate(
              n2,
              container,
              anchor,
              isSVG,
              optimized
            );
          } else {
            mountComponent(
              n2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              isSVG,
              optimized
            );
          }
        } else {
          updateComponent(n1, n2, optimized);
        }
      };
      const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
        const instance = initialVNode.component = createComponentInstance(
          initialVNode,
          parentComponent,
          parentSuspense
        );
        if (isKeepAlive(initialVNode)) {
          instance.ctx.renderer = internals;
        }
        {
          setupComponent(instance);
        }
        if (instance.asyncDep) {
          parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);
          if (!initialVNode.el) {
            const placeholder = instance.subTree = createVNode(Comment);
            processCommentNode(null, placeholder, container, anchor);
          }
          return;
        }
        setupRenderEffect(
          instance,
          initialVNode,
          container,
          anchor,
          parentSuspense,
          isSVG,
          optimized
        );
      };
      const updateComponent = (n1, n2, optimized) => {
        const instance = n2.component = n1.component;
        if (shouldUpdateComponent(n1, n2, optimized)) {
          if (instance.asyncDep && !instance.asyncResolved) {
            updateComponentPreRender(instance, n2, optimized);
            return;
          } else {
            instance.next = n2;
            invalidateJob(instance.update);
            instance.update();
          }
        } else {
          n2.el = n1.el;
          instance.vnode = n2;
        }
      };
      const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {
        const componentUpdateFn = () => {
          if (!instance.isMounted) {
            let vnodeHook;
            const { el, props } = initialVNode;
            const { bm, m: m2, parent } = instance;
            const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
            toggleRecurse(instance, false);
            if (bm) {
              invokeArrayFns(bm);
            }
            if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
              invokeVNodeHook(vnodeHook, parent, initialVNode);
            }
            toggleRecurse(instance, true);
            if (el && hydrateNode) {
              const hydrateSubTree = () => {
                instance.subTree = renderComponentRoot(instance);
                hydrateNode(
                  el,
                  instance.subTree,
                  instance,
                  parentSuspense,
                  null
                );
              };
              if (isAsyncWrapperVNode) {
                initialVNode.type.__asyncLoader().then(
                  // note: we are moving the render call into an async callback,
                  // which means it won't track dependencies - but it's ok because
                  // a server-rendered async wrapper is already in resolved state
                  // and it will never need to change.
                  () => !instance.isUnmounted && hydrateSubTree()
                );
              } else {
                hydrateSubTree();
              }
            } else {
              const subTree = instance.subTree = renderComponentRoot(instance);
              patch(
                null,
                subTree,
                container,
                anchor,
                instance,
                parentSuspense,
                isSVG
              );
              initialVNode.el = subTree.el;
            }
            if (m2) {
              queuePostRenderEffect(m2, parentSuspense);
            }
            if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
              const scopedInitialVNode = initialVNode;
              queuePostRenderEffect(
                () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
                parentSuspense
              );
            }
            if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
              instance.a && queuePostRenderEffect(instance.a, parentSuspense);
            }
            instance.isMounted = true;
            initialVNode = container = anchor = null;
          } else {
            let { next, bu, u: u2, parent, vnode } = instance;
            let originNext = next;
            let vnodeHook;
            toggleRecurse(instance, false);
            if (next) {
              next.el = vnode.el;
              updateComponentPreRender(instance, next, optimized);
            } else {
              next = vnode;
            }
            if (bu) {
              invokeArrayFns(bu);
            }
            if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
              invokeVNodeHook(vnodeHook, parent, next, vnode);
            }
            toggleRecurse(instance, true);
            const nextTree = renderComponentRoot(instance);
            const prevTree = instance.subTree;
            instance.subTree = nextTree;
            patch(
              prevTree,
              nextTree,
              // parent may have changed if it's in a teleport
              hostParentNode(prevTree.el),
              // anchor may have changed if it's in a fragment
              getNextHostNode(prevTree),
              instance,
              parentSuspense,
              isSVG
            );
            next.el = nextTree.el;
            if (originNext === null) {
              updateHOCHostEl(instance, nextTree.el);
            }
            if (u2) {
              queuePostRenderEffect(u2, parentSuspense);
            }
            if (vnodeHook = next.props && next.props.onVnodeUpdated) {
              queuePostRenderEffect(
                () => invokeVNodeHook(vnodeHook, parent, next, vnode),
                parentSuspense
              );
            }
          }
        };
        const effect = instance.effect = new ReactiveEffect(
          componentUpdateFn,
          () => queueJob(update),
          instance.scope
          // track it in component's effect scope
        );
        const update = instance.update = () => effect.run();
        update.id = instance.uid;
        toggleRecurse(instance, true);
        update();
      };
      const updateComponentPreRender = (instance, nextVNode, optimized) => {
        nextVNode.component = instance;
        const prevProps = instance.vnode.props;
        instance.vnode = nextVNode;
        instance.next = null;
        updateProps(instance, nextVNode.props, prevProps, optimized);
        updateSlots(instance, nextVNode.children, optimized);
        pauseTracking();
        flushPreFlushCbs();
        resetTracking();
      };
      const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => {
        const c1 = n1 && n1.children;
        const prevShapeFlag = n1 ? n1.shapeFlag : 0;
        const c2 = n2.children;
        const { patchFlag, shapeFlag } = n2;
        if (patchFlag > 0) {
          if (patchFlag & 128) {
            patchKeyedChildren(
              c1,
              c2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds,
              optimized
            );
            return;
          } else if (patchFlag & 256) {
            patchUnkeyedChildren(
              c1,
              c2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds,
              optimized
            );
            return;
          }
        }
        if (shapeFlag & 8) {
          if (prevShapeFlag & 16) {
            unmountChildren(c1, parentComponent, parentSuspense);
          }
          if (c2 !== c1) {
            hostSetElementText(container, c2);
          }
        } else {
          if (prevShapeFlag & 16) {
            if (shapeFlag & 16) {
              patchKeyedChildren(
                c1,
                c2,
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
            } else {
              unmountChildren(c1, parentComponent, parentSuspense, true);
            }
          } else {
            if (prevShapeFlag & 8) {
              hostSetElementText(container, "");
            }
            if (shapeFlag & 16) {
              mountChildren(
                c2,
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
            }
          }
        }
      };
      const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
        c1 = c1 || EMPTY_ARR;
        c2 = c2 || EMPTY_ARR;
        const oldLength = c1.length;
        const newLength = c2.length;
        const commonLength = Math.min(oldLength, newLength);
        let i;
        for (i = 0; i < commonLength; i++) {
          const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
          patch(
            c1[i],
            nextChild,
            container,
            null,
            parentComponent,
            parentSuspense,
            isSVG,
            slotScopeIds,
            optimized
          );
        }
        if (oldLength > newLength) {
          unmountChildren(
            c1,
            parentComponent,
            parentSuspense,
            true,
            false,
            commonLength
          );
        } else {
          mountChildren(
            c2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            isSVG,
            slotScopeIds,
            optimized,
            commonLength
          );
        }
      };
      const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
        let i = 0;
        const l2 = c2.length;
        let e1 = c1.length - 1;
        let e2 = l2 - 1;
        while (i <= e1 && i <= e2) {
          const n1 = c1[i];
          const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
          if (isSameVNodeType(n1, n2)) {
            patch(
              n1,
              n2,
              container,
              null,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds,
              optimized
            );
          } else {
            break;
          }
          i++;
        }
        while (i <= e1 && i <= e2) {
          const n1 = c1[e1];
          const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
          if (isSameVNodeType(n1, n2)) {
            patch(
              n1,
              n2,
              container,
              null,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds,
              optimized
            );
          } else {
            break;
          }
          e1--;
          e2--;
        }
        if (i > e1) {
          if (i <= e2) {
            const nextPos = e2 + 1;
            const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
            while (i <= e2) {
              patch(
                null,
                c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
              i++;
            }
          }
        } else if (i > e2) {
          while (i <= e1) {
            unmount(c1[i], parentComponent, parentSuspense, true);
            i++;
          }
        } else {
          const s1 = i;
          const s2 = i;
          const keyToNewIndexMap = /* @__PURE__ */ new Map();
          for (i = s2; i <= e2; i++) {
            const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
            if (nextChild.key != null) {
              keyToNewIndexMap.set(nextChild.key, i);
            }
          }
          let j;
          let patched = 0;
          const toBePatched = e2 - s2 + 1;
          let moved = false;
          let maxNewIndexSoFar = 0;
          const newIndexToOldIndexMap = new Array(toBePatched);
          for (i = 0; i < toBePatched; i++)
            newIndexToOldIndexMap[i] = 0;
          for (i = s1; i <= e1; i++) {
            const prevChild = c1[i];
            if (patched >= toBePatched) {
              unmount(prevChild, parentComponent, parentSuspense, true);
              continue;
            }
            let newIndex;
            if (prevChild.key != null) {
              newIndex = keyToNewIndexMap.get(prevChild.key);
            } else {
              for (j = s2; j <= e2; j++) {
                if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
                  newIndex = j;
                  break;
                }
              }
            }
            if (newIndex === void 0) {
              unmount(prevChild, parentComponent, parentSuspense, true);
            } else {
              newIndexToOldIndexMap[newIndex - s2] = i + 1;
              if (newIndex >= maxNewIndexSoFar) {
                maxNewIndexSoFar = newIndex;
              } else {
                moved = true;
              }
              patch(
                prevChild,
                c2[newIndex],
                container,
                null,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
              patched++;
            }
          }
          const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
          j = increasingNewIndexSequence.length - 1;
          for (i = toBePatched - 1; i >= 0; i--) {
            const nextIndex = s2 + i;
            const nextChild = c2[nextIndex];
            const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
            if (newIndexToOldIndexMap[i] === 0) {
              patch(
                null,
                nextChild,
                container,
                anchor,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
            } else if (moved) {
              if (j < 0 || i !== increasingNewIndexSequence[j]) {
                move(nextChild, container, anchor, 2);
              } else {
                j--;
              }
            }
          }
        }
      };
      const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
        const { el, type: type2, transition, children, shapeFlag } = vnode;
        if (shapeFlag & 6) {
          move(vnode.component.subTree, container, anchor, moveType);
          return;
        }
        if (shapeFlag & 128) {
          vnode.suspense.move(container, anchor, moveType);
          return;
        }
        if (shapeFlag & 64) {
          type2.move(vnode, container, anchor, internals);
          return;
        }
        if (type2 === Fragment) {
          hostInsert(el, container, anchor);
          for (let i = 0; i < children.length; i++) {
            move(children[i], container, anchor, moveType);
          }
          hostInsert(vnode.anchor, container, anchor);
          return;
        }
        if (type2 === Static) {
          moveStaticNode(vnode, container, anchor);
          return;
        }
        const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
        if (needTransition2) {
          if (moveType === 0) {
            transition.beforeEnter(el);
            hostInsert(el, container, anchor);
            queuePostRenderEffect(() => transition.enter(el), parentSuspense);
          } else {
            const { leave, delayLeave, afterLeave } = transition;
            const remove22 = () => hostInsert(el, container, anchor);
            const performLeave = () => {
              leave(el, () => {
                remove22();
                afterLeave && afterLeave();
              });
            };
            if (delayLeave) {
              delayLeave(el, remove22, performLeave);
            } else {
              performLeave();
            }
          }
        } else {
          hostInsert(el, container, anchor);
        }
      };
      const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
        const {
          type: type2,
          props,
          ref: ref2,
          children,
          dynamicChildren,
          shapeFlag,
          patchFlag,
          dirs
        } = vnode;
        if (ref2 != null) {
          setRef(ref2, null, parentSuspense, vnode, true);
        }
        if (shapeFlag & 256) {
          parentComponent.ctx.deactivate(vnode);
          return;
        }
        const shouldInvokeDirs = shapeFlag & 1 && dirs;
        const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
        let vnodeHook;
        if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
          invokeVNodeHook(vnodeHook, parentComponent, vnode);
        }
        if (shapeFlag & 6) {
          unmountComponent(vnode.component, parentSuspense, doRemove);
        } else {
          if (shapeFlag & 128) {
            vnode.suspense.unmount(parentSuspense, doRemove);
            return;
          }
          if (shouldInvokeDirs) {
            invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
          }
          if (shapeFlag & 64) {
            vnode.type.remove(
              vnode,
              parentComponent,
              parentSuspense,
              optimized,
              internals,
              doRemove
            );
          } else if (dynamicChildren && // #1153: fast path should not be taken for non-stable (v-for) fragments
          (type2 !== Fragment || patchFlag > 0 && patchFlag & 64)) {
            unmountChildren(
              dynamicChildren,
              parentComponent,
              parentSuspense,
              false,
              true
            );
          } else if (type2 === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
            unmountChildren(children, parentComponent, parentSuspense);
          }
          if (doRemove) {
            remove2(vnode);
          }
        }
        if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
          queuePostRenderEffect(() => {
            vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
            shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
          }, parentSuspense);
        }
      };
      const remove2 = (vnode) => {
        const { type: type2, el, anchor, transition } = vnode;
        if (type2 === Fragment) {
          {
            removeFragment(el, anchor);
          }
          return;
        }
        if (type2 === Static) {
          removeStaticNode(vnode);
          return;
        }
        const performRemove = () => {
          hostRemove(el);
          if (transition && !transition.persisted && transition.afterLeave) {
            transition.afterLeave();
          }
        };
        if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
          const { leave, delayLeave } = transition;
          const performLeave = () => leave(el, performRemove);
          if (delayLeave) {
            delayLeave(vnode.el, performRemove, performLeave);
          } else {
            performLeave();
          }
        } else {
          performRemove();
        }
      };
      const removeFragment = (cur, end2) => {
        let next;
        while (cur !== end2) {
          next = hostNextSibling(cur);
          hostRemove(cur);
          cur = next;
        }
        hostRemove(end2);
      };
      const unmountComponent = (instance, parentSuspense, doRemove) => {
        const { bum, scope, update, subTree, um } = instance;
        if (bum) {
          invokeArrayFns(bum);
        }
        scope.stop();
        if (update) {
          update.active = false;
          unmount(subTree, instance, parentSuspense, doRemove);
        }
        if (um) {
          queuePostRenderEffect(um, parentSuspense);
        }
        queuePostRenderEffect(() => {
          instance.isUnmounted = true;
        }, parentSuspense);
        if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
          parentSuspense.deps--;
          if (parentSuspense.deps === 0) {
            parentSuspense.resolve();
          }
        }
      };
      const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
        for (let i = start; i < children.length; i++) {
          unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
        }
      };
      const getNextHostNode = (vnode) => {
        if (vnode.shapeFlag & 6) {
          return getNextHostNode(vnode.component.subTree);
        }
        if (vnode.shapeFlag & 128) {
          return vnode.suspense.next();
        }
        return hostNextSibling(vnode.anchor || vnode.el);
      };
      const render2 = (vnode, container, isSVG) => {
        if (vnode == null) {
          if (container._vnode) {
            unmount(container._vnode, null, null, true);
          }
        } else {
          patch(container._vnode || null, vnode, container, null, null, null, isSVG);
        }
        flushPreFlushCbs();
        flushPostFlushCbs();
        container._vnode = vnode;
      };
      const internals = {
        p: patch,
        um: unmount,
        m: move,
        r: remove2,
        mt: mountComponent,
        mc: mountChildren,
        pc: patchChildren,
        pbc: patchBlockChildren,
        n: getNextHostNode,
        o: options
      };
      let hydrate;
      let hydrateNode;
      if (createHydrationFns) {
        [hydrate, hydrateNode] = createHydrationFns(
          internals
        );
      }
      return {
        render: render2,
        hydrate,
        createApp: createAppAPI(render2, hydrate)
      };
    }
    function toggleRecurse({ effect, update }, allowed) {
      effect.allowRecurse = update.allowRecurse = allowed;
    }
    function needTransition(parentSuspense, transition) {
      return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
    }
    function traverseStaticChildren(n1, n2, shallow = false) {
      const ch1 = n1.children;
      const ch2 = n2.children;
      if (isArray$3(ch1) && isArray$3(ch2)) {
        for (let i = 0; i < ch1.length; i++) {
          const c1 = ch1[i];
          let c2 = ch2[i];
          if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
            if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
              c2 = ch2[i] = cloneIfMounted(ch2[i]);
              c2.el = c1.el;
            }
            if (!shallow)
              traverseStaticChildren(c1, c2);
          }
          if (c2.type === Text$1) {
            c2.el = c1.el;
          }
        }
      }
    }
    function getSequence(arr) {
      const p2 = arr.slice();
      const result = [0];
      let i, j, u2, v2, c2;
      const len = arr.length;
      for (i = 0; i < len; i++) {
        const arrI = arr[i];
        if (arrI !== 0) {
          j = result[result.length - 1];
          if (arr[j] < arrI) {
            p2[i] = j;
            result.push(i);
            continue;
          }
          u2 = 0;
          v2 = result.length - 1;
          while (u2 < v2) {
            c2 = u2 + v2 >> 1;
            if (arr[result[c2]] < arrI) {
              u2 = c2 + 1;
            } else {
              v2 = c2;
            }
          }
          if (arrI < arr[result[u2]]) {
            if (u2 > 0) {
              p2[i] = result[u2 - 1];
            }
            result[u2] = i;
          }
        }
      }
      u2 = result.length;
      v2 = result[u2 - 1];
      while (u2-- > 0) {
        result[u2] = v2;
        v2 = p2[v2];
      }
      return result;
    }
    const isTeleport = (type2) => type2.__isTeleport;
    const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
    const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
    const resolveTarget = (props, select) => {
      const targetSelector = props && props.to;
      if (isString$1(targetSelector)) {
        if (!select) {
          return null;
        } else {
          const target = select(targetSelector);
          return target;
        }
      } else {
        return targetSelector;
      }
    };
    const TeleportImpl = {
      name: "Teleport",
      __isTeleport: true,
      process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals) {
        const {
          mc: mountChildren,
          pc: patchChildren,
          pbc: patchBlockChildren,
          o: { insert, querySelector, createText, createComment }
        } = internals;
        const disabled = isTeleportDisabled(n2.props);
        let { shapeFlag, children, dynamicChildren } = n2;
        if (n1 == null) {
          const placeholder = n2.el = createText("");
          const mainAnchor = n2.anchor = createText("");
          insert(placeholder, container, anchor);
          insert(mainAnchor, container, anchor);
          const target = n2.target = resolveTarget(n2.props, querySelector);
          const targetAnchor = n2.targetAnchor = createText("");
          if (target) {
            insert(targetAnchor, target);
            isSVG = isSVG || isTargetSVG(target);
          }
          const mount = (container2, anchor2) => {
            if (shapeFlag & 16) {
              mountChildren(
                children,
                container2,
                anchor2,
                parentComponent,
                parentSuspense,
                isSVG,
                slotScopeIds,
                optimized
              );
            }
          };
          if (disabled) {
            mount(container, mainAnchor);
          } else if (target) {
            mount(target, targetAnchor);
          }
        } else {
          n2.el = n1.el;
          const mainAnchor = n2.anchor = n1.anchor;
          const target = n2.target = n1.target;
          const targetAnchor = n2.targetAnchor = n1.targetAnchor;
          const wasDisabled = isTeleportDisabled(n1.props);
          const currentContainer = wasDisabled ? container : target;
          const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
          isSVG = isSVG || isTargetSVG(target);
          if (dynamicChildren) {
            patchBlockChildren(
              n1.dynamicChildren,
              dynamicChildren,
              currentContainer,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds
            );
            traverseStaticChildren(n1, n2, true);
          } else if (!optimized) {
            patchChildren(
              n1,
              n2,
              currentContainer,
              currentAnchor,
              parentComponent,
              parentSuspense,
              isSVG,
              slotScopeIds,
              false
            );
          }
          if (disabled) {
            if (!wasDisabled) {
              moveTeleport(
                n2,
                container,
                mainAnchor,
                internals,
                1
              );
            } else {
              if (n2.props && n1.props && n2.props.to !== n1.props.to) {
                n2.props.to = n1.props.to;
              }
            }
          } else {
            if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
              const nextTarget = n2.target = resolveTarget(
                n2.props,
                querySelector
              );
              if (nextTarget) {
                moveTeleport(
                  n2,
                  nextTarget,
                  null,
                  internals,
                  0
                );
              }
            } else if (wasDisabled) {
              moveTeleport(
                n2,
                target,
                targetAnchor,
                internals,
                1
              );
            }
          }
        }
        updateCssVars(n2);
      },
      remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) {
        const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode;
        if (target) {
          hostRemove(targetAnchor);
        }
        doRemove && hostRemove(anchor);
        if (shapeFlag & 16) {
          const shouldRemove = doRemove || !isTeleportDisabled(props);
          for (let i = 0; i < children.length; i++) {
            const child = children[i];
            unmount(
              child,
              parentComponent,
              parentSuspense,
              shouldRemove,
              !!child.dynamicChildren
            );
          }
        }
      },
      move: moveTeleport,
      hydrate: hydrateTeleport
    };
    function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
      if (moveType === 0) {
        insert(vnode.targetAnchor, container, parentAnchor);
      }
      const { el, anchor, shapeFlag, children, props } = vnode;
      const isReorder = moveType === 2;
      if (isReorder) {
        insert(el, container, parentAnchor);
      }
      if (!isReorder || isTeleportDisabled(props)) {
        if (shapeFlag & 16) {
          for (let i = 0; i < children.length; i++) {
            move(
              children[i],
              container,
              parentAnchor,
              2
            );
          }
        }
      }
      if (isReorder) {
        insert(anchor, container, parentAnchor);
      }
    }
    function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
      o: { nextSibling, parentNode, querySelector }
    }, hydrateChildren) {
      const target = vnode.target = resolveTarget(
        vnode.props,
        querySelector
      );
      if (target) {
        const targetNode = target._lpa || target.firstChild;
        if (vnode.shapeFlag & 16) {
          if (isTeleportDisabled(vnode.props)) {
            vnode.anchor = hydrateChildren(
              nextSibling(node),
              vnode,
              parentNode(node),
              parentComponent,
              parentSuspense,
              slotScopeIds,
              optimized
            );
            vnode.targetAnchor = targetNode;
          } else {
            vnode.anchor = nextSibling(node);
            let targetAnchor = targetNode;
            while (targetAnchor) {
              targetAnchor = nextSibling(targetAnchor);
              if (targetAnchor && targetAnchor.nodeType === 8 && targetAnchor.data === "teleport anchor") {
                vnode.targetAnchor = targetAnchor;
                target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
                break;
              }
            }
            hydrateChildren(
              targetNode,
              vnode,
              target,
              parentComponent,
              parentSuspense,
              slotScopeIds,
              optimized
            );
          }
        }
        updateCssVars(vnode);
      }
      return vnode.anchor && nextSibling(vnode.anchor);
    }
    const Teleport = TeleportImpl;
    function updateCssVars(vnode) {
      const ctx = vnode.ctx;
      if (ctx && ctx.ut) {
        let node = vnode.children[0].el;
        while (node && node !== vnode.targetAnchor) {
          if (node.nodeType === 1)
            node.setAttribute("data-v-owner", ctx.uid);
          node = node.nextSibling;
        }
        ctx.ut();
      }
    }
    const Fragment = Symbol.for("v-fgt");
    const Text$1 = Symbol.for("v-txt");
    const Comment = Symbol.for("v-cmt");
    const Static = Symbol.for("v-stc");
    const blockStack = [];
    let currentBlock = null;
    function openBlock(disableTracking = false) {
      blockStack.push(currentBlock = disableTracking ? null : []);
    }
    function closeBlock() {
      blockStack.pop();
      currentBlock = blockStack[blockStack.length - 1] || null;
    }
    let isBlockTreeEnabled = 1;
    function setBlockTracking(value) {
      isBlockTreeEnabled += value;
    }
    function setupBlock(vnode) {
      vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
      closeBlock();
      if (isBlockTreeEnabled > 0 && currentBlock) {
        currentBlock.push(vnode);
      }
      return vnode;
    }
    function createElementBlock(type2, props, children, patchFlag, dynamicProps, shapeFlag) {
      return setupBlock(
        createBaseVNode(
          type2,
          props,
          children,
          patchFlag,
          dynamicProps,
          shapeFlag,
          true
          /* isBlock */
        )
      );
    }
    function createBlock(type2, props, children, patchFlag, dynamicProps) {
      return setupBlock(
        createVNode(
          type2,
          props,
          children,
          patchFlag,
          dynamicProps,
          true
          /* isBlock: prevent a block from tracking itself */
        )
      );
    }
    function isVNode(value) {
      return value ? value.__v_isVNode === true : false;
    }
    function isSameVNodeType(n1, n2) {
      return n1.type === n2.type && n1.key === n2.key;
    }
    const InternalObjectKey = `__vInternal`;
    const normalizeKey = ({ key }) => key != null ? key : null;
    const normalizeRef = ({
      ref: ref2,
      ref_key,
      ref_for
    }) => {
      if (typeof ref2 === "number") {
        ref2 = "" + ref2;
      }
      return ref2 != null ? isString$1(ref2) || isRef(ref2) || isFunction$2(ref2) ? { i: currentRenderingInstance, r: ref2, k: ref_key, f: !!ref_for } : ref2 : null;
    };
    function createBaseVNode(type2, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type2 === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
      const vnode = {
        __v_isVNode: true,
        __v_skip: true,
        type: type2,
        props,
        key: props && normalizeKey(props),
        ref: props && normalizeRef(props),
        scopeId: currentScopeId,
        slotScopeIds: null,
        children,
        component: null,
        suspense: null,
        ssContent: null,
        ssFallback: null,
        dirs: null,
        transition: null,
        el: null,
        anchor: null,
        target: null,
        targetAnchor: null,
        staticCount: 0,
        shapeFlag,
        patchFlag,
        dynamicProps,
        dynamicChildren: null,
        appContext: null,
        ctx: currentRenderingInstance
      };
      if (needFullChildrenNormalization) {
        normalizeChildren(vnode, children);
        if (shapeFlag & 128) {
          type2.normalize(vnode);
        }
      } else if (children) {
        vnode.shapeFlag |= isString$1(children) ? 8 : 16;
      }
      if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
      !isBlockNode && // has current parent block
      currentBlock && // presence of a patch flag indicates this node needs patching on updates.
      // component nodes also should always be patched, because even if the
      // component doesn't need to update, it needs to persist the instance on to
      // the next vnode so that it can be properly unmounted later.
      (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
      // vnode should not be considered dynamic due to handler caching.
      vnode.patchFlag !== 32) {
        currentBlock.push(vnode);
      }
      return vnode;
    }
    const createVNode = _createVNode;
    function _createVNode(type2, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
      if (!type2 || type2 === NULL_DYNAMIC_COMPONENT) {
        type2 = Comment;
      }
      if (isVNode(type2)) {
        const cloned = cloneVNode(
          type2,
          props,
          true
          /* mergeRef: true */
        );
        if (children) {
          normalizeChildren(cloned, children);
        }
        if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
          if (cloned.shapeFlag & 6) {
            currentBlock[currentBlock.indexOf(type2)] = cloned;
          } else {
            currentBlock.push(cloned);
          }
        }
        cloned.patchFlag |= -2;
        return cloned;
      }
      if (isClassComponent(type2)) {
        type2 = type2.__vccOpts;
      }
      if (props) {
        props = guardReactiveProps(props);
        let { class: klass, style } = props;
        if (klass && !isString$1(klass)) {
          props.class = normalizeClass(klass);
        }
        if (isObject$1(style)) {
          if (isProxy(style) && !isArray$3(style)) {
            style = extend({}, style);
          }
          props.style = normalizeStyle(style);
        }
      }
      const shapeFlag = isString$1(type2) ? 1 : isSuspense(type2) ? 128 : isTeleport(type2) ? 64 : isObject$1(type2) ? 4 : isFunction$2(type2) ? 2 : 0;
      return createBaseVNode(
        type2,
        props,
        children,
        patchFlag,
        dynamicProps,
        shapeFlag,
        isBlockNode,
        true
      );
    }
    function guardReactiveProps(props) {
      if (!props)
        return null;
      return isProxy(props) || InternalObjectKey in props ? extend({}, props) : props;
    }
    function cloneVNode(vnode, extraProps, mergeRef = false) {
      const { props, ref: ref2, patchFlag, children } = vnode;
      const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
      const cloned = {
        __v_isVNode: true,
        __v_skip: true,
        type: vnode.type,
        props: mergedProps,
        key: mergedProps && normalizeKey(mergedProps),
        ref: extraProps && extraProps.ref ? (
          // #2078 in the case of <component :is="vnode" ref="extra"/>
          // if the vnode itself already has a ref, cloneVNode will need to merge
          // the refs so the single vnode can be set on multiple refs
          mergeRef && ref2 ? isArray$3(ref2) ? ref2.concat(normalizeRef(extraProps)) : [ref2, normalizeRef(extraProps)] : normalizeRef(extraProps)
        ) : ref2,
        scopeId: vnode.scopeId,
        slotScopeIds: vnode.slotScopeIds,
        children,
        target: vnode.target,
        targetAnchor: vnode.targetAnchor,
        staticCount: vnode.staticCount,
        shapeFlag: vnode.shapeFlag,
        // if the vnode is cloned with extra props, we can no longer assume its
        // existing patch flag to be reliable and need to add the FULL_PROPS flag.
        // note: preserve flag for fragments since they use the flag for children
        // fast paths only.
        patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
        dynamicProps: vnode.dynamicProps,
        dynamicChildren: vnode.dynamicChildren,
        appContext: vnode.appContext,
        dirs: vnode.dirs,
        transition: vnode.transition,
        // These should technically only be non-null on mounted VNodes. However,
        // they *should* be copied for kept-alive vnodes. So we just always copy
        // them since them being non-null during a mount doesn't affect the logic as
        // they will simply be overwritten.
        component: vnode.component,
        suspense: vnode.suspense,
        ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
        ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
        el: vnode.el,
        anchor: vnode.anchor,
        ctx: vnode.ctx,
        ce: vnode.ce
      };
      return cloned;
    }
    function createTextVNode(text = " ", flag = 0) {
      return createVNode(Text$1, null, text, flag);
    }
    function createCommentVNode(text = "", asBlock = false) {
      return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
    }
    function normalizeVNode(child) {
      if (child == null || typeof child === "boolean") {
        return createVNode(Comment);
      } else if (isArray$3(child)) {
        return createVNode(
          Fragment,
          null,
          // #3666, avoid reference pollution when reusing vnode
          child.slice()
        );
      } else if (typeof child === "object") {
        return cloneIfMounted(child);
      } else {
        return createVNode(Text$1, null, String(child));
      }
    }
    function cloneIfMounted(child) {
      return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
    }
    function normalizeChildren(vnode, children) {
      let type2 = 0;
      const { shapeFlag } = vnode;
      if (children == null) {
        children = null;
      } else if (isArray$3(children)) {
        type2 = 16;
      } else if (typeof children === "object") {
        if (shapeFlag & (1 | 64)) {
          const slot = children.default;
          if (slot) {
            slot._c && (slot._d = false);
            normalizeChildren(vnode, slot());
            slot._c && (slot._d = true);
          }
          return;
        } else {
          type2 = 32;
          const slotFlag = children._;
          if (!slotFlag && !(InternalObjectKey in children)) {
            children._ctx = currentRenderingInstance;
          } else if (slotFlag === 3 && currentRenderingInstance) {
            if (currentRenderingInstance.slots._ === 1) {
              children._ = 1;
            } else {
              children._ = 2;
              vnode.patchFlag |= 1024;
            }
          }
        }
      } else if (isFunction$2(children)) {
        children = { default: children, _ctx: currentRenderingInstance };
        type2 = 32;
      } else {
        children = String(children);
        if (shapeFlag & 64) {
          type2 = 16;
          children = [createTextVNode(children)];
        } else {
          type2 = 8;
        }
      }
      vnode.children = children;
      vnode.shapeFlag |= type2;
    }
    function mergeProps(...args) {
      const ret = {};
      for (let i = 0; i < args.length; i++) {
        const toMerge = args[i];
        for (const key in toMerge) {
          if (key === "class") {
            if (ret.class !== toMerge.class) {
              ret.class = normalizeClass([ret.class, toMerge.class]);
            }
          } else if (key === "style") {
            ret.style = normalizeStyle([ret.style, toMerge.style]);
          } else if (isOn(key)) {
            const existing = ret[key];
            const incoming = toMerge[key];
            if (incoming && existing !== incoming && !(isArray$3(existing) && existing.includes(incoming))) {
              ret[key] = existing ? [].concat(existing, incoming) : incoming;
            }
          } else if (key !== "") {
            ret[key] = toMerge[key];
          }
        }
      }
      return ret;
    }
    function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
      callWithAsyncErrorHandling(hook, instance, 7, [
        vnode,
        prevVNode
      ]);
    }
    const emptyAppContext = createAppContext();
    let uid$2 = 0;
    function createComponentInstance(vnode, parent, suspense) {
      const type2 = vnode.type;
      const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
      const instance = {
        uid: uid$2++,
        vnode,
        type: type2,
        parent,
        appContext,
        root: null,
        // to be immediately set
        next: null,
        subTree: null,
        // will be set synchronously right after creation
        effect: null,
        update: null,
        // will be set synchronously right after creation
        scope: new EffectScope(
          true
          /* detached */
        ),
        render: null,
        proxy: null,
        exposed: null,
        exposeProxy: null,
        withProxy: null,
        provides: parent ? parent.provides : Object.create(appContext.provides),
        accessCache: null,
        renderCache: [],
        // local resolved assets
        components: null,
        directives: null,
        // resolved props and emits options
        propsOptions: normalizePropsOptions(type2, appContext),
        emitsOptions: normalizeEmitsOptions(type2, appContext),
        // emit
        emit: null,
        // to be set immediately
        emitted: null,
        // props default value
        propsDefaults: EMPTY_OBJ,
        // inheritAttrs
        inheritAttrs: type2.inheritAttrs,
        // state
        ctx: EMPTY_OBJ,
        data: EMPTY_OBJ,
        props: EMPTY_OBJ,
        attrs: EMPTY_OBJ,
        slots: EMPTY_OBJ,
        refs: EMPTY_OBJ,
        setupState: EMPTY_OBJ,
        setupContext: null,
        attrsProxy: null,
        slotsProxy: null,
        // suspense related
        suspense,
        suspenseId: suspense ? suspense.pendingId : 0,
        asyncDep: null,
        asyncResolved: false,
        // lifecycle hooks
        // not using enums here because it results in computed properties
        isMounted: false,
        isUnmounted: false,
        isDeactivated: false,
        bc: null,
        c: null,
        bm: null,
        m: null,
        bu: null,
        u: null,
        um: null,
        bum: null,
        da: null,
        a: null,
        rtg: null,
        rtc: null,
        ec: null,
        sp: null
      };
      {
        instance.ctx = { _: instance };
      }
      instance.root = parent ? parent.root : instance;
      instance.emit = emit.bind(null, instance);
      if (vnode.ce) {
        vnode.ce(instance);
      }
      return instance;
    }
    let currentInstance = null;
    const getCurrentInstance = () => currentInstance || currentRenderingInstance;
    let internalSetCurrentInstance;
    let globalCurrentInstanceSetters;
    let settersKey = "__VUE_INSTANCE_SETTERS__";
    {
      if (!(globalCurrentInstanceSetters = getGlobalThis()[settersKey])) {
        globalCurrentInstanceSetters = getGlobalThis()[settersKey] = [];
      }
      globalCurrentInstanceSetters.push((i) => currentInstance = i);
      internalSetCurrentInstance = (instance) => {
        if (globalCurrentInstanceSetters.length > 1) {
          globalCurrentInstanceSetters.forEach((s2) => s2(instance));
        } else {
          globalCurrentInstanceSetters[0](instance);
        }
      };
    }
    const setCurrentInstance = (instance) => {
      internalSetCurrentInstance(instance);
      instance.scope.on();
    };
    const unsetCurrentInstance = () => {
      currentInstance && currentInstance.scope.off();
      internalSetCurrentInstance(null);
    };
    function isStatefulComponent(instance) {
      return instance.vnode.shapeFlag & 4;
    }
    let isInSSRComponentSetup = false;
    function setupComponent(instance, isSSR = false) {
      isInSSRComponentSetup = isSSR;
      const { props, children } = instance.vnode;
      const isStateful = isStatefulComponent(instance);
      initProps(instance, props, isStateful, isSSR);
      initSlots(instance, children);
      const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
      isInSSRComponentSetup = false;
      return setupResult;
    }
    function setupStatefulComponent(instance, isSSR) {
      const Component = instance.type;
      instance.accessCache = /* @__PURE__ */ Object.create(null);
      instance.proxy = markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
      const { setup } = Component;
      if (setup) {
        const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
        setCurrentInstance(instance);
        pauseTracking();
        const setupResult = callWithErrorHandling(
          setup,
          instance,
          0,
          [instance.props, setupContext]
        );
        resetTracking();
        unsetCurrentInstance();
        if (isPromise(setupResult)) {
          setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
          if (isSSR) {
            return setupResult.then((resolvedResult) => {
              handleSetupResult(instance, resolvedResult, isSSR);
            }).catch((e) => {
              handleError(e, instance, 0);
            });
          } else {
            instance.asyncDep = setupResult;
          }
        } else {
          handleSetupResult(instance, setupResult, isSSR);
        }
      } else {
        finishComponentSetup(instance, isSSR);
      }
    }
    function handleSetupResult(instance, setupResult, isSSR) {
      if (isFunction$2(setupResult)) {
        if (instance.type.__ssrInlineRender) {
          instance.ssrRender = setupResult;
        } else {
          instance.render = setupResult;
        }
      } else if (isObject$1(setupResult)) {
        instance.setupState = proxyRefs(setupResult);
      } else
        ;
      finishComponentSetup(instance, isSSR);
    }
    let compile;
    function finishComponentSetup(instance, isSSR, skipOptions) {
      const Component = instance.type;
      if (!instance.render) {
        if (!isSSR && compile && !Component.render) {
          const template = Component.template || resolveMergedOptions(instance).template;
          if (template) {
            const { isCustomElement, compilerOptions } = instance.appContext.config;
            const { delimiters, compilerOptions: componentCompilerOptions } = Component;
            const finalCompilerOptions = extend(
              extend(
                {
                  isCustomElement,
                  delimiters
                },
                compilerOptions
              ),
              componentCompilerOptions
            );
            Component.render = compile(template, finalCompilerOptions);
          }
        }
        instance.render = Component.render || NOOP;
      }
      {
        setCurrentInstance(instance);
        pauseTracking();
        try {
          applyOptions(instance);
        } finally {
          resetTracking();
          unsetCurrentInstance();
        }
      }
    }
    function getAttrsProxy(instance) {
      return instance.attrsProxy || (instance.attrsProxy = new Proxy(
        instance.attrs,
        {
          get(target, key) {
            track(instance, "get", "$attrs");
            return target[key];
          }
        }
      ));
    }
    function createSetupContext(instance) {
      const expose = (exposed) => {
        instance.exposed = exposed || {};
      };
      {
        return {
          get attrs() {
            return getAttrsProxy(instance);
          },
          slots: instance.slots,
          emit: instance.emit,
          expose
        };
      }
    }
    function getExposeProxy(instance) {
      if (instance.exposed) {
        return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
          get(target, key) {
            if (key in target) {
              return target[key];
            } else if (key in publicPropertiesMap) {
              return publicPropertiesMap[key](instance);
            }
          },
          has(target, key) {
            return key in target || key in publicPropertiesMap;
          }
        }));
      }
    }
    function getComponentName(Component, includeInferred = true) {
      return isFunction$2(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
    }
    function isClassComponent(value) {
      return isFunction$2(value) && "__vccOpts" in value;
    }
    const computed = (getterOrOptions, debugOptions) => {
      return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
    };
    function h$1(type2, propsOrChildren, children) {
      const l2 = arguments.length;
      if (l2 === 2) {
        if (isObject$1(propsOrChildren) && !isArray$3(propsOrChildren)) {
          if (isVNode(propsOrChildren)) {
            return createVNode(type2, null, [propsOrChildren]);
          }
          return createVNode(type2, propsOrChildren);
        } else {
          return createVNode(type2, null, propsOrChildren);
        }
      } else {
        if (l2 > 3) {
          children = Array.prototype.slice.call(arguments, 2);
        } else if (l2 === 3 && isVNode(children)) {
          children = [children];
        }
        return createVNode(type2, propsOrChildren, children);
      }
    }
    const ssrContextKey = Symbol.for("v-scx");
    const useSSRContext = () => {
      {
        const ctx = inject(ssrContextKey);
        return ctx;
      }
    };
    const version$1 = "3.3.9";
    const svgNS = "http://www.w3.org/2000/svg";
    const doc = typeof document !== "undefined" ? document : null;
    const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
    const nodeOps = {
      insert: (child, parent, anchor) => {
        parent.insertBefore(child, anchor || null);
      },
      remove: (child) => {
        const parent = child.parentNode;
        if (parent) {
          parent.removeChild(child);
        }
      },
      createElement: (tag, isSVG, is, props) => {
        const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0);
        if (tag === "select" && props && props.multiple != null) {
          el.setAttribute("multiple", props.multiple);
        }
        return el;
      },
      createText: (text) => doc.createTextNode(text),
      createComment: (text) => doc.createComment(text),
      setText: (node, text) => {
        node.nodeValue = text;
      },
      setElementText: (el, text) => {
        el.textContent = text;
      },
      parentNode: (node) => node.parentNode,
      nextSibling: (node) => node.nextSibling,
      querySelector: (selector) => doc.querySelector(selector),
      setScopeId(el, id) {
        el.setAttribute(id, "");
      },
      // __UNSAFE__
      // Reason: innerHTML.
      // Static content here can only come from compiled templates.
      // As long as the user only uses trusted templates, this is safe.
      insertStaticContent(content, parent, anchor, isSVG, start, end2) {
        const before = anchor ? anchor.previousSibling : parent.lastChild;
        if (start && (start === end2 || start.nextSibling)) {
          while (true) {
            parent.insertBefore(start.cloneNode(true), anchor);
            if (start === end2 || !(start = start.nextSibling))
              break;
          }
        } else {
          templateContainer.innerHTML = isSVG ? `<svg>${content}</svg>` : content;
          const template = templateContainer.content;
          if (isSVG) {
            const wrapper = template.firstChild;
            while (wrapper.firstChild) {
              template.appendChild(wrapper.firstChild);
            }
            template.removeChild(wrapper);
          }
          parent.insertBefore(template, anchor);
        }
        return [
          // first
          before ? before.nextSibling : parent.firstChild,
          // last
          anchor ? anchor.previousSibling : parent.lastChild
        ];
      }
    };
    const TRANSITION = "transition";
    const ANIMATION = "animation";
    const vtcKey = Symbol("_vtc");
    const Transition = (props, { slots }) => h$1(BaseTransition, resolveTransitionProps(props), slots);
    Transition.displayName = "Transition";
    const DOMTransitionPropsValidators = {
      name: String,
      type: String,
      css: {
        type: Boolean,
        default: true
      },
      duration: [String, Number, Object],
      enterFromClass: String,
      enterActiveClass: String,
      enterToClass: String,
      appearFromClass: String,
      appearActiveClass: String,
      appearToClass: String,
      leaveFromClass: String,
      leaveActiveClass: String,
      leaveToClass: String
    };
    const TransitionPropsValidators = Transition.props = /* @__PURE__ */ extend(
      {},
      BaseTransitionPropsValidators,
      DOMTransitionPropsValidators
    );
    const callHook = (hook, args = []) => {
      if (isArray$3(hook)) {
        hook.forEach((h2) => h2(...args));
      } else if (hook) {
        hook(...args);
      }
    };
    const hasExplicitCallback = (hook) => {
      return hook ? isArray$3(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
    };
    function resolveTransitionProps(rawProps) {
      const baseProps = {};
      for (const key in rawProps) {
        if (!(key in DOMTransitionPropsValidators)) {
          baseProps[key] = rawProps[key];
        }
      }
      if (rawProps.css === false) {
        return baseProps;
      }
      const {
        name = "v",
        type: type2,
        duration,
        enterFromClass = `${name}-enter-from`,
        enterActiveClass = `${name}-enter-active`,
        enterToClass = `${name}-enter-to`,
        appearFromClass = enterFromClass,
        appearActiveClass = enterActiveClass,
        appearToClass = enterToClass,
        leaveFromClass = `${name}-leave-from`,
        leaveActiveClass = `${name}-leave-active`,
        leaveToClass = `${name}-leave-to`
      } = rawProps;
      const durations = normalizeDuration(duration);
      const enterDuration = durations && durations[0];
      const leaveDuration = durations && durations[1];
      const {
        onBeforeEnter,
        onEnter,
        onEnterCancelled,
        onLeave,
        onLeaveCancelled,
        onBeforeAppear = onBeforeEnter,
        onAppear = onEnter,
        onAppearCancelled = onEnterCancelled
      } = baseProps;
      const finishEnter = (el, isAppear, done) => {
        removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
        removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
        done && done();
      };
      const finishLeave = (el, done) => {
        el._isLeaving = false;
        removeTransitionClass(el, leaveFromClass);
        removeTransitionClass(el, leaveToClass);
        removeTransitionClass(el, leaveActiveClass);
        done && done();
      };
      const makeEnterHook = (isAppear) => {
        return (el, done) => {
          const hook = isAppear ? onAppear : onEnter;
          const resolve2 = () => finishEnter(el, isAppear, done);
          callHook(hook, [el, resolve2]);
          nextFrame(() => {
            removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
            addTransitionClass(el, isAppear ? appearToClass : enterToClass);
            if (!hasExplicitCallback(hook)) {
              whenTransitionEnds(el, type2, enterDuration, resolve2);
            }
          });
        };
      };
      return extend(baseProps, {
        onBeforeEnter(el) {
          callHook(onBeforeEnter, [el]);
          addTransitionClass(el, enterFromClass);
          addTransitionClass(el, enterActiveClass);
        },
        onBeforeAppear(el) {
          callHook(onBeforeAppear, [el]);
          addTransitionClass(el, appearFromClass);
          addTransitionClass(el, appearActiveClass);
        },
        onEnter: makeEnterHook(false),
        onAppear: makeEnterHook(true),
        onLeave(el, done) {
          el._isLeaving = true;
          const resolve2 = () => finishLeave(el, done);
          addTransitionClass(el, leaveFromClass);
          forceReflow();
          addTransitionClass(el, leaveActiveClass);
          nextFrame(() => {
            if (!el._isLeaving) {
              return;
            }
            removeTransitionClass(el, leaveFromClass);
            addTransitionClass(el, leaveToClass);
            if (!hasExplicitCallback(onLeave)) {
              whenTransitionEnds(el, type2, leaveDuration, resolve2);
            }
          });
          callHook(onLeave, [el, resolve2]);
        },
        onEnterCancelled(el) {
          finishEnter(el, false);
          callHook(onEnterCancelled, [el]);
        },
        onAppearCancelled(el) {
          finishEnter(el, true);
          callHook(onAppearCancelled, [el]);
        },
        onLeaveCancelled(el) {
          finishLeave(el);
          callHook(onLeaveCancelled, [el]);
        }
      });
    }
    function normalizeDuration(duration) {
      if (duration == null) {
        return null;
      } else if (isObject$1(duration)) {
        return [NumberOf(duration.enter), NumberOf(duration.leave)];
      } else {
        const n = NumberOf(duration);
        return [n, n];
      }
    }
    function NumberOf(val) {
      const res = toNumber$1(val);
      return res;
    }
    function addTransitionClass(el, cls) {
      cls.split(/\s+/).forEach((c2) => c2 && el.classList.add(c2));
      (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
    }
    function removeTransitionClass(el, cls) {
      cls.split(/\s+/).forEach((c2) => c2 && el.classList.remove(c2));
      const _vtc = el[vtcKey];
      if (_vtc) {
        _vtc.delete(cls);
        if (!_vtc.size) {
          el[vtcKey] = void 0;
        }
      }
    }
    function nextFrame(cb) {
      requestAnimationFrame(() => {
        requestAnimationFrame(cb);
      });
    }
    let endId = 0;
    function whenTransitionEnds(el, expectedType, explicitTimeout, resolve2) {
      const id = el._endId = ++endId;
      const resolveIfNotStale = () => {
        if (id === el._endId) {
          resolve2();
        }
      };
      if (explicitTimeout) {
        return setTimeout(resolveIfNotStale, explicitTimeout);
      }
      const { type: type2, timeout, propCount } = getTransitionInfo(el, expectedType);
      if (!type2) {
        return resolve2();
      }
      const endEvent = type2 + "end";
      let ended = 0;
      const end2 = () => {
        el.removeEventListener(endEvent, onEnd);
        resolveIfNotStale();
      };
      const onEnd = (e) => {
        if (e.target === el && ++ended >= propCount) {
          end2();
        }
      };
      setTimeout(() => {
        if (ended < propCount) {
          end2();
        }
      }, timeout + 1);
      el.addEventListener(endEvent, onEnd);
    }
    function getTransitionInfo(el, expectedType) {
      const styles = window.getComputedStyle(el);
      const getStyleProperties = (key) => (styles[key] || "").split(", ");
      const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
      const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
      const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
      const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
      const animationTimeout = getTimeout(animationDelays, animationDurations);
      let type2 = null;
      let timeout = 0;
      let propCount = 0;
      if (expectedType === TRANSITION) {
        if (transitionTimeout > 0) {
          type2 = TRANSITION;
          timeout = transitionTimeout;
          propCount = transitionDurations.length;
        }
      } else if (expectedType === ANIMATION) {
        if (animationTimeout > 0) {
          type2 = ANIMATION;
          timeout = animationTimeout;
          propCount = animationDurations.length;
        }
      } else {
        timeout = Math.max(transitionTimeout, animationTimeout);
        type2 = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
        propCount = type2 ? type2 === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
      }
      const hasTransform = type2 === TRANSITION && /\b(transform|all)(,|$)/.test(
        getStyleProperties(`${TRANSITION}Property`).toString()
      );
      return {
        type: type2,
        timeout,
        propCount,
        hasTransform
      };
    }
    function getTimeout(delays, durations) {
      while (delays.length < durations.length) {
        delays = delays.concat(delays);
      }
      return Math.max(...durations.map((d2, i) => toMs(d2) + toMs(delays[i])));
    }
    function toMs(s2) {
      if (s2 === "auto")
        return 0;
      return Number(s2.slice(0, -1).replace(",", ".")) * 1e3;
    }
    function forceReflow() {
      return document.body.offsetHeight;
    }
    function patchClass(el, value, isSVG) {
      const transitionClasses = el[vtcKey];
      if (transitionClasses) {
        value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
      }
      if (value == null) {
        el.removeAttribute("class");
      } else if (isSVG) {
        el.setAttribute("class", value);
      } else {
        el.className = value;
      }
    }
    const vShowOldKey = Symbol("_vod");
    const vShow = {
      beforeMount(el, { value }, { transition }) {
        el[vShowOldKey] = el.style.display === "none" ? "" : el.style.display;
        if (transition && value) {
          transition.beforeEnter(el);
        } else {
          setDisplay(el, value);
        }
      },
      mounted(el, { value }, { transition }) {
        if (transition && value) {
          transition.enter(el);
        }
      },
      updated(el, { value, oldValue }, { transition }) {
        if (!value === !oldValue)
          return;
        if (transition) {
          if (value) {
            transition.beforeEnter(el);
            setDisplay(el, true);
            transition.enter(el);
          } else {
            transition.leave(el, () => {
              setDisplay(el, false);
            });
          }
        } else {
          setDisplay(el, value);
        }
      },
      beforeUnmount(el, { value }) {
        setDisplay(el, value);
      }
    };
    function setDisplay(el, value) {
      el.style.display = value ? el[vShowOldKey] : "none";
    }
    function patchStyle(el, prev, next) {
      const style = el.style;
      const isCssString = isString$1(next);
      if (next && !isCssString) {
        if (prev && !isString$1(prev)) {
          for (const key in prev) {
            if (next[key] == null) {
              setStyle(style, key, "");
            }
          }
        }
        for (const key in next) {
          setStyle(style, key, next[key]);
        }
      } else {
        const currentDisplay = style.display;
        if (isCssString) {
          if (prev !== next) {
            style.cssText = next;
          }
        } else if (prev) {
          el.removeAttribute("style");
        }
        if (vShowOldKey in el) {
          style.display = currentDisplay;
        }
      }
    }
    const importantRE = /\s*!important$/;
    function setStyle(style, name, val) {
      if (isArray$3(val)) {
        val.forEach((v2) => setStyle(style, name, v2));
      } else {
        if (val == null)
          val = "";
        if (name.startsWith("--")) {
          style.setProperty(name, val);
        } else {
          const prefixed = autoPrefix(style, name);
          if (importantRE.test(val)) {
            style.setProperty(
              hyphenate(prefixed),
              val.replace(importantRE, ""),
              "important"
            );
          } else {
            style[prefixed] = val;
          }
        }
      }
    }
    const prefixes = ["Webkit", "Moz", "ms"];
    const prefixCache = {};
    function autoPrefix(style, rawName) {
      const cached = prefixCache[rawName];
      if (cached) {
        return cached;
      }
      let name = camelize(rawName);
      if (name !== "filter" && name in style) {
        return prefixCache[rawName] = name;
      }
      name = capitalize$1(name);
      for (let i = 0; i < prefixes.length; i++) {
        const prefixed = prefixes[i] + name;
        if (prefixed in style) {
          return prefixCache[rawName] = prefixed;
        }
      }
      return rawName;
    }
    const xlinkNS = "http://www.w3.org/1999/xlink";
    function patchAttr(el, key, value, isSVG, instance) {
      if (isSVG && key.startsWith("xlink:")) {
        if (value == null) {
          el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
        } else {
          el.setAttributeNS(xlinkNS, key, value);
        }
      } else {
        const isBoolean2 = isSpecialBooleanAttr(key);
        if (value == null || isBoolean2 && !includeBooleanAttr(value)) {
          el.removeAttribute(key);
        } else {
          el.setAttribute(key, isBoolean2 ? "" : value);
        }
      }
    }
    function patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) {
      if (key === "innerHTML" || key === "textContent") {
        if (prevChildren) {
          unmountChildren(prevChildren, parentComponent, parentSuspense);
        }
        el[key] = value == null ? "" : value;
        return;
      }
      const tag = el.tagName;
      if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
      !tag.includes("-")) {
        el._value = value;
        const oldValue = tag === "OPTION" ? el.getAttribute("value") : el.value;
        const newValue = value == null ? "" : value;
        if (oldValue !== newValue) {
          el.value = newValue;
        }
        if (value == null) {
          el.removeAttribute(key);
        }
        return;
      }
      let needRemove = false;
      if (value === "" || value == null) {
        const type2 = typeof el[key];
        if (type2 === "boolean") {
          value = includeBooleanAttr(value);
        } else if (value == null && type2 === "string") {
          value = "";
          needRemove = true;
        } else if (type2 === "number") {
          value = 0;
          needRemove = true;
        }
      }
      try {
        el[key] = value;
      } catch (e) {
      }
      needRemove && el.removeAttribute(key);
    }
    function addEventListener(el, event, handler, options) {
      el.addEventListener(event, handler, options);
    }
    function removeEventListener(el, event, handler, options) {
      el.removeEventListener(event, handler, options);
    }
    const veiKey = Symbol("_vei");
    function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
      const invokers = el[veiKey] || (el[veiKey] = {});
      const existingInvoker = invokers[rawName];
      if (nextValue && existingInvoker) {
        existingInvoker.value = nextValue;
      } else {
        const [name, options] = parseName(rawName);
        if (nextValue) {
          const invoker = invokers[rawName] = createInvoker(nextValue, instance);
          addEventListener(el, name, invoker, options);
        } else if (existingInvoker) {
          removeEventListener(el, name, existingInvoker, options);
          invokers[rawName] = void 0;
        }
      }
    }
    const optionsModifierRE = /(?:Once|Passive|Capture)$/;
    function parseName(name) {
      let options;
      if (optionsModifierRE.test(name)) {
        options = {};
        let m2;
        while (m2 = name.match(optionsModifierRE)) {
          name = name.slice(0, name.length - m2[0].length);
          options[m2[0].toLowerCase()] = true;
        }
      }
      const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
      return [event, options];
    }
    let cachedNow = 0;
    const p$1 = /* @__PURE__ */ Promise.resolve();
    const getNow = () => cachedNow || (p$1.then(() => cachedNow = 0), cachedNow = Date.now());
    function createInvoker(initialValue, instance) {
      const invoker = (e) => {
        if (!e._vts) {
          e._vts = Date.now();
        } else if (e._vts <= invoker.attached) {
          return;
        }
        callWithAsyncErrorHandling(
          patchStopImmediatePropagation(e, invoker.value),
          instance,
          5,
          [e]
        );
      };
      invoker.value = initialValue;
      invoker.attached = getNow();
      return invoker;
    }
    function patchStopImmediatePropagation(e, value) {
      if (isArray$3(value)) {
        const originalStop = e.stopImmediatePropagation;
        e.stopImmediatePropagation = () => {
          originalStop.call(e);
          e._stopped = true;
        };
        return value.map((fn2) => (e2) => !e2._stopped && fn2 && fn2(e2));
      } else {
        return value;
      }
    }
    const nativeOnRE = /^on[a-z]/;
    const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {
      if (key === "class") {
        patchClass(el, nextValue, isSVG);
      } else if (key === "style") {
        patchStyle(el, prevValue, nextValue);
      } else if (isOn(key)) {
        if (!isModelListener(key)) {
          patchEvent(el, key, prevValue, nextValue, parentComponent);
        }
      } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
        patchDOMProp(
          el,
          key,
          nextValue,
          prevChildren,
          parentComponent,
          parentSuspense,
          unmountChildren
        );
      } else {
        if (key === "true-value") {
          el._trueValue = nextValue;
        } else if (key === "false-value") {
          el._falseValue = nextValue;
        }
        patchAttr(el, key, nextValue, isSVG);
      }
    };
    function shouldSetAsProp(el, key, value, isSVG) {
      if (isSVG) {
        if (key === "innerHTML" || key === "textContent") {
          return true;
        }
        if (key in el && nativeOnRE.test(key) && isFunction$2(value)) {
          return true;
        }
        return false;
      }
      if (key === "spellcheck" || key === "draggable" || key === "translate") {
        return false;
      }
      if (key === "form") {
        return false;
      }
      if (key === "list" && el.tagName === "INPUT") {
        return false;
      }
      if (key === "type" && el.tagName === "TEXTAREA") {
        return false;
      }
      if (nativeOnRE.test(key) && isString$1(value)) {
        return false;
      }
      return key in el;
    }
    const positionMap = /* @__PURE__ */ new WeakMap();
    const newPositionMap = /* @__PURE__ */ new WeakMap();
    const moveCbKey = Symbol("_moveCb");
    const enterCbKey = Symbol("_enterCb");
    const TransitionGroupImpl = {
      name: "TransitionGroup",
      props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
        tag: String,
        moveClass: String
      }),
      setup(props, { slots }) {
        const instance = getCurrentInstance();
        const state = useTransitionState();
        let prevChildren;
        let children;
        onUpdated(() => {
          if (!prevChildren.length) {
            return;
          }
          const moveClass = props.moveClass || `${props.name || "v"}-move`;
          if (!hasCSSTransform(
            prevChildren[0].el,
            instance.vnode.el,
            moveClass
          )) {
            return;
          }
          prevChildren.forEach(callPendingCbs);
          prevChildren.forEach(recordPosition);
          const movedChildren = prevChildren.filter(applyTranslation);
          forceReflow();
          movedChildren.forEach((c2) => {
            const el = c2.el;
            const style = el.style;
            addTransitionClass(el, moveClass);
            style.transform = style.webkitTransform = style.transitionDuration = "";
            const cb = el[moveCbKey] = (e) => {
              if (e && e.target !== el) {
                return;
              }
              if (!e || /transform$/.test(e.propertyName)) {
                el.removeEventListener("transitionend", cb);
                el[moveCbKey] = null;
                removeTransitionClass(el, moveClass);
              }
            };
            el.addEventListener("transitionend", cb);
          });
        });
        return () => {
          const rawProps = toRaw(props);
          const cssTransitionProps = resolveTransitionProps(rawProps);
          let tag = rawProps.tag || Fragment;
          prevChildren = children;
          children = slots.default ? getTransitionRawChildren(slots.default()) : [];
          for (let i = 0; i < children.length; i++) {
            const child = children[i];
            if (child.key != null) {
              setTransitionHooks(
                child,
                resolveTransitionHooks(child, cssTransitionProps, state, instance)
              );
            }
          }
          if (prevChildren) {
            for (let i = 0; i < prevChildren.length; i++) {
              const child = prevChildren[i];
              setTransitionHooks(
                child,
                resolveTransitionHooks(child, cssTransitionProps, state, instance)
              );
              positionMap.set(child, child.el.getBoundingClientRect());
            }
          }
          return createVNode(tag, null, children);
        };
      }
    };
    const removeMode = (props) => delete props.mode;
    /* @__PURE__ */ removeMode(TransitionGroupImpl.props);
    const TransitionGroup = TransitionGroupImpl;
    function callPendingCbs(c2) {
      const el = c2.el;
      if (el[moveCbKey]) {
        el[moveCbKey]();
      }
      if (el[enterCbKey]) {
        el[enterCbKey]();
      }
    }
    function recordPosition(c2) {
      newPositionMap.set(c2, c2.el.getBoundingClientRect());
    }
    function applyTranslation(c2) {
      const oldPos = positionMap.get(c2);
      const newPos = newPositionMap.get(c2);
      const dx = oldPos.left - newPos.left;
      const dy = oldPos.top - newPos.top;
      if (dx || dy) {
        const s2 = c2.el.style;
        s2.transform = s2.webkitTransform = `translate(${dx}px,${dy}px)`;
        s2.transitionDuration = "0s";
        return c2;
      }
    }
    function hasCSSTransform(el, root2, moveClass) {
      const clone2 = el.cloneNode();
      const _vtc = el[vtcKey];
      if (_vtc) {
        _vtc.forEach((cls) => {
          cls.split(/\s+/).forEach((c2) => c2 && clone2.classList.remove(c2));
        });
      }
      moveClass.split(/\s+/).forEach((c2) => c2 && clone2.classList.add(c2));
      clone2.style.display = "none";
      const container = root2.nodeType === 1 ? root2 : root2.parentNode;
      container.appendChild(clone2);
      const { hasTransform } = getTransitionInfo(clone2);
      container.removeChild(clone2);
      return hasTransform;
    }
    const getModelAssigner = (vnode) => {
      const fn2 = vnode.props["onUpdate:modelValue"] || false;
      return isArray$3(fn2) ? (value) => invokeArrayFns(fn2, value) : fn2;
    };
    function onCompositionStart(e) {
      e.target.composing = true;
    }
    function onCompositionEnd(e) {
      const target = e.target;
      if (target.composing) {
        target.composing = false;
        target.dispatchEvent(new Event("input"));
      }
    }
    const assignKey = Symbol("_assign");
    const vModelText = {
      created(el, { modifiers: { lazy, trim, number: number2 } }, vnode) {
        el[assignKey] = getModelAssigner(vnode);
        const castToNumber = number2 || vnode.props && vnode.props.type === "number";
        addEventListener(el, lazy ? "change" : "input", (e) => {
          if (e.target.composing)
            return;
          let domValue = el.value;
          if (trim) {
            domValue = domValue.trim();
          }
          if (castToNumber) {
            domValue = looseToNumber(domValue);
          }
          el[assignKey](domValue);
        });
        if (trim) {
          addEventListener(el, "change", () => {
            el.value = el.value.trim();
          });
        }
        if (!lazy) {
          addEventListener(el, "compositionstart", onCompositionStart);
          addEventListener(el, "compositionend", onCompositionEnd);
          addEventListener(el, "change", onCompositionEnd);
        }
      },
      // set value on mounted so it's after min/max for type="range"
      mounted(el, { value }) {
        el.value = value == null ? "" : value;
      },
      beforeUpdate(el, { value, modifiers: { lazy, trim, number: number2 } }, vnode) {
        el[assignKey] = getModelAssigner(vnode);
        if (el.composing)
          return;
        const elValue = number2 || el.type === "number" ? looseToNumber(el.value) : el.value;
        const newValue = value == null ? "" : value;
        if (elValue === newValue) {
          return;
        }
        if (document.activeElement === el && el.type !== "range") {
          if (lazy) {
            return;
          }
          if (trim && el.value.trim() === newValue) {
            return;
          }
        }
        el.value = newValue;
      }
    };
    const vModelCheckbox = {
      // #4096 array checkboxes need to be deep traversed
      deep: true,
      created(el, _2, vnode) {
        el[assignKey] = getModelAssigner(vnode);
        addEventListener(el, "change", () => {
          const modelValue = el._modelValue;
          const elementValue = getValue$2(el);
          const checked = el.checked;
          const assign2 = el[assignKey];
          if (isArray$3(modelValue)) {
            const index2 = looseIndexOf(modelValue, elementValue);
            const found = index2 !== -1;
            if (checked && !found) {
              assign2(modelValue.concat(elementValue));
            } else if (!checked && found) {
              const filtered = [...modelValue];
              filtered.splice(index2, 1);
              assign2(filtered);
            }
          } else if (isSet$2(modelValue)) {
            const cloned = new Set(modelValue);
            if (checked) {
              cloned.add(elementValue);
            } else {
              cloned.delete(elementValue);
            }
            assign2(cloned);
          } else {
            assign2(getCheckboxValue(el, checked));
          }
        });
      },
      // set initial checked on mount to wait for true-value/false-value
      mounted: setChecked,
      beforeUpdate(el, binding, vnode) {
        el[assignKey] = getModelAssigner(vnode);
        setChecked(el, binding, vnode);
      }
    };
    function setChecked(el, { value, oldValue }, vnode) {
      el._modelValue = value;
      if (isArray$3(value)) {
        el.checked = looseIndexOf(value, vnode.props.value) > -1;
      } else if (isSet$2(value)) {
        el.checked = value.has(vnode.props.value);
      } else if (value !== oldValue) {
        el.checked = looseEqual(value, getCheckboxValue(el, true));
      }
    }
    const vModelRadio = {
      created(el, { value }, vnode) {
        el.checked = looseEqual(value, vnode.props.value);
        el[assignKey] = getModelAssigner(vnode);
        addEventListener(el, "change", () => {
          el[assignKey](getValue$2(el));
        });
      },
      beforeUpdate(el, { value, oldValue }, vnode) {
        el[assignKey] = getModelAssigner(vnode);
        if (value !== oldValue) {
          el.checked = looseEqual(value, vnode.props.value);
        }
      }
    };
    function getValue$2(el) {
      return "_value" in el ? el._value : el.value;
    }
    function getCheckboxValue(el, checked) {
      const key = checked ? "_trueValue" : "_falseValue";
      return key in el ? el[key] : checked;
    }
    const systemModifiers = ["ctrl", "shift", "alt", "meta"];
    const modifierGuards = {
      stop: (e) => e.stopPropagation(),
      prevent: (e) => e.preventDefault(),
      self: (e) => e.target !== e.currentTarget,
      ctrl: (e) => !e.ctrlKey,
      shift: (e) => !e.shiftKey,
      alt: (e) => !e.altKey,
      meta: (e) => !e.metaKey,
      left: (e) => "button" in e && e.button !== 0,
      middle: (e) => "button" in e && e.button !== 1,
      right: (e) => "button" in e && e.button !== 2,
      exact: (e, modifiers) => systemModifiers.some((m2) => e[`${m2}Key`] && !modifiers.includes(m2))
    };
    const withModifiers = (fn2, modifiers) => {
      return (event, ...args) => {
        for (let i = 0; i < modifiers.length; i++) {
          const guard = modifierGuards[modifiers[i]];
          if (guard && guard(event, modifiers))
            return;
        }
        return fn2(event, ...args);
      };
    };
    const keyNames = {
      esc: "escape",
      space: " ",
      up: "arrow-up",
      left: "arrow-left",
      right: "arrow-right",
      down: "arrow-down",
      delete: "backspace"
    };
    const withKeys = (fn2, modifiers) => {
      return (event) => {
        if (!("key" in event)) {
          return;
        }
        const eventKey = hyphenate(event.key);
        if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) {
          return fn2(event);
        }
      };
    };
    const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
    let renderer;
    function ensureRenderer() {
      return renderer || (renderer = createRenderer(rendererOptions));
    }
    const render = (...args) => {
      ensureRenderer().render(...args);
    };
    const createApp = (...args) => {
      const app = ensureRenderer().createApp(...args);
      const { mount } = app;
      app.mount = (containerOrSelector) => {
        const container = normalizeContainer(containerOrSelector);
        if (!container)
          return;
        const component2 = app._component;
        if (!isFunction$2(component2) && !component2.render && !component2.template) {
          component2.template = container.innerHTML;
        }
        container.innerHTML = "";
        const proxy = mount(container, false, container instanceof SVGElement);
        if (container instanceof Element) {
          container.removeAttribute("v-cloak");
          container.setAttribute("data-v-app", "");
        }
        return proxy;
      };
      return app;
    };
    function normalizeContainer(container) {
      if (isString$1(container)) {
        const res = document.querySelector(container);
        return res;
      }
      return container;
    }
    var isVue2 = false;
    /*!
     * pinia v2.1.7
     * (c) 2023 Eduardo San Martin Morote
     * @license MIT
     */
    let activePinia;
    const setActivePinia = (pinia) => activePinia = pinia;
    const piniaSymbol = (
      /* istanbul ignore next */
      Symbol()
    );
    function isPlainObject$1(o2) {
      return o2 && typeof o2 === "object" && Object.prototype.toString.call(o2) === "[object Object]" && typeof o2.toJSON !== "function";
    }
    var MutationType;
    (function(MutationType2) {
      MutationType2["direct"] = "direct";
      MutationType2["patchObject"] = "patch object";
      MutationType2["patchFunction"] = "patch function";
    })(MutationType || (MutationType = {}));
    function createPinia() {
      const scope = effectScope(true);
      const state = scope.run(() => ref({}));
      let _p = [];
      let toBeInstalled = [];
      const pinia = markRaw({
        install(app) {
          setActivePinia(pinia);
          {
            pinia._a = app;
            app.provide(piniaSymbol, pinia);
            app.config.globalProperties.$pinia = pinia;
            toBeInstalled.forEach((plugin) => _p.push(plugin));
            toBeInstalled = [];
          }
        },
        use(plugin) {
          if (!this._a && !isVue2) {
            toBeInstalled.push(plugin);
          } else {
            _p.push(plugin);
          }
          return this;
        },
        _p,
        // it's actually undefined here
        // @ts-expect-error
        _a: null,
        _e: scope,
        _s: /* @__PURE__ */ new Map(),
        state
      });
      return pinia;
    }
    const noop$3 = () => {
    };
    function addSubscription(subscriptions, callback, detached, onCleanup = noop$3) {
      subscriptions.push(callback);
      const removeSubscription = () => {
        const idx = subscriptions.indexOf(callback);
        if (idx > -1) {
          subscriptions.splice(idx, 1);
          onCleanup();
        }
      };
      if (!detached && getCurrentScope()) {
        onScopeDispose(removeSubscription);
      }
      return removeSubscription;
    }
    function triggerSubscriptions(subscriptions, ...args) {
      subscriptions.slice().forEach((callback) => {
        callback(...args);
      });
    }
    const fallbackRunWithContext = (fn2) => fn2();
    function mergeReactiveObjects(target, patchToApply) {
      if (target instanceof Map && patchToApply instanceof Map) {
        patchToApply.forEach((value, key) => target.set(key, value));
      }
      if (target instanceof Set && patchToApply instanceof Set) {
        patchToApply.forEach(target.add, target);
      }
      for (const key in patchToApply) {
        if (!patchToApply.hasOwnProperty(key))
          continue;
        const subPatch = patchToApply[key];
        const targetValue = target[key];
        if (isPlainObject$1(targetValue) && isPlainObject$1(subPatch) && target.hasOwnProperty(key) && !isRef(subPatch) && !isReactive(subPatch)) {
          target[key] = mergeReactiveObjects(targetValue, subPatch);
        } else {
          target[key] = subPatch;
        }
      }
      return target;
    }
    const skipHydrateSymbol = (
      /* istanbul ignore next */
      Symbol()
    );
    function shouldHydrate(obj) {
      return !isPlainObject$1(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
    }
    const { assign: assign$1 } = Object;
    function isComputed(o2) {
      return !!(isRef(o2) && o2.effect);
    }
    function createOptionsStore(id, options, pinia, hot) {
      const { state, actions, getters } = options;
      const initialState = pinia.state.value[id];
      let store;
      function setup() {
        if (!initialState && true) {
          {
            pinia.state.value[id] = state ? state() : {};
          }
        }
        const localState = toRefs(pinia.state.value[id]);
        return assign$1(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
          computedGetters[name] = markRaw(computed(() => {
            setActivePinia(pinia);
            const store2 = pinia._s.get(id);
            return getters[name].call(store2, store2);
          }));
          return computedGetters;
        }, {}));
      }
      store = createSetupStore(id, setup, options, pinia, hot, true);
      return store;
    }
    function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
      let scope;
      const optionsForPlugin = assign$1({ actions: {} }, options);
      const $subscribeOptions = {
        deep: true
        // flush: 'post',
      };
      let isListening;
      let isSyncListening;
      let subscriptions = [];
      let actionSubscriptions = [];
      let debuggerEvents;
      const initialState = pinia.state.value[$id];
      if (!isOptionsStore && !initialState && true) {
        {
          pinia.state.value[$id] = {};
        }
      }
      ref({});
      let activeListener;
      function $patch(partialStateOrMutator) {
        let subscriptionMutation;
        isListening = isSyncListening = false;
        if (typeof partialStateOrMutator === "function") {
          partialStateOrMutator(pinia.state.value[$id]);
          subscriptionMutation = {
            type: MutationType.patchFunction,
            storeId: $id,
            events: debuggerEvents
          };
        } else {
          mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
          subscriptionMutation = {
            type: MutationType.patchObject,
            payload: partialStateOrMutator,
            storeId: $id,
            events: debuggerEvents
          };
        }
        const myListenerId = activeListener = Symbol();
        nextTick().then(() => {
          if (activeListener === myListenerId) {
            isListening = true;
          }
        });
        isSyncListening = true;
        triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
      }
      const $reset = isOptionsStore ? function $reset2() {
        const { state } = options;
        const newState = state ? state() : {};
        this.$patch(($state) => {
          assign$1($state, newState);
        });
      } : (
        /* istanbul ignore next */
        noop$3
      );
      function $dispose() {
        scope.stop();
        subscriptions = [];
        actionSubscriptions = [];
        pinia._s.delete($id);
      }
      function wrapAction(name, action) {
        return function() {
          setActivePinia(pinia);
          const args = Array.from(arguments);
          const afterCallbackList = [];
          const onErrorCallbackList = [];
          function after(callback) {
            afterCallbackList.push(callback);
          }
          function onError(callback) {
            onErrorCallbackList.push(callback);
          }
          triggerSubscriptions(actionSubscriptions, {
            args,
            name,
            store,
            after,
            onError
          });
          let ret;
          try {
            ret = action.apply(this && this.$id === $id ? this : store, args);
          } catch (error) {
            triggerSubscriptions(onErrorCallbackList, error);
            throw error;
          }
          if (ret instanceof Promise) {
            return ret.then((value) => {
              triggerSubscriptions(afterCallbackList, value);
              return value;
            }).catch((error) => {
              triggerSubscriptions(onErrorCallbackList, error);
              return Promise.reject(error);
            });
          }
          triggerSubscriptions(afterCallbackList, ret);
          return ret;
        };
      }
      const partialStore = {
        _p: pinia,
        // _s: scope,
        $id,
        $onAction: addSubscription.bind(null, actionSubscriptions),
        $patch,
        $reset,
        $subscribe(callback, options2 = {}) {
          const removeSubscription = addSubscription(subscriptions, callback, options2.detached, () => stopWatcher());
          const stopWatcher = scope.run(() => watch(() => pinia.state.value[$id], (state) => {
            if (options2.flush === "sync" ? isSyncListening : isListening) {
              callback({
                storeId: $id,
                type: MutationType.direct,
                events: debuggerEvents
              }, state);
            }
          }, assign$1({}, $subscribeOptions, options2)));
          return removeSubscription;
        },
        $dispose
      };
      const store = reactive(partialStore);
      pinia._s.set($id, store);
      const runWithContext = pinia._a && pinia._a.runWithContext || fallbackRunWithContext;
      const setupStore = runWithContext(() => pinia._e.run(() => (scope = effectScope()).run(setup)));
      for (const key in setupStore) {
        const prop = setupStore[key];
        if (isRef(prop) && !isComputed(prop) || isReactive(prop)) {
          if (!isOptionsStore) {
            if (initialState && shouldHydrate(prop)) {
              if (isRef(prop)) {
                prop.value = initialState[key];
              } else {
                mergeReactiveObjects(prop, initialState[key]);
              }
            }
            {
              pinia.state.value[$id][key] = prop;
            }
          }
        } else if (typeof prop === "function") {
          const actionValue = wrapAction(key, prop);
          {
            setupStore[key] = actionValue;
          }
          optionsForPlugin.actions[key] = prop;
        } else
          ;
      }
      {
        assign$1(store, setupStore);
        assign$1(toRaw(store), setupStore);
      }
      Object.defineProperty(store, "$state", {
        get: () => pinia.state.value[$id],
        set: (state) => {
          $patch(($state) => {
            assign$1($state, state);
          });
        }
      });
      pinia._p.forEach((extender) => {
        {
          assign$1(store, scope.run(() => extender({
            store,
            app: pinia._a,
            pinia,
            options: optionsForPlugin
          })));
        }
      });
      if (initialState && isOptionsStore && options.hydrate) {
        options.hydrate(store.$state, initialState);
      }
      isListening = true;
      isSyncListening = true;
      return store;
    }
    function defineStore(idOrOptions, setup, setupOptions) {
      let id;
      let options;
      const isSetupStore = typeof setup === "function";
      if (typeof idOrOptions === "string") {
        id = idOrOptions;
        options = isSetupStore ? setupOptions : setup;
      } else {
        options = idOrOptions;
        id = idOrOptions.id;
      }
      function useStore2(pinia, hot) {
        const hasContext = hasInjectionContext();
        pinia = // in test mode, ignore the argument provided as we can always retrieve a
        // pinia instance with getActivePinia()
        pinia || (hasContext ? inject(piniaSymbol, null) : null);
        if (pinia)
          setActivePinia(pinia);
        pinia = activePinia;
        if (!pinia._s.has(id)) {
          if (isSetupStore) {
            createSetupStore(id, setup, options, pinia);
          } else {
            createOptionsStore(id, options, pinia);
          }
        }
        const store = pinia._s.get(id);
        return store;
      }
      useStore2.$id = id;
      return useStore2;
    }
    /*!
      * vue-router v4.2.5
      * (c) 2023 Eduardo San Martin Morote
      * @license MIT
      */
    const isBrowser = typeof window !== "undefined";
    function isESModule(obj) {
      return obj.__esModule || obj[Symbol.toStringTag] === "Module";
    }
    const assign = Object.assign;
    function applyToParams(fn2, params) {
      const newParams = {};
      for (const key in params) {
        const value = params[key];
        newParams[key] = isArray$2(value) ? value.map(fn2) : fn2(value);
      }
      return newParams;
    }
    const noop$2 = () => {
    };
    const isArray$2 = Array.isArray;
    const TRAILING_SLASH_RE = /\/$/;
    const removeTrailingSlash = (path) => path.replace(TRAILING_SLASH_RE, "");
    function parseURL(parseQuery2, location2, currentLocation = "/") {
      let path, query = {}, searchString = "", hash = "";
      const hashPos = location2.indexOf("#");
      let searchPos = location2.indexOf("?");
      if (hashPos < searchPos && hashPos >= 0) {
        searchPos = -1;
      }
      if (searchPos > -1) {
        path = location2.slice(0, searchPos);
        searchString = location2.slice(searchPos + 1, hashPos > -1 ? hashPos : location2.length);
        query = parseQuery2(searchString);
      }
      if (hashPos > -1) {
        path = path || location2.slice(0, hashPos);
        hash = location2.slice(hashPos, location2.length);
      }
      path = resolveRelativePath(path != null ? path : location2, currentLocation);
      return {
        fullPath: path + (searchString && "?") + searchString + hash,
        path,
        query,
        hash
      };
    }
    function stringifyURL(stringifyQuery2, location2) {
      const query = location2.query ? stringifyQuery2(location2.query) : "";
      return location2.path + (query && "?") + query + (location2.hash || "");
    }
    function stripBase(pathname, base) {
      if (!base || !pathname.toLowerCase().startsWith(base.toLowerCase()))
        return pathname;
      return pathname.slice(base.length) || "/";
    }
    function isSameRouteLocation(stringifyQuery2, a2, b2) {
      const aLastIndex = a2.matched.length - 1;
      const bLastIndex = b2.matched.length - 1;
      return aLastIndex > -1 && aLastIndex === bLastIndex && isSameRouteRecord(a2.matched[aLastIndex], b2.matched[bLastIndex]) && isSameRouteLocationParams(a2.params, b2.params) && stringifyQuery2(a2.query) === stringifyQuery2(b2.query) && a2.hash === b2.hash;
    }
    function isSameRouteRecord(a2, b2) {
      return (a2.aliasOf || a2) === (b2.aliasOf || b2);
    }
    function isSameRouteLocationParams(a2, b2) {
      if (Object.keys(a2).length !== Object.keys(b2).length)
        return false;
      for (const key in a2) {
        if (!isSameRouteLocationParamsValue(a2[key], b2[key]))
          return false;
      }
      return true;
    }
    function isSameRouteLocationParamsValue(a2, b2) {
      return isArray$2(a2) ? isEquivalentArray(a2, b2) : isArray$2(b2) ? isEquivalentArray(b2, a2) : a2 === b2;
    }
    function isEquivalentArray(a2, b2) {
      return isArray$2(b2) ? a2.length === b2.length && a2.every((value, i) => value === b2[i]) : a2.length === 1 && a2[0] === b2;
    }
    function resolveRelativePath(to, from) {
      if (to.startsWith("/"))
        return to;
      if (!to)
        return from;
      const fromSegments = from.split("/");
      const toSegments = to.split("/");
      const lastToSegment = toSegments[toSegments.length - 1];
      if (lastToSegment === ".." || lastToSegment === ".") {
        toSegments.push("");
      }
      let position = fromSegments.length - 1;
      let toPosition;
      let segment;
      for (toPosition = 0; toPosition < toSegments.length; toPosition++) {
        segment = toSegments[toPosition];
        if (segment === ".")
          continue;
        if (segment === "..") {
          if (position > 1)
            position--;
        } else
          break;
      }
      return fromSegments.slice(0, position).join("/") + "/" + toSegments.slice(toPosition - (toPosition === toSegments.length ? 1 : 0)).join("/");
    }
    var NavigationType;
    (function(NavigationType2) {
      NavigationType2["pop"] = "pop";
      NavigationType2["push"] = "push";
    })(NavigationType || (NavigationType = {}));
    var NavigationDirection;
    (function(NavigationDirection2) {
      NavigationDirection2["back"] = "back";
      NavigationDirection2["forward"] = "forward";
      NavigationDirection2["unknown"] = "";
    })(NavigationDirection || (NavigationDirection = {}));
    function normalizeBase(base) {
      if (!base) {
        if (isBrowser) {
          const baseEl = document.querySelector("base");
          base = baseEl && baseEl.getAttribute("href") || "/";
          base = base.replace(/^\w+:\/\/[^\/]+/, "");
        } else {
          base = "/";
        }
      }
      if (base[0] !== "/" && base[0] !== "#")
        base = "/" + base;
      return removeTrailingSlash(base);
    }
    const BEFORE_HASH_RE = /^[^#]+#/;
    function createHref(base, location2) {
      return base.replace(BEFORE_HASH_RE, "#") + location2;
    }
    function getElementPosition(el, offset2) {
      const docRect = document.documentElement.getBoundingClientRect();
      const elRect = el.getBoundingClientRect();
      return {
        behavior: offset2.behavior,
        left: elRect.left - docRect.left - (offset2.left || 0),
        top: elRect.top - docRect.top - (offset2.top || 0)
      };
    }
    const computeScrollPosition = () => ({
      left: window.pageXOffset,
      top: window.pageYOffset
    });
    function scrollToPosition(position) {
      let scrollToOptions;
      if ("el" in position) {
        const positionEl = position.el;
        const isIdSelector = typeof positionEl === "string" && positionEl.startsWith("#");
        const el = typeof positionEl === "string" ? isIdSelector ? document.getElementById(positionEl.slice(1)) : document.querySelector(positionEl) : positionEl;
        if (!el) {
          return;
        }
        scrollToOptions = getElementPosition(el, position);
      } else {
        scrollToOptions = position;
      }
      if ("scrollBehavior" in document.documentElement.style)
        window.scrollTo(scrollToOptions);
      else {
        window.scrollTo(scrollToOptions.left != null ? scrollToOptions.left : window.pageXOffset, scrollToOptions.top != null ? scrollToOptions.top : window.pageYOffset);
      }
    }
    function getScrollKey(path, delta) {
      const position = history.state ? history.state.position - delta : -1;
      return position + path;
    }
    const scrollPositions = /* @__PURE__ */ new Map();
    function saveScrollPosition(key, scrollPosition) {
      scrollPositions.set(key, scrollPosition);
    }
    function getSavedScrollPosition(key) {
      const scroll = scrollPositions.get(key);
      scrollPositions.delete(key);
      return scroll;
    }
    let createBaseLocation = () => location.protocol + "//" + location.host;
    function createCurrentLocation(base, location2) {
      const { pathname, search, hash } = location2;
      const hashPos = base.indexOf("#");
      if (hashPos > -1) {
        let slicePos = hash.includes(base.slice(hashPos)) ? base.slice(hashPos).length : 1;
        let pathFromHash = hash.slice(slicePos);
        if (pathFromHash[0] !== "/")
          pathFromHash = "/" + pathFromHash;
        return stripBase(pathFromHash, "");
      }
      const path = stripBase(pathname, base);
      return path + search + hash;
    }
    function useHistoryListeners(base, historyState, currentLocation, replace) {
      let listeners = [];
      let teardowns = [];
      let pauseState = null;
      const popStateHandler = ({ state }) => {
        const to = createCurrentLocation(base, location);
        const from = currentLocation.value;
        const fromState = historyState.value;
        let delta = 0;
        if (state) {
          currentLocation.value = to;
          historyState.value = state;
          if (pauseState && pauseState === from) {
            pauseState = null;
            return;
          }
          delta = fromState ? state.position - fromState.position : 0;
        } else {
          replace(to);
        }
        listeners.forEach((listener) => {
          listener(currentLocation.value, from, {
            delta,
            type: NavigationType.pop,
            direction: delta ? delta > 0 ? NavigationDirection.forward : NavigationDirection.back : NavigationDirection.unknown
          });
        });
      };
      function pauseListeners() {
        pauseState = currentLocation.value;
      }
      function listen(callback) {
        listeners.push(callback);
        const teardown = () => {
          const index2 = listeners.indexOf(callback);
          if (index2 > -1)
            listeners.splice(index2, 1);
        };
        teardowns.push(teardown);
        return teardown;
      }
      function beforeUnloadListener() {
        const { history: history2 } = window;
        if (!history2.state)
          return;
        history2.replaceState(assign({}, history2.state, { scroll: computeScrollPosition() }), "");
      }
      function destroy() {
        for (const teardown of teardowns)
          teardown();
        teardowns = [];
        window.removeEventListener("popstate", popStateHandler);
        window.removeEventListener("beforeunload", beforeUnloadListener);
      }
      window.addEventListener("popstate", popStateHandler);
      window.addEventListener("beforeunload", beforeUnloadListener, {
        passive: true
      });
      return {
        pauseListeners,
        listen,
        destroy
      };
    }
    function buildState(back, current, forward, replaced = false, computeScroll = false) {
      return {
        back,
        current,
        forward,
        replaced,
        position: window.history.length,
        scroll: computeScroll ? computeScrollPosition() : null
      };
    }
    function useHistoryStateNavigation(base) {
      const { history: history2, location: location2 } = window;
      const currentLocation = {
        value: createCurrentLocation(base, location2)
      };
      const historyState = { value: history2.state };
      if (!historyState.value) {
        changeLocation(currentLocation.value, {
          back: null,
          current: currentLocation.value,
          forward: null,
          // the length is off by one, we need to decrease it
          position: history2.length - 1,
          replaced: true,
          // don't add a scroll as the user may have an anchor, and we want
          // scrollBehavior to be triggered without a saved position
          scroll: null
        }, true);
      }
      function changeLocation(to, state, replace2) {
        const hashIndex = base.indexOf("#");
        const url = hashIndex > -1 ? (location2.host && document.querySelector("base") ? base : base.slice(hashIndex)) + to : createBaseLocation() + base + to;
        try {
          history2[replace2 ? "replaceState" : "pushState"](state, "", url);
          historyState.value = state;
        } catch (err) {
          {
            console.error(err);
          }
          location2[replace2 ? "replace" : "assign"](url);
        }
      }
      function replace(to, data) {
        const state = assign({}, history2.state, buildState(
          historyState.value.back,
          // keep back and forward entries but override current position
          to,
          historyState.value.forward,
          true
        ), data, { position: historyState.value.position });
        changeLocation(to, state, true);
        currentLocation.value = to;
      }
      function push(to, data) {
        const currentState = assign(
          {},
          // use current history state to gracefully handle a wrong call to
          // history.replaceState
          // https://github.com/vuejs/router/issues/366
          historyState.value,
          history2.state,
          {
            forward: to,
            scroll: computeScrollPosition()
          }
        );
        changeLocation(currentState.current, currentState, true);
        const state = assign({}, buildState(currentLocation.value, to, null), { position: currentState.position + 1 }, data);
        changeLocation(to, state, false);
        currentLocation.value = to;
      }
      return {
        location: currentLocation,
        state: historyState,
        push,
        replace
      };
    }
    function createWebHistory(base) {
      base = normalizeBase(base);
      const historyNavigation = useHistoryStateNavigation(base);
      const historyListeners = useHistoryListeners(base, historyNavigation.state, historyNavigation.location, historyNavigation.replace);
      function go(delta, triggerListeners = true) {
        if (!triggerListeners)
          historyListeners.pauseListeners();
        history.go(delta);
      }
      const routerHistory = assign({
        // it's overridden right after
        location: "",
        base,
        go,
        createHref: createHref.bind(null, base)
      }, historyNavigation, historyListeners);
      Object.defineProperty(routerHistory, "location", {
        enumerable: true,
        get: () => historyNavigation.location.value
      });
      Object.defineProperty(routerHistory, "state", {
        enumerable: true,
        get: () => historyNavigation.state.value
      });
      return routerHistory;
    }
    function createWebHashHistory(base) {
      base = location.host ? base || location.pathname + location.search : "";
      if (!base.includes("#"))
        base += "#";
      return createWebHistory(base);
    }
    function isRouteLocation(route) {
      return typeof route === "string" || route && typeof route === "object";
    }
    function isRouteName(name) {
      return typeof name === "string" || typeof name === "symbol";
    }
    const START_LOCATION_NORMALIZED = {
      path: "/",
      name: void 0,
      params: {},
      query: {},
      hash: "",
      fullPath: "/",
      matched: [],
      meta: {},
      redirectedFrom: void 0
    };
    const NavigationFailureSymbol = Symbol("");
    var NavigationFailureType;
    (function(NavigationFailureType2) {
      NavigationFailureType2[NavigationFailureType2["aborted"] = 4] = "aborted";
      NavigationFailureType2[NavigationFailureType2["cancelled"] = 8] = "cancelled";
      NavigationFailureType2[NavigationFailureType2["duplicated"] = 16] = "duplicated";
    })(NavigationFailureType || (NavigationFailureType = {}));
    function createRouterError(type2, params) {
      {
        return assign(new Error(), {
          type: type2,
          [NavigationFailureSymbol]: true
        }, params);
      }
    }
    function isNavigationFailure(error, type2) {
      return error instanceof Error && NavigationFailureSymbol in error && (type2 == null || !!(error.type & type2));
    }
    const BASE_PARAM_PATTERN = "[^/]+?";
    const BASE_PATH_PARSER_OPTIONS = {
      sensitive: false,
      strict: false,
      start: true,
      end: true
    };
    const REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
    function tokensToParser(segments, extraOptions) {
      const options = assign({}, BASE_PATH_PARSER_OPTIONS, extraOptions);
      const score = [];
      let pattern2 = options.start ? "^" : "";
      const keys2 = [];
      for (const segment of segments) {
        const segmentScores = segment.length ? [] : [
          90
          /* PathScore.Root */
        ];
        if (options.strict && !segment.length)
          pattern2 += "/";
        for (let tokenIndex = 0; tokenIndex < segment.length; tokenIndex++) {
          const token = segment[tokenIndex];
          let subSegmentScore = 40 + (options.sensitive ? 0.25 : 0);
          if (token.type === 0) {
            if (!tokenIndex)
              pattern2 += "/";
            pattern2 += token.value.replace(REGEX_CHARS_RE, "\\$&");
            subSegmentScore += 40;
          } else if (token.type === 1) {
            const { value, repeatable, optional, regexp: regexp2 } = token;
            keys2.push({
              name: value,
              repeatable,
              optional
            });
            const re2 = regexp2 ? regexp2 : BASE_PARAM_PATTERN;
            if (re2 !== BASE_PARAM_PATTERN) {
              subSegmentScore += 10;
              try {
                new RegExp(`(${re2})`);
              } catch (err) {
                throw new Error(`Invalid custom RegExp for param "${value}" (${re2}): ` + err.message);
              }
            }
            let subPattern = repeatable ? `((?:${re2})(?:/(?:${re2}))*)` : `(${re2})`;
            if (!tokenIndex)
              subPattern = // avoid an optional / if there are more segments e.g. /:p?-static
              // or /:p?-:p2
              optional && segment.length < 2 ? `(?:/${subPattern})` : "/" + subPattern;
            if (optional)
              subPattern += "?";
            pattern2 += subPattern;
            subSegmentScore += 20;
            if (optional)
              subSegmentScore += -8;
            if (repeatable)
              subSegmentScore += -20;
            if (re2 === ".*")
              subSegmentScore += -50;
          }
          segmentScores.push(subSegmentScore);
        }
        score.push(segmentScores);
      }
      if (options.strict && options.end) {
        const i = score.length - 1;
        score[i][score[i].length - 1] += 0.7000000000000001;
      }
      if (!options.strict)
        pattern2 += "/?";
      if (options.end)
        pattern2 += "$";
      else if (options.strict)
        pattern2 += "(?:/|$)";
      const re = new RegExp(pattern2, options.sensitive ? "" : "i");
      function parse(path) {
        const match = path.match(re);
        const params = {};
        if (!match)
          return null;
        for (let i = 1; i < match.length; i++) {
          const value = match[i] || "";
          const key = keys2[i - 1];
          params[key.name] = value && key.repeatable ? value.split("/") : value;
        }
        return params;
      }
      function stringify(params) {
        let path = "";
        let avoidDuplicatedSlash = false;
        for (const segment of segments) {
          if (!avoidDuplicatedSlash || !path.endsWith("/"))
            path += "/";
          avoidDuplicatedSlash = false;
          for (const token of segment) {
            if (token.type === 0) {
              path += token.value;
            } else if (token.type === 1) {
              const { value, repeatable, optional } = token;
              const param = value in params ? params[value] : "";
              if (isArray$2(param) && !repeatable) {
                throw new Error(`Provided param "${value}" is an array but it is not repeatable (* or + modifiers)`);
              }
              const text = isArray$2(param) ? param.join("/") : param;
              if (!text) {
                if (optional) {
                  if (segment.length < 2) {
                    if (path.endsWith("/"))
                      path = path.slice(0, -1);
                    else
                      avoidDuplicatedSlash = true;
                  }
                } else
                  throw new Error(`Missing required param "${value}"`);
              }
              path += text;
            }
          }
        }
        return path || "/";
      }
      return {
        re,
        score,
        keys: keys2,
        parse,
        stringify
      };
    }
    function compareScoreArray(a2, b2) {
      let i = 0;
      while (i < a2.length && i < b2.length) {
        const diff = b2[i] - a2[i];
        if (diff)
          return diff;
        i++;
      }
      if (a2.length < b2.length) {
        return a2.length === 1 && a2[0] === 40 + 40 ? -1 : 1;
      } else if (a2.length > b2.length) {
        return b2.length === 1 && b2[0] === 40 + 40 ? 1 : -1;
      }
      return 0;
    }
    function comparePathParserScore(a2, b2) {
      let i = 0;
      const aScore = a2.score;
      const bScore = b2.score;
      while (i < aScore.length && i < bScore.length) {
        const comp = compareScoreArray(aScore[i], bScore[i]);
        if (comp)
          return comp;
        i++;
      }
      if (Math.abs(bScore.length - aScore.length) === 1) {
        if (isLastScoreNegative(aScore))
          return 1;
        if (isLastScoreNegative(bScore))
          return -1;
      }
      return bScore.length - aScore.length;
    }
    function isLastScoreNegative(score) {
      const last = score[score.length - 1];
      return score.length > 0 && last[last.length - 1] < 0;
    }
    const ROOT_TOKEN = {
      type: 0,
      value: ""
    };
    const VALID_PARAM_RE = /[a-zA-Z0-9_]/;
    function tokenizePath(path) {
      if (!path)
        return [[]];
      if (path === "/")
        return [[ROOT_TOKEN]];
      if (!path.startsWith("/")) {
        throw new Error(`Invalid path "${path}"`);
      }
      function crash(message2) {
        throw new Error(`ERR (${state})/"${buffer}": ${message2}`);
      }
      let state = 0;
      let previousState = state;
      const tokens = [];
      let segment;
      function finalizeSegment() {
        if (segment)
          tokens.push(segment);
        segment = [];
      }
      let i = 0;
      let char;
      let buffer = "";
      let customRe = "";
      function consumeBuffer() {
        if (!buffer)
          return;
        if (state === 0) {
          segment.push({
            type: 0,
            value: buffer
          });
        } else if (state === 1 || state === 2 || state === 3) {
          if (segment.length > 1 && (char === "*" || char === "+"))
            crash(`A repeatable param (${buffer}) must be alone in its segment. eg: '/:ids+.`);
          segment.push({
            type: 1,
            value: buffer,
            regexp: customRe,
            repeatable: char === "*" || char === "+",
            optional: char === "*" || char === "?"
          });
        } else {
          crash("Invalid state to consume buffer");
        }
        buffer = "";
      }
      function addCharToBuffer() {
        buffer += char;
      }
      while (i < path.length) {
        char = path[i++];
        if (char === "\\" && state !== 2) {
          previousState = state;
          state = 4;
          continue;
        }
        switch (state) {
          case 0:
            if (char === "/") {
              if (buffer) {
                consumeBuffer();
              }
              finalizeSegment();
            } else if (char === ":") {
              consumeBuffer();
              state = 1;
            } else {
              addCharToBuffer();
            }
            break;
          case 4:
            addCharToBuffer();
            state = previousState;
            break;
          case 1:
            if (char === "(") {
              state = 2;
            } else if (VALID_PARAM_RE.test(char)) {
              addCharToBuffer();
            } else {
              consumeBuffer();
              state = 0;
              if (char !== "*" && char !== "?" && char !== "+")
                i--;
            }
            break;
          case 2:
            if (char === ")") {
              if (customRe[customRe.length - 1] == "\\")
                customRe = customRe.slice(0, -1) + char;
              else
                state = 3;
            } else {
              customRe += char;
            }
            break;
          case 3:
            consumeBuffer();
            state = 0;
            if (char !== "*" && char !== "?" && char !== "+")
              i--;
            customRe = "";
            break;
          default:
            crash("Unknown state");
            break;
        }
      }
      if (state === 2)
        crash(`Unfinished custom RegExp for param "${buffer}"`);
      consumeBuffer();
      finalizeSegment();
      return tokens;
    }
    function createRouteRecordMatcher(record, parent, options) {
      const parser = tokensToParser(tokenizePath(record.path), options);
      const matcher = assign(parser, {
        record,
        parent,
        // these needs to be populated by the parent
        children: [],
        alias: []
      });
      if (parent) {
        if (!matcher.record.aliasOf === !parent.record.aliasOf)
          parent.children.push(matcher);
      }
      return matcher;
    }
    function createRouterMatcher(routes, globalOptions) {
      const matchers2 = [];
      const matcherMap = /* @__PURE__ */ new Map();
      globalOptions = mergeOptions$1({ strict: false, end: true, sensitive: false }, globalOptions);
      function getRecordMatcher(name) {
        return matcherMap.get(name);
      }
      function addRoute(record, parent, originalRecord) {
        const isRootAdd = !originalRecord;
        const mainNormalizedRecord = normalizeRouteRecord(record);
        mainNormalizedRecord.aliasOf = originalRecord && originalRecord.record;
        const options = mergeOptions$1(globalOptions, record);
        const normalizedRecords = [
          mainNormalizedRecord
        ];
        if ("alias" in record) {
          const aliases = typeof record.alias === "string" ? [record.alias] : record.alias;
          for (const alias of aliases) {
            normalizedRecords.push(assign({}, mainNormalizedRecord, {
              // this allows us to hold a copy of the `components` option
              // so that async components cache is hold on the original record
              components: originalRecord ? originalRecord.record.components : mainNormalizedRecord.components,
              path: alias,
              // we might be the child of an alias
              aliasOf: originalRecord ? originalRecord.record : mainNormalizedRecord
              // the aliases are always of the same kind as the original since they
              // are defined on the same record
            }));
          }
        }
        let matcher;
        let originalMatcher;
        for (const normalizedRecord of normalizedRecords) {
          const { path } = normalizedRecord;
          if (parent && path[0] !== "/") {
            const parentPath = parent.record.path;
            const connectingSlash = parentPath[parentPath.length - 1] === "/" ? "" : "/";
            normalizedRecord.path = parent.record.path + (path && connectingSlash + path);
          }
          matcher = createRouteRecordMatcher(normalizedRecord, parent, options);
          if (originalRecord) {
            originalRecord.alias.push(matcher);
          } else {
            originalMatcher = originalMatcher || matcher;
            if (originalMatcher !== matcher)
              originalMatcher.alias.push(matcher);
            if (isRootAdd && record.name && !isAliasRecord(matcher))
              removeRoute(record.name);
          }
          if (mainNormalizedRecord.children) {
            const children = mainNormalizedRecord.children;
            for (let i = 0; i < children.length; i++) {
              addRoute(children[i], matcher, originalRecord && originalRecord.children[i]);
            }
          }
          originalRecord = originalRecord || matcher;
          if (matcher.record.components && Object.keys(matcher.record.components).length || matcher.record.name || matcher.record.redirect) {
            insertMatcher(matcher);
          }
        }
        return originalMatcher ? () => {
          removeRoute(originalMatcher);
        } : noop$2;
      }
      function removeRoute(matcherRef) {
        if (isRouteName(matcherRef)) {
          const matcher = matcherMap.get(matcherRef);
          if (matcher) {
            matcherMap.delete(matcherRef);
            matchers2.splice(matchers2.indexOf(matcher), 1);
            matcher.children.forEach(removeRoute);
            matcher.alias.forEach(removeRoute);
          }
        } else {
          const index2 = matchers2.indexOf(matcherRef);
          if (index2 > -1) {
            matchers2.splice(index2, 1);
            if (matcherRef.record.name)
              matcherMap.delete(matcherRef.record.name);
            matcherRef.children.forEach(removeRoute);
            matcherRef.alias.forEach(removeRoute);
          }
        }
      }
      function getRoutes() {
        return matchers2;
      }
      function insertMatcher(matcher) {
        let i = 0;
        while (i < matchers2.length && comparePathParserScore(matcher, matchers2[i]) >= 0 && // Adding children with empty path should still appear before the parent
        // https://github.com/vuejs/router/issues/1124
        (matcher.record.path !== matchers2[i].record.path || !isRecordChildOf(matcher, matchers2[i])))
          i++;
        matchers2.splice(i, 0, matcher);
        if (matcher.record.name && !isAliasRecord(matcher))
          matcherMap.set(matcher.record.name, matcher);
      }
      function resolve2(location2, currentLocation) {
        let matcher;
        let params = {};
        let path;
        let name;
        if ("name" in location2 && location2.name) {
          matcher = matcherMap.get(location2.name);
          if (!matcher)
            throw createRouterError(1, {
              location: location2
            });
          name = matcher.record.name;
          params = assign(
            // paramsFromLocation is a new object
            paramsFromLocation(
              currentLocation.params,
              // only keep params that exist in the resolved location
              // TODO: only keep optional params coming from a parent record
              matcher.keys.filter((k) => !k.optional).map((k) => k.name)
            ),
            // discard any existing params in the current location that do not exist here
            // #1497 this ensures better active/exact matching
            location2.params && paramsFromLocation(location2.params, matcher.keys.map((k) => k.name))
          );
          path = matcher.stringify(params);
        } else if ("path" in location2) {
          path = location2.path;
          matcher = matchers2.find((m2) => m2.re.test(path));
          if (matcher) {
            params = matcher.parse(path);
            name = matcher.record.name;
          }
        } else {
          matcher = currentLocation.name ? matcherMap.get(currentLocation.name) : matchers2.find((m2) => m2.re.test(currentLocation.path));
          if (!matcher)
            throw createRouterError(1, {
              location: location2,
              currentLocation
            });
          name = matcher.record.name;
          params = assign({}, currentLocation.params, location2.params);
          path = matcher.stringify(params);
        }
        const matched = [];
        let parentMatcher = matcher;
        while (parentMatcher) {
          matched.unshift(parentMatcher.record);
          parentMatcher = parentMatcher.parent;
        }
        return {
          name,
          path,
          params,
          matched,
          meta: mergeMetaFields(matched)
        };
      }
      routes.forEach((route) => addRoute(route));
      return { addRoute, resolve: resolve2, removeRoute, getRoutes, getRecordMatcher };
    }
    function paramsFromLocation(params, keys2) {
      const newParams = {};
      for (const key of keys2) {
        if (key in params)
          newParams[key] = params[key];
      }
      return newParams;
    }
    function normalizeRouteRecord(record) {
      return {
        path: record.path,
        redirect: record.redirect,
        name: record.name,
        meta: record.meta || {},
        aliasOf: void 0,
        beforeEnter: record.beforeEnter,
        props: normalizeRecordProps(record),
        children: record.children || [],
        instances: {},
        leaveGuards: /* @__PURE__ */ new Set(),
        updateGuards: /* @__PURE__ */ new Set(),
        enterCallbacks: {},
        components: "components" in record ? record.components || null : record.component && { default: record.component }
      };
    }
    function normalizeRecordProps(record) {
      const propsObject = {};
      const props = record.props || false;
      if ("component" in record) {
        propsObject.default = props;
      } else {
        for (const name in record.components)
          propsObject[name] = typeof props === "object" ? props[name] : props;
      }
      return propsObject;
    }
    function isAliasRecord(record) {
      while (record) {
        if (record.record.aliasOf)
          return true;
        record = record.parent;
      }
      return false;
    }
    function mergeMetaFields(matched) {
      return matched.reduce((meta, record) => assign(meta, record.meta), {});
    }
    function mergeOptions$1(defaults, partialOptions) {
      const options = {};
      for (const key in defaults) {
        options[key] = key in partialOptions ? partialOptions[key] : defaults[key];
      }
      return options;
    }
    function isRecordChildOf(record, parent) {
      return parent.children.some((child) => child === record || isRecordChildOf(record, child));
    }
    const HASH_RE = /#/g;
    const AMPERSAND_RE = /&/g;
    const SLASH_RE = /\//g;
    const EQUAL_RE = /=/g;
    const IM_RE = /\?/g;
    const PLUS_RE = /\+/g;
    const ENC_BRACKET_OPEN_RE = /%5B/g;
    const ENC_BRACKET_CLOSE_RE = /%5D/g;
    const ENC_CARET_RE = /%5E/g;
    const ENC_BACKTICK_RE = /%60/g;
    const ENC_CURLY_OPEN_RE = /%7B/g;
    const ENC_PIPE_RE = /%7C/g;
    const ENC_CURLY_CLOSE_RE = /%7D/g;
    const ENC_SPACE_RE = /%20/g;
    function commonEncode(text) {
      return encodeURI("" + text).replace(ENC_PIPE_RE, "|").replace(ENC_BRACKET_OPEN_RE, "[").replace(ENC_BRACKET_CLOSE_RE, "]");
    }
    function encodeHash(text) {
      return commonEncode(text).replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
    }
    function encodeQueryValue(text) {
      return commonEncode(text).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
    }
    function encodeQueryKey(text) {
      return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
    }
    function encodePath(text) {
      return commonEncode(text).replace(HASH_RE, "%23").replace(IM_RE, "%3F");
    }
    function encodeParam(text) {
      return text == null ? "" : encodePath(text).replace(SLASH_RE, "%2F");
    }
    function decode(text) {
      try {
        return decodeURIComponent("" + text);
      } catch (err) {
      }
      return "" + text;
    }
    function parseQuery(search) {
      const query = {};
      if (search === "" || search === "?")
        return query;
      const hasLeadingIM = search[0] === "?";
      const searchParams = (hasLeadingIM ? search.slice(1) : search).split("&");
      for (let i = 0; i < searchParams.length; ++i) {
        const searchParam = searchParams[i].replace(PLUS_RE, " ");
        const eqPos = searchParam.indexOf("=");
        const key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));
        const value = eqPos < 0 ? null : decode(searchParam.slice(eqPos + 1));
        if (key in query) {
          let currentValue = query[key];
          if (!isArray$2(currentValue)) {
            currentValue = query[key] = [currentValue];
          }
          currentValue.push(value);
        } else {
          query[key] = value;
        }
      }
      return query;
    }
    function stringifyQuery(query) {
      let search = "";
      for (let key in query) {
        const value = query[key];
        key = encodeQueryKey(key);
        if (value == null) {
          if (value !== void 0) {
            search += (search.length ? "&" : "") + key;
          }
          continue;
        }
        const values = isArray$2(value) ? value.map((v2) => v2 && encodeQueryValue(v2)) : [value && encodeQueryValue(value)];
        values.forEach((value2) => {
          if (value2 !== void 0) {
            search += (search.length ? "&" : "") + key;
            if (value2 != null)
              search += "=" + value2;
          }
        });
      }
      return search;
    }
    function normalizeQuery(query) {
      const normalizedQuery = {};
      for (const key in query) {
        const value = query[key];
        if (value !== void 0) {
          normalizedQuery[key] = isArray$2(value) ? value.map((v2) => v2 == null ? null : "" + v2) : value == null ? value : "" + value;
        }
      }
      return normalizedQuery;
    }
    const matchedRouteKey = Symbol("");
    const viewDepthKey = Symbol("");
    const routerKey = Symbol("");
    const routeLocationKey = Symbol("");
    const routerViewLocationKey = Symbol("");
    function useCallbacks() {
      let handlers = [];
      function add2(handler) {
        handlers.push(handler);
        return () => {
          const i = handlers.indexOf(handler);
          if (i > -1)
            handlers.splice(i, 1);
        };
      }
      function reset() {
        handlers = [];
      }
      return {
        add: add2,
        list: () => handlers.slice(),
        reset
      };
    }
    function guardToPromiseFn(guard, to, from, record, name) {
      const enterCallbackArray = record && // name is defined if record is because of the function overload
      (record.enterCallbacks[name] = record.enterCallbacks[name] || []);
      return () => new Promise((resolve2, reject) => {
        const next = (valid) => {
          if (valid === false) {
            reject(createRouterError(4, {
              from,
              to
            }));
          } else if (valid instanceof Error) {
            reject(valid);
          } else if (isRouteLocation(valid)) {
            reject(createRouterError(2, {
              from: to,
              to: valid
            }));
          } else {
            if (enterCallbackArray && // since enterCallbackArray is truthy, both record and name also are
            record.enterCallbacks[name] === enterCallbackArray && typeof valid === "function") {
              enterCallbackArray.push(valid);
            }
            resolve2();
          }
        };
        const guardReturn = guard.call(record && record.instances[name], to, from, next);
        let guardCall = Promise.resolve(guardReturn);
        if (guard.length < 3)
          guardCall = guardCall.then(next);
        guardCall.catch((err) => reject(err));
      });
    }
    function extractComponentsGuards(matched, guardType, to, from) {
      const guards = [];
      for (const record of matched) {
        for (const name in record.components) {
          let rawComponent = record.components[name];
          if (guardType !== "beforeRouteEnter" && !record.instances[name])
            continue;
          if (isRouteComponent(rawComponent)) {
            const options = rawComponent.__vccOpts || rawComponent;
            const guard = options[guardType];
            guard && guards.push(guardToPromiseFn(guard, to, from, record, name));
          } else {
            let componentPromise = rawComponent();
            guards.push(() => componentPromise.then((resolved) => {
              if (!resolved)
                return Promise.reject(new Error(`Couldn't resolve component "${name}" at "${record.path}"`));
              const resolvedComponent = isESModule(resolved) ? resolved.default : resolved;
              record.components[name] = resolvedComponent;
              const options = resolvedComponent.__vccOpts || resolvedComponent;
              const guard = options[guardType];
              return guard && guardToPromiseFn(guard, to, from, record, name)();
            }));
          }
        }
      }
      return guards;
    }
    function isRouteComponent(component2) {
      return typeof component2 === "object" || "displayName" in component2 || "props" in component2 || "__vccOpts" in component2;
    }
    function useLink(props) {
      const router2 = inject(routerKey);
      const currentRoute = inject(routeLocationKey);
      const route = computed(() => router2.resolve(unref(props.to)));
      const activeRecordIndex = computed(() => {
        const { matched } = route.value;
        const { length } = matched;
        const routeMatched = matched[length - 1];
        const currentMatched = currentRoute.matched;
        if (!routeMatched || !currentMatched.length)
          return -1;
        const index2 = currentMatched.findIndex(isSameRouteRecord.bind(null, routeMatched));
        if (index2 > -1)
          return index2;
        const parentRecordPath = getOriginalPath(matched[length - 2]);
        return (
          // we are dealing with nested routes
          length > 1 && // if the parent and matched route have the same path, this link is
          // referring to the empty child. Or we currently are on a different
          // child of the same parent
          getOriginalPath(routeMatched) === parentRecordPath && // avoid comparing the child with its parent
          currentMatched[currentMatched.length - 1].path !== parentRecordPath ? currentMatched.findIndex(isSameRouteRecord.bind(null, matched[length - 2])) : index2
        );
      });
      const isActive = computed(() => activeRecordIndex.value > -1 && includesParams(currentRoute.params, route.value.params));
      const isExactActive = computed(() => activeRecordIndex.value > -1 && activeRecordIndex.value === currentRoute.matched.length - 1 && isSameRouteLocationParams(currentRoute.params, route.value.params));
      function navigate(e = {}) {
        if (guardEvent(e)) {
          return router2[unref(props.replace) ? "replace" : "push"](
            unref(props.to)
            // avoid uncaught errors are they are logged anyway
          ).catch(noop$2);
        }
        return Promise.resolve();
      }
      return {
        route,
        href: computed(() => route.value.href),
        isActive,
        isExactActive,
        navigate
      };
    }
    const RouterLinkImpl = /* @__PURE__ */ defineComponent({
      name: "RouterLink",
      compatConfig: { MODE: 3 },
      props: {
        to: {
          type: [String, Object],
          required: true
        },
        replace: Boolean,
        activeClass: String,
        // inactiveClass: String,
        exactActiveClass: String,
        custom: Boolean,
        ariaCurrentValue: {
          type: String,
          default: "page"
        }
      },
      useLink,
      setup(props, { slots }) {
        const link = reactive(useLink(props));
        const { options } = inject(routerKey);
        const elClass = computed(() => ({
          [getLinkClass(props.activeClass, options.linkActiveClass, "router-link-active")]: link.isActive,
          // [getLinkClass(
          //   props.inactiveClass,
          //   options.linkInactiveClass,
          //   'router-link-inactive'
          // )]: !link.isExactActive,
          [getLinkClass(props.exactActiveClass, options.linkExactActiveClass, "router-link-exact-active")]: link.isExactActive
        }));
        return () => {
          const children = slots.default && slots.default(link);
          return props.custom ? children : h$1("a", {
            "aria-current": link.isExactActive ? props.ariaCurrentValue : null,
            href: link.href,
            // this would override user added attrs but Vue will still add
            // the listener, so we end up triggering both
            onClick: link.navigate,
            class: elClass.value
          }, children);
        };
      }
    });
    const RouterLink = RouterLinkImpl;
    function guardEvent(e) {
      if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)
        return;
      if (e.defaultPrevented)
        return;
      if (e.button !== void 0 && e.button !== 0)
        return;
      if (e.currentTarget && e.currentTarget.getAttribute) {
        const target = e.currentTarget.getAttribute("target");
        if (/\b_blank\b/i.test(target))
          return;
      }
      if (e.preventDefault)
        e.preventDefault();
      return true;
    }
    function includesParams(outer, inner) {
      for (const key in inner) {
        const innerValue = inner[key];
        const outerValue = outer[key];
        if (typeof innerValue === "string") {
          if (innerValue !== outerValue)
            return false;
        } else {
          if (!isArray$2(outerValue) || outerValue.length !== innerValue.length || innerValue.some((value, i) => value !== outerValue[i]))
            return false;
        }
      }
      return true;
    }
    function getOriginalPath(record) {
      return record ? record.aliasOf ? record.aliasOf.path : record.path : "";
    }
    const getLinkClass = (propClass, globalClass, defaultClass) => propClass != null ? propClass : globalClass != null ? globalClass : defaultClass;
    const RouterViewImpl = /* @__PURE__ */ defineComponent({
      name: "RouterView",
      // #674 we manually inherit them
      inheritAttrs: false,
      props: {
        name: {
          type: String,
          default: "default"
        },
        route: Object
      },
      // Better compat for @vue/compat users
      // https://github.com/vuejs/router/issues/1315
      compatConfig: { MODE: 3 },
      setup(props, { attrs, slots }) {
        const injectedRoute = inject(routerViewLocationKey);
        const routeToDisplay = computed(() => props.route || injectedRoute.value);
        const injectedDepth = inject(viewDepthKey, 0);
        const depth = computed(() => {
          let initialDepth = unref(injectedDepth);
          const { matched } = routeToDisplay.value;
          let matchedRoute;
          while ((matchedRoute = matched[initialDepth]) && !matchedRoute.components) {
            initialDepth++;
          }
          return initialDepth;
        });
        const matchedRouteRef = computed(() => routeToDisplay.value.matched[depth.value]);
        provide(viewDepthKey, computed(() => depth.value + 1));
        provide(matchedRouteKey, matchedRouteRef);
        provide(routerViewLocationKey, routeToDisplay);
        const viewRef = ref();
        watch(() => [viewRef.value, matchedRouteRef.value, props.name], ([instance, to, name], [oldInstance, from, oldName]) => {
          if (to) {
            to.instances[name] = instance;
            if (from && from !== to && instance && instance === oldInstance) {
              if (!to.leaveGuards.size) {
                to.leaveGuards = from.leaveGuards;
              }
              if (!to.updateGuards.size) {
                to.updateGuards = from.updateGuards;
              }
            }
          }
          if (instance && to && // if there is no instance but to and from are the same this might be
          // the first visit
          (!from || !isSameRouteRecord(to, from) || !oldInstance)) {
            (to.enterCallbacks[name] || []).forEach((callback) => callback(instance));
          }
        }, { flush: "post" });
        return () => {
          const route = routeToDisplay.value;
          const currentName = props.name;
          const matchedRoute = matchedRouteRef.value;
          const ViewComponent = matchedRoute && matchedRoute.components[currentName];
          if (!ViewComponent) {
            return normalizeSlot(slots.default, { Component: ViewComponent, route });
          }
          const routePropsOption = matchedRoute.props[currentName];
          const routeProps = routePropsOption ? routePropsOption === true ? route.params : typeof routePropsOption === "function" ? routePropsOption(route) : routePropsOption : null;
          const onVnodeUnmounted = (vnode) => {
            if (vnode.component.isUnmounted) {
              matchedRoute.instances[currentName] = null;
            }
          };
          const component2 = h$1(ViewComponent, assign({}, routeProps, attrs, {
            onVnodeUnmounted,
            ref: viewRef
          }));
          return (
            // pass the vnode to the slot as a prop.
            // h and <component :is="..."> both accept vnodes
            normalizeSlot(slots.default, { Component: component2, route }) || component2
          );
        };
      }
    });
    function normalizeSlot(slot, data) {
      if (!slot)
        return null;
      const slotContent = slot(data);
      return slotContent.length === 1 ? slotContent[0] : slotContent;
    }
    const RouterView = RouterViewImpl;
    function createRouter(options) {
      const matcher = createRouterMatcher(options.routes, options);
      const parseQuery$1 = options.parseQuery || parseQuery;
      const stringifyQuery$1 = options.stringifyQuery || stringifyQuery;
      const routerHistory = options.history;
      const beforeGuards = useCallbacks();
      const beforeResolveGuards = useCallbacks();
      const afterGuards = useCallbacks();
      const currentRoute = shallowRef(START_LOCATION_NORMALIZED);
      let pendingLocation = START_LOCATION_NORMALIZED;
      if (isBrowser && options.scrollBehavior && "scrollRestoration" in history) {
        history.scrollRestoration = "manual";
      }
      const normalizeParams = applyToParams.bind(null, (paramValue) => "" + paramValue);
      const encodeParams = applyToParams.bind(null, encodeParam);
      const decodeParams = (
        // @ts-expect-error: intentionally avoid the type check
        applyToParams.bind(null, decode)
      );
      function addRoute(parentOrRoute, route) {
        let parent;
        let record;
        if (isRouteName(parentOrRoute)) {
          parent = matcher.getRecordMatcher(parentOrRoute);
          record = route;
        } else {
          record = parentOrRoute;
        }
        return matcher.addRoute(record, parent);
      }
      function removeRoute(name) {
        const recordMatcher = matcher.getRecordMatcher(name);
        if (recordMatcher) {
          matcher.removeRoute(recordMatcher);
        }
      }
      function getRoutes() {
        return matcher.getRoutes().map((routeMatcher) => routeMatcher.record);
      }
      function hasRoute(name) {
        return !!matcher.getRecordMatcher(name);
      }
      function resolve2(rawLocation, currentLocation) {
        currentLocation = assign({}, currentLocation || currentRoute.value);
        if (typeof rawLocation === "string") {
          const locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);
          const matchedRoute2 = matcher.resolve({ path: locationNormalized.path }, currentLocation);
          const href2 = routerHistory.createHref(locationNormalized.fullPath);
          return assign(locationNormalized, matchedRoute2, {
            params: decodeParams(matchedRoute2.params),
            hash: decode(locationNormalized.hash),
            redirectedFrom: void 0,
            href: href2
          });
        }
        let matcherLocation;
        if ("path" in rawLocation) {
          matcherLocation = assign({}, rawLocation, {
            path: parseURL(parseQuery$1, rawLocation.path, currentLocation.path).path
          });
        } else {
          const targetParams = assign({}, rawLocation.params);
          for (const key in targetParams) {
            if (targetParams[key] == null) {
              delete targetParams[key];
            }
          }
          matcherLocation = assign({}, rawLocation, {
            params: encodeParams(targetParams)
          });
          currentLocation.params = encodeParams(currentLocation.params);
        }
        const matchedRoute = matcher.resolve(matcherLocation, currentLocation);
        const hash = rawLocation.hash || "";
        matchedRoute.params = normalizeParams(decodeParams(matchedRoute.params));
        const fullPath = stringifyURL(stringifyQuery$1, assign({}, rawLocation, {
          hash: encodeHash(hash),
          path: matchedRoute.path
        }));
        const href = routerHistory.createHref(fullPath);
        return assign({
          fullPath,
          // keep the hash encoded so fullPath is effectively path + encodedQuery +
          // hash
          hash,
          query: (
            // if the user is using a custom query lib like qs, we might have
            // nested objects, so we keep the query as is, meaning it can contain
            // numbers at `$route.query`, but at the point, the user will have to
            // use their own type anyway.
            // https://github.com/vuejs/router/issues/328#issuecomment-649481567
            stringifyQuery$1 === stringifyQuery ? normalizeQuery(rawLocation.query) : rawLocation.query || {}
          )
        }, matchedRoute, {
          redirectedFrom: void 0,
          href
        });
      }
      function locationAsObject(to) {
        return typeof to === "string" ? parseURL(parseQuery$1, to, currentRoute.value.path) : assign({}, to);
      }
      function checkCanceledNavigation(to, from) {
        if (pendingLocation !== to) {
          return createRouterError(8, {
            from,
            to
          });
        }
      }
      function push(to) {
        return pushWithRedirect(to);
      }
      function replace(to) {
        return push(assign(locationAsObject(to), { replace: true }));
      }
      function handleRedirectRecord(to) {
        const lastMatched = to.matched[to.matched.length - 1];
        if (lastMatched && lastMatched.redirect) {
          const { redirect } = lastMatched;
          let newTargetLocation = typeof redirect === "function" ? redirect(to) : redirect;
          if (typeof newTargetLocation === "string") {
            newTargetLocation = newTargetLocation.includes("?") || newTargetLocation.includes("#") ? newTargetLocation = locationAsObject(newTargetLocation) : (
              // force empty params
              { path: newTargetLocation }
            );
            newTargetLocation.params = {};
          }
          return assign({
            query: to.query,
            hash: to.hash,
            // avoid transferring params if the redirect has a path
            params: "path" in newTargetLocation ? {} : to.params
          }, newTargetLocation);
        }
      }
      function pushWithRedirect(to, redirectedFrom) {
        const targetLocation = pendingLocation = resolve2(to);
        const from = currentRoute.value;
        const data = to.state;
        const force = to.force;
        const replace2 = to.replace === true;
        const shouldRedirect = handleRedirectRecord(targetLocation);
        if (shouldRedirect)
          return pushWithRedirect(
            assign(locationAsObject(shouldRedirect), {
              state: typeof shouldRedirect === "object" ? assign({}, data, shouldRedirect.state) : data,
              force,
              replace: replace2
            }),
            // keep original redirectedFrom if it exists
            redirectedFrom || targetLocation
          );
        const toLocation = targetLocation;
        toLocation.redirectedFrom = redirectedFrom;
        let failure;
        if (!force && isSameRouteLocation(stringifyQuery$1, from, targetLocation)) {
          failure = createRouterError(16, { to: toLocation, from });
          handleScroll2(
            from,
            from,
            // this is a push, the only way for it to be triggered from a
            // history.listen is with a redirect, which makes it become a push
            true,
            // This cannot be the first navigation because the initial location
            // cannot be manually navigated to
            false
          );
        }
        return (failure ? Promise.resolve(failure) : navigate(toLocation, from)).catch((error) => isNavigationFailure(error) ? (
          // navigation redirects still mark the router as ready
          isNavigationFailure(
            error,
            2
            /* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
          ) ? error : markAsReady(error)
        ) : (
          // reject any unknown error
          triggerError(error, toLocation, from)
        )).then((failure2) => {
          if (failure2) {
            if (isNavigationFailure(
              failure2,
              2
              /* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
            )) {
              return pushWithRedirect(
                // keep options
                assign({
                  // preserve an existing replacement but allow the redirect to override it
                  replace: replace2
                }, locationAsObject(failure2.to), {
                  state: typeof failure2.to === "object" ? assign({}, data, failure2.to.state) : data,
                  force
                }),
                // preserve the original redirectedFrom if any
                redirectedFrom || toLocation
              );
            }
          } else {
            failure2 = finalizeNavigation(toLocation, from, true, replace2, data);
          }
          triggerAfterEach(toLocation, from, failure2);
          return failure2;
        });
      }
      function checkCanceledNavigationAndReject(to, from) {
        const error = checkCanceledNavigation(to, from);
        return error ? Promise.reject(error) : Promise.resolve();
      }
      function runWithContext(fn2) {
        const app = installedApps.values().next().value;
        return app && typeof app.runWithContext === "function" ? app.runWithContext(fn2) : fn2();
      }
      function navigate(to, from) {
        let guards;
        const [leavingRecords, updatingRecords, enteringRecords] = extractChangingRecords(to, from);
        guards = extractComponentsGuards(leavingRecords.reverse(), "beforeRouteLeave", to, from);
        for (const record of leavingRecords) {
          record.leaveGuards.forEach((guard) => {
            guards.push(guardToPromiseFn(guard, to, from));
          });
        }
        const canceledNavigationCheck = checkCanceledNavigationAndReject.bind(null, to, from);
        guards.push(canceledNavigationCheck);
        return runGuardQueue(guards).then(() => {
          guards = [];
          for (const guard of beforeGuards.list()) {
            guards.push(guardToPromiseFn(guard, to, from));
          }
          guards.push(canceledNavigationCheck);
          return runGuardQueue(guards);
        }).then(() => {
          guards = extractComponentsGuards(updatingRecords, "beforeRouteUpdate", to, from);
          for (const record of updatingRecords) {
            record.updateGuards.forEach((guard) => {
              guards.push(guardToPromiseFn(guard, to, from));
            });
          }
          guards.push(canceledNavigationCheck);
          return runGuardQueue(guards);
        }).then(() => {
          guards = [];
          for (const record of enteringRecords) {
            if (record.beforeEnter) {
              if (isArray$2(record.beforeEnter)) {
                for (const beforeEnter of record.beforeEnter)
                  guards.push(guardToPromiseFn(beforeEnter, to, from));
              } else {
                guards.push(guardToPromiseFn(record.beforeEnter, to, from));
              }
            }
          }
          guards.push(canceledNavigationCheck);
          return runGuardQueue(guards);
        }).then(() => {
          to.matched.forEach((record) => record.enterCallbacks = {});
          guards = extractComponentsGuards(enteringRecords, "beforeRouteEnter", to, from);
          guards.push(canceledNavigationCheck);
          return runGuardQueue(guards);
        }).then(() => {
          guards = [];
          for (const guard of beforeResolveGuards.list()) {
            guards.push(guardToPromiseFn(guard, to, from));
          }
          guards.push(canceledNavigationCheck);
          return runGuardQueue(guards);
        }).catch((err) => isNavigationFailure(
          err,
          8
          /* ErrorTypes.NAVIGATION_CANCELLED */
        ) ? err : Promise.reject(err));
      }
      function triggerAfterEach(to, from, failure) {
        afterGuards.list().forEach((guard) => runWithContext(() => guard(to, from, failure)));
      }
      function finalizeNavigation(toLocation, from, isPush, replace2, data) {
        const error = checkCanceledNavigation(toLocation, from);
        if (error)
          return error;
        const isFirstNavigation = from === START_LOCATION_NORMALIZED;
        const state = !isBrowser ? {} : history.state;
        if (isPush) {
          if (replace2 || isFirstNavigation)
            routerHistory.replace(toLocation.fullPath, assign({
              scroll: isFirstNavigation && state && state.scroll
            }, data));
          else
            routerHistory.push(toLocation.fullPath, data);
        }
        currentRoute.value = toLocation;
        handleScroll2(toLocation, from, isPush, isFirstNavigation);
        markAsReady();
      }
      let removeHistoryListener;
      function setupListeners() {
        if (removeHistoryListener)
          return;
        removeHistoryListener = routerHistory.listen((to, _from, info) => {
          if (!router2.listening)
            return;
          const toLocation = resolve2(to);
          const shouldRedirect = handleRedirectRecord(toLocation);
          if (shouldRedirect) {
            pushWithRedirect(assign(shouldRedirect, { replace: true }), toLocation).catch(noop$2);
            return;
          }
          pendingLocation = toLocation;
          const from = currentRoute.value;
          if (isBrowser) {
            saveScrollPosition(getScrollKey(from.fullPath, info.delta), computeScrollPosition());
          }
          navigate(toLocation, from).catch((error) => {
            if (isNavigationFailure(
              error,
              4 | 8
              /* ErrorTypes.NAVIGATION_CANCELLED */
            )) {
              return error;
            }
            if (isNavigationFailure(
              error,
              2
              /* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
            )) {
              pushWithRedirect(
                error.to,
                toLocation
                // avoid an uncaught rejection, let push call triggerError
              ).then((failure) => {
                if (isNavigationFailure(
                  failure,
                  4 | 16
                  /* ErrorTypes.NAVIGATION_DUPLICATED */
                ) && !info.delta && info.type === NavigationType.pop) {
                  routerHistory.go(-1, false);
                }
              }).catch(noop$2);
              return Promise.reject();
            }
            if (info.delta) {
              routerHistory.go(-info.delta, false);
            }
            return triggerError(error, toLocation, from);
          }).then((failure) => {
            failure = failure || finalizeNavigation(
              // after navigation, all matched components are resolved
              toLocation,
              from,
              false
            );
            if (failure) {
              if (info.delta && // a new navigation has been triggered, so we do not want to revert, that will change the current history
              // entry while a different route is displayed
              !isNavigationFailure(
                failure,
                8
                /* ErrorTypes.NAVIGATION_CANCELLED */
              )) {
                routerHistory.go(-info.delta, false);
              } else if (info.type === NavigationType.pop && isNavigationFailure(
                failure,
                4 | 16
                /* ErrorTypes.NAVIGATION_DUPLICATED */
              )) {
                routerHistory.go(-1, false);
              }
            }
            triggerAfterEach(toLocation, from, failure);
          }).catch(noop$2);
        });
      }
      let readyHandlers = useCallbacks();
      let errorListeners = useCallbacks();
      let ready;
      function triggerError(error, to, from) {
        markAsReady(error);
        const list = errorListeners.list();
        if (list.length) {
          list.forEach((handler) => handler(error, to, from));
        } else {
          console.error(error);
        }
        return Promise.reject(error);
      }
      function isReady() {
        if (ready && currentRoute.value !== START_LOCATION_NORMALIZED)
          return Promise.resolve();
        return new Promise((resolve3, reject) => {
          readyHandlers.add([resolve3, reject]);
        });
      }
      function markAsReady(err) {
        if (!ready) {
          ready = !err;
          setupListeners();
          readyHandlers.list().forEach(([resolve3, reject]) => err ? reject(err) : resolve3());
          readyHandlers.reset();
        }
        return err;
      }
      function handleScroll2(to, from, isPush, isFirstNavigation) {
        const { scrollBehavior } = options;
        if (!isBrowser || !scrollBehavior)
          return Promise.resolve();
        const scrollPosition = !isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0)) || (isFirstNavigation || !isPush) && history.state && history.state.scroll || null;
        return nextTick().then(() => scrollBehavior(to, from, scrollPosition)).then((position) => position && scrollToPosition(position)).catch((err) => triggerError(err, to, from));
      }
      const go = (delta) => routerHistory.go(delta);
      let started;
      const installedApps = /* @__PURE__ */ new Set();
      const router2 = {
        currentRoute,
        listening: true,
        addRoute,
        removeRoute,
        hasRoute,
        getRoutes,
        resolve: resolve2,
        options,
        push,
        replace,
        go,
        back: () => go(-1),
        forward: () => go(1),
        beforeEach: beforeGuards.add,
        beforeResolve: beforeResolveGuards.add,
        afterEach: afterGuards.add,
        onError: errorListeners.add,
        isReady,
        install(app) {
          const router3 = this;
          app.component("RouterLink", RouterLink);
          app.component("RouterView", RouterView);
          app.config.globalProperties.$router = router3;
          Object.defineProperty(app.config.globalProperties, "$route", {
            enumerable: true,
            get: () => unref(currentRoute)
          });
          if (isBrowser && // used for the initial navigation client side to avoid pushing
          // multiple times when the router is used in multiple apps
          !started && currentRoute.value === START_LOCATION_NORMALIZED) {
            started = true;
            push(routerHistory.location).catch((err) => {
            });
          }
          const reactiveRoute = {};
          for (const key in START_LOCATION_NORMALIZED) {
            Object.defineProperty(reactiveRoute, key, {
              get: () => currentRoute.value[key],
              enumerable: true
            });
          }
          app.provide(routerKey, router3);
          app.provide(routeLocationKey, shallowReactive(reactiveRoute));
          app.provide(routerViewLocationKey, currentRoute);
          const unmountApp = app.unmount;
          installedApps.add(app);
          app.unmount = function() {
            installedApps.delete(app);
            if (installedApps.size < 1) {
              pendingLocation = START_LOCATION_NORMALIZED;
              removeHistoryListener && removeHistoryListener();
              removeHistoryListener = null;
              currentRoute.value = START_LOCATION_NORMALIZED;
              started = false;
              ready = false;
            }
            unmountApp();
          };
        }
      };
      function runGuardQueue(guards) {
        return guards.reduce((promise, guard) => promise.then(() => runWithContext(guard)), Promise.resolve());
      }
      return router2;
    }
    function extractChangingRecords(to, from) {
      const leavingRecords = [];
      const updatingRecords = [];
      const enteringRecords = [];
      const len = Math.max(from.matched.length, to.matched.length);
      for (let i = 0; i < len; i++) {
        const recordFrom = from.matched[i];
        if (recordFrom) {
          if (to.matched.find((record) => isSameRouteRecord(record, recordFrom)))
            updatingRecords.push(recordFrom);
          else
            leavingRecords.push(recordFrom);
        }
        const recordTo = to.matched[i];
        if (recordTo) {
          if (!from.matched.find((record) => isSameRouteRecord(record, recordTo))) {
            enteringRecords.push(recordTo);
          }
        }
      }
      return [leavingRecords, updatingRecords, enteringRecords];
    }
    function useRouter() {
      return inject(routerKey);
    }
    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 isVisible = (element) => {
      const computed2 = getComputedStyle(element);
      return computed2.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.disabled) {
        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 index2 = Array.prototype.indexOf.call(siblings, el);
      return siblings[index2 + distance] || null;
    };
    const focusNode = (el) => {
      if (!el)
        return;
      el.focus();
      !isLeaf(el) && el.click();
    };
    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;
    };
    var __defProp$9 = Object.defineProperty;
    var __defProps$6 = Object.defineProperties;
    var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
    var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
    var __hasOwnProp$b = Object.prototype.hasOwnProperty;
    var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
    var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
    var __spreadValues$9 = (a2, b2) => {
      for (var prop in b2 || (b2 = {}))
        if (__hasOwnProp$b.call(b2, prop))
          __defNormalProp$9(a2, prop, b2[prop]);
      if (__getOwnPropSymbols$b)
        for (var prop of __getOwnPropSymbols$b(b2)) {
          if (__propIsEnum$b.call(b2, prop))
            __defNormalProp$9(a2, prop, b2[prop]);
        }
      return a2;
    };
    var __spreadProps$6 = (a2, b2) => __defProps$6(a2, __getOwnPropDescs$6(b2));
    function computedEager(fn2, options) {
      var _a2;
      const result = shallowRef();
      watchEffect(() => {
        result.value = fn2();
      }, __spreadProps$6(__spreadValues$9({}, options), {
        flush: (_a2 = options == null ? void 0 : options.flush) != null ? _a2 : "sync"
      }));
      return readonly(result);
    }
    var _a;
    const isClient = typeof window !== "undefined";
    const isDef = (val) => typeof val !== "undefined";
    const isFunction$1 = (val) => typeof val === "function";
    const isString = (val) => typeof val === "string";
    const noop$1 = () => {
    };
    const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
    function resolveUnref(r) {
      return typeof r === "function" ? r() : unref(r);
    }
    function createFilterWrapper(filter, fn2) {
      function wrapper(...args) {
        return new Promise((resolve2, reject) => {
          Promise.resolve(filter(() => fn2.apply(this, args), { fn: fn2, thisArg: this, args })).then(resolve2).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 = resolveUnref(ms);
        const maxDuration = resolveUnref(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((resolve2, reject) => {
          lastRejector = options.rejectOnCancel ? reject : resolve2;
          if (maxDuration && !maxTimer) {
            maxTimer = setTimeout(() => {
              if (timer)
                _clearTimeout(timer);
              maxTimer = null;
              resolve2(invoke());
            }, maxDuration);
          }
          timer = setTimeout(() => {
            if (maxTimer)
              _clearTimeout(maxTimer);
            maxTimer = null;
            resolve2(invoke());
          }, duration);
        });
      };
      return filter;
    }
    function throttleFilter(ms, trailing = true, leading = true, rejectOnCancel = false) {
      let lastExec = 0;
      let timer;
      let isLeading = true;
      let lastRejector = noop$1;
      let lastValue;
      const clear2 = () => {
        if (timer) {
          clearTimeout(timer);
          timer = void 0;
          lastRejector();
          lastRejector = noop$1;
        }
      };
      const filter = (_invoke) => {
        const duration = resolveUnref(ms);
        const elapsed = Date.now() - lastExec;
        const invoke = () => {
          return lastValue = _invoke();
        };
        clear2();
        if (duration <= 0) {
          lastExec = Date.now();
          return invoke();
        }
        if (elapsed > duration && (leading || !isLeading)) {
          lastExec = Date.now();
          invoke();
        } else if (trailing) {
          lastValue = new Promise((resolve2, reject) => {
            lastRejector = rejectOnCancel ? reject : resolve2;
            timer = setTimeout(() => {
              lastExec = Date.now();
              isLeading = true;
              resolve2(invoke());
              clear2();
            }, Math.max(0, duration - elapsed));
          });
        }
        if (!leading && !timer)
          timer = setTimeout(() => isLeading = true, duration);
        isLeading = false;
        return lastValue;
      };
      return filter;
    }
    function identity$1(arg) {
      return arg;
    }
    function tryOnScopeDispose(fn2) {
      if (getCurrentScope()) {
        onScopeDispose(fn2);
        return true;
      }
      return false;
    }
    function useDebounceFn(fn2, ms = 200, options = {}) {
      return createFilterWrapper(debounceFilter(ms, options), fn2);
    }
    function refDebounced(value, ms = 200, options = {}) {
      const debounced = ref(value.value);
      const updater = useDebounceFn(() => {
        debounced.value = value.value;
      }, ms, options);
      watch(value, () => updater());
      return debounced;
    }
    function useThrottleFn(fn2, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
      return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn2);
    }
    function tryOnMounted(fn2, sync = true) {
      if (getCurrentInstance())
        onMounted(fn2);
      else if (sync)
        fn2();
      else
        nextTick(fn2);
    }
    function useTimeoutFn(cb, interval, options = {}) {
      const {
        immediate = true
      } = options;
      const isPending = ref(false);
      let timer = null;
      function clear2() {
        if (timer) {
          clearTimeout(timer);
          timer = null;
        }
      }
      function stop() {
        isPending.value = false;
        clear2();
      }
      function start(...args) {
        clear2();
        isPending.value = true;
        timer = setTimeout(() => {
          isPending.value = false;
          timer = null;
          cb(...args);
        }, resolveUnref(interval));
      }
      if (immediate) {
        isPending.value = true;
        if (isClient)
          start();
      }
      tryOnScopeDispose(stop);
      return {
        isPending: readonly(isPending),
        start,
        stop
      };
    }
    function unrefElement(elRef) {
      var _a2;
      const plain = resolveUnref(elRef);
      return (_a2 = plain == null ? void 0 : plain.$el) != null ? _a2 : 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 (isString(args[0]) || 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((fn2) => fn2());
        cleanups.length = 0;
      };
      const register = (el, event, listener, options2) => {
        el.addEventListener(event, listener, options2);
        return () => el.removeEventListener(event, listener, options2);
      };
      const stopWatch = watch(() => [unrefElement(target), resolveUnref(options)], ([el, options2]) => {
        cleanup();
        if (!el)
          return;
        cleanups.push(...events.flatMap((event) => {
          return listeners.map((listener) => register(el, event, listener, options2));
        }));
      }, { immediate: true, flush: "post" });
      const stop = () => {
        stopWatch();
        cleanup();
      };
      tryOnScopeDispose(stop);
      return stop;
    }
    let _iOSWorkaround = false;
    function onClickOutside(target, handler, options = {}) {
      const { window: window2 = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
      if (!window2)
        return;
      if (isIOS && !_iOSWorkaround) {
        _iOSWorkaround = true;
        Array.from(window2.document.body.children).forEach((el) => el.addEventListener("click", noop$1));
      }
      let shouldListen = true;
      const shouldIgnore = (event) => {
        return ignore.some((target2) => {
          if (typeof target2 === "string") {
            return Array.from(window2.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(window2, "click", listener, { passive: true, capture }),
        useEventListener(window2, "pointerdown", (e) => {
          const el = unrefElement(target);
          if (el)
            shouldListen = !e.composedPath().includes(el) && !shouldIgnore(e);
        }, { passive: true }),
        detectIframe && useEventListener(window2, "blur", (event) => {
          var _a2;
          const el = unrefElement(target);
          if (((_a2 = window2.document.activeElement) == null ? void 0 : _a2.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window2.document.activeElement)))
            handler(event);
        })
      ].filter(Boolean);
      const stop = () => cleanup.forEach((fn2) => fn2());
      return stop;
    }
    function useSupported(callback, sync = false) {
      const isSupported = ref();
      const update = () => isSupported.value = Boolean(callback());
      update();
      tryOnMounted(update, sync);
      return isSupported;
    }
    function cloneFnJSON(source) {
      return JSON.parse(JSON.stringify(source));
    }
    const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
    const globalKey = "__vueuse_ssr_handlers__";
    _global[globalKey] = _global[globalKey] || {};
    function useCssVar(prop, target, { window: window2 = defaultWindow, initialValue = "" } = {}) {
      const variable = ref(initialValue);
      const elRef = computed(() => {
        var _a2;
        return unrefElement(target) || ((_a2 = window2 == null ? void 0 : window2.document) == null ? void 0 : _a2.documentElement);
      });
      watch([elRef, () => resolveUnref(prop)], ([el, prop2]) => {
        var _a2;
        if (el && window2) {
          const value = (_a2 = window2.getComputedStyle(el).getPropertyValue(prop2)) == null ? void 0 : _a2.trim();
          variable.value = value || initialValue;
        }
      }, { immediate: true });
      watch(variable, (val) => {
        var _a2;
        if ((_a2 = elRef.value) == null ? void 0 : _a2.style)
          elRef.value.style.setProperty(resolveUnref(prop), val);
      });
      return variable;
    }
    function useDocumentVisibility({ document: document2 = defaultDocument } = {}) {
      if (!document2)
        return ref("visible");
      const visibility = ref(document2.visibilityState);
      useEventListener(document2, "visibilitychange", () => {
        visibility.value = document2.visibilityState;
      });
      return visibility;
    }
    var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
    var __hasOwnProp$g = Object.prototype.hasOwnProperty;
    var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
    var __objRest$2 = (source, exclude) => {
      var target = {};
      for (var prop in source)
        if (__hasOwnProp$g.call(source, prop) && exclude.indexOf(prop) < 0)
          target[prop] = source[prop];
      if (source != null && __getOwnPropSymbols$g)
        for (var prop of __getOwnPropSymbols$g(source)) {
          if (exclude.indexOf(prop) < 0 && __propIsEnum$g.call(source, prop))
            target[prop] = source[prop];
        }
      return target;
    };
    function useResizeObserver(target, callback, options = {}) {
      const _a2 = options, { window: window2 = defaultWindow } = _a2, observerOptions = __objRest$2(_a2, ["window"]);
      let observer;
      const isSupported = useSupported(() => window2 && "ResizeObserver" in window2);
      const cleanup = () => {
        if (observer) {
          observer.disconnect();
          observer = void 0;
        }
      };
      const stopWatch = watch(() => unrefElement(target), (el) => {
        cleanup();
        if (isSupported.value && window2 && el) {
          observer = new ResizeObserver(callback);
          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 = ref(0);
      const bottom = ref(0);
      const left2 = ref(0);
      const right2 = ref(0);
      const top = ref(0);
      const width = ref(0);
      const x2 = ref(0);
      const y = ref(0);
      function update() {
        const el = unrefElement(target);
        if (!el) {
          if (reset) {
            height.value = 0;
            bottom.value = 0;
            left2.value = 0;
            right2.value = 0;
            top.value = 0;
            width.value = 0;
            x2.value = 0;
            y.value = 0;
          }
          return;
        }
        const rect = el.getBoundingClientRect();
        height.value = rect.height;
        bottom.value = rect.bottom;
        left2.value = rect.left;
        right2.value = rect.right;
        top.value = rect.top;
        width.value = rect.width;
        x2.value = rect.x;
        y.value = rect.y;
      }
      useResizeObserver(target, update);
      watch(() => unrefElement(target), (ele) => !ele && update());
      if (windowScroll)
        useEventListener("scroll", update, { capture: true, passive: true });
      if (windowResize)
        useEventListener("resize", update, { passive: true });
      tryOnMounted(() => {
        if (immediate)
          update();
      });
      return {
        height,
        bottom,
        left: left2,
        right: right2,
        top,
        width,
        x: x2,
        y,
        update
      };
    }
    var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
    var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
    var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
    var __objRest$1 = (source, exclude) => {
      var target = {};
      for (var prop in source)
        if (__hasOwnProp$8.call(source, prop) && exclude.indexOf(prop) < 0)
          target[prop] = source[prop];
      if (source != null && __getOwnPropSymbols$8)
        for (var prop of __getOwnPropSymbols$8(source)) {
          if (exclude.indexOf(prop) < 0 && __propIsEnum$8.call(source, prop))
            target[prop] = source[prop];
        }
      return target;
    };
    function useMutationObserver(target, callback, options = {}) {
      const _a2 = options, { window: window2 = defaultWindow } = _a2, mutationOptions = __objRest$1(_a2, ["window"]);
      let observer;
      const isSupported = useSupported(() => window2 && "MutationObserver" in window2);
      const cleanup = () => {
        if (observer) {
          observer.disconnect();
          observer = void 0;
        }
      };
      const stopWatch = watch(() => unrefElement(target), (el) => {
        cleanup();
        if (isSupported.value && window2 && el) {
          observer = new MutationObserver(callback);
          observer.observe(el, mutationOptions);
        }
      }, { immediate: true });
      const stop = () => {
        cleanup();
        stopWatch();
      };
      tryOnScopeDispose(stop);
      return {
        isSupported,
        stop
      };
    }
    var SwipeDirection;
    (function(SwipeDirection2) {
      SwipeDirection2["UP"] = "UP";
      SwipeDirection2["RIGHT"] = "RIGHT";
      SwipeDirection2["DOWN"] = "DOWN";
      SwipeDirection2["LEFT"] = "LEFT";
      SwipeDirection2["NONE"] = "NONE";
    })(SwipeDirection || (SwipeDirection = {}));
    var __defProp = Object.defineProperty;
    var __getOwnPropSymbols = Object.getOwnPropertySymbols;
    var __hasOwnProp = Object.prototype.hasOwnProperty;
    var __propIsEnum = Object.prototype.propertyIsEnumerable;
    var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
    var __spreadValues = (a2, b2) => {
      for (var prop in b2 || (b2 = {}))
        if (__hasOwnProp.call(b2, prop))
          __defNormalProp(a2, prop, b2[prop]);
      if (__getOwnPropSymbols)
        for (var prop of __getOwnPropSymbols(b2)) {
          if (__propIsEnum.call(b2, prop))
            __defNormalProp(a2, prop, b2[prop]);
        }
      return a2;
    };
    const _TransitionPresets = {
      easeInSine: [0.12, 0, 0.39, 0],
      easeOutSine: [0.61, 1, 0.88, 1],
      easeInOutSine: [0.37, 0, 0.63, 1],
      easeInQuad: [0.11, 0, 0.5, 0],
      easeOutQuad: [0.5, 1, 0.89, 1],
      easeInOutQuad: [0.45, 0, 0.55, 1],
      easeInCubic: [0.32, 0, 0.67, 0],
      easeOutCubic: [0.33, 1, 0.68, 1],
      easeInOutCubic: [0.65, 0, 0.35, 1],
      easeInQuart: [0.5, 0, 0.75, 0],
      easeOutQuart: [0.25, 1, 0.5, 1],
      easeInOutQuart: [0.76, 0, 0.24, 1],
      easeInQuint: [0.64, 0, 0.78, 0],
      easeOutQuint: [0.22, 1, 0.36, 1],
      easeInOutQuint: [0.83, 0, 0.17, 1],
      easeInExpo: [0.7, 0, 0.84, 0],
      easeOutExpo: [0.16, 1, 0.3, 1],
      easeInOutExpo: [0.87, 0, 0.13, 1],
      easeInCirc: [0.55, 0, 1, 0.45],
      easeOutCirc: [0, 0.55, 0.45, 1],
      easeInOutCirc: [0.85, 0, 0.15, 1],
      easeInBack: [0.36, 0, 0.66, -0.56],
      easeOutBack: [0.34, 1.56, 0.64, 1],
      easeInOutBack: [0.68, -0.6, 0.32, 1.6]
    };
    __spreadValues({
      linear: identity$1
    }, _TransitionPresets);
    function useVModel(props, key, emit2, options = {}) {
      var _a2, _b, _c;
      const {
        clone: clone2 = false,
        passive = false,
        eventName,
        deep = false,
        defaultValue
      } = options;
      const vm = getCurrentInstance();
      const _emit = emit2 || (vm == null ? void 0 : vm.emit) || ((_a2 = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a2.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 = eventName || event || `update:${key.toString()}`;
      const cloneFn = (val) => !clone2 ? val : isFunction$1(clone2) ? clone2(val) : cloneFnJSON(val);
      const getValue2 = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
      if (passive) {
        const initialValue = getValue2();
        const proxy = ref(initialValue);
        watch(() => props[key], (v2) => proxy.value = cloneFn(v2));
        watch(proxy, (v2) => {
          if (v2 !== props[key] || deep)
            _emit(event, v2);
        }, { deep });
        return proxy;
      } else {
        return computed({
          get() {
            return getValue2();
          },
          set(value) {
            _emit(event, value);
          }
        });
      }
    }
    function useWindowFocus({ window: window2 = defaultWindow } = {}) {
      if (!window2)
        return ref(false);
      const focused = ref(window2.document.hasFocus());
      useEventListener(window2, "blur", () => {
        focused.value = false;
      });
      useEventListener(window2, "focus", () => {
        focused.value = true;
      });
      return focused;
    }
    function useWindowSize(options = {}) {
      const {
        window: window2 = defaultWindow,
        initialWidth = Infinity,
        initialHeight = Infinity,
        listenOrientation = true,
        includeScrollbar = true
      } = options;
      const width = ref(initialWidth);
      const height = ref(initialHeight);
      const update = () => {
        if (window2) {
          if (includeScrollbar) {
            width.value = window2.innerWidth;
            height.value = window2.innerHeight;
          } else {
            width.value = window2.document.documentElement.clientWidth;
            height.value = window2.document.documentElement.clientHeight;
          }
        }
      };
      update();
      tryOnMounted(update);
      useEventListener("resize", update, { passive: true });
      if (listenOrientation)
        useEventListener("orientationchange", update, { passive: true });
      return { width, height };
    }
    const isFirefox = () => isClient && /firefox/i.test(window.navigator.userAgent);
    const isInContainer = (el, container) => {
      if (!isClient || !el || !container)
        return false;
      const elRect = el.getBoundingClientRect();
      let containerRect;
      if (container instanceof Element) {
        containerRect = container.getBoundingClientRect();
      } else {
        containerRect = {
          top: 0,
          right: window.innerWidth,
          bottom: window.innerHeight,
          left: 0
        };
      }
      return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
    };
    const getOffsetTop = (el) => {
      let offset2 = 0;
      let parent = el;
      while (parent) {
        offset2 += parent.offsetTop;
        parent = parent.offsetParent;
      }
      return offset2;
    };
    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
      };
    };
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    const freeGlobal$1 = freeGlobal;
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal$1 || freeSelf || Function("return this")();
    const root$1 = root;
    var Symbol$1 = root$1.Symbol;
    const Symbol$2 = Symbol$1;
    var objectProto$f = Object.prototype;
    var hasOwnProperty$c = objectProto$f.hasOwnProperty;
    var nativeObjectToString$1 = objectProto$f.toString;
    var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : void 0;
    function getRawTag(value) {
      var isOwn = hasOwnProperty$c.call(value, symToStringTag$1), tag = value[symToStringTag$1];
      try {
        value[symToStringTag$1] = void 0;
        var unmasked = true;
      } catch (e) {
      }
      var result = nativeObjectToString$1.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag$1] = tag;
        } else {
          delete value[symToStringTag$1];
        }
      }
      return result;
    }
    var objectProto$e = Object.prototype;
    var nativeObjectToString = objectProto$e.toString;
    function objectToString(value) {
      return nativeObjectToString.call(value);
    }
    var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
    var symToStringTag = Symbol$2 ? Symbol$2.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;
    }
    function arrayMap(array2, iteratee) {
      var index2 = -1, length = array2 == null ? 0 : array2.length, result = Array(length);
      while (++index2 < length) {
        result[index2] = iteratee(array2[index2], index2, array2);
      }
      return result;
    }
    var isArray = Array.isArray;
    const isArray$1 = isArray;
    var INFINITY$4 = 1 / 0;
    var symbolProto$2 = Symbol$2 ? Symbol$2.prototype : void 0, symbolToString = symbolProto$2 ? symbolProto$2.toString : void 0;
    function baseToString(value) {
      if (typeof value == "string") {
        return value;
      }
      if (isArray$1(value)) {
        return arrayMap(value, baseToString) + "";
      }
      if (isSymbol(value)) {
        return symbolToString ? symbolToString.call(value) : "";
      }
      var result = value + "";
      return result == "0" && 1 / value == -INFINITY$4 ? "-0" : result;
    }
    var reWhitespace = /\s/;
    function trimmedEndIndex(string2) {
      var index2 = string2.length;
      while (index2-- && reWhitespace.test(string2.charAt(index2))) {
      }
      return index2;
    }
    var reTrimStart = /^\s+/;
    function baseTrim(string2) {
      return string2 ? string2.slice(0, trimmedEndIndex(string2) + 1).replace(reTrimStart, "") : string2;
    }
    function isObject(value) {
      var type2 = typeof value;
      return value != null && (type2 == "object" || type2 == "function");
    }
    var NAN = 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;
      }
      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 : +value;
    }
    var INFINITY$3 = 1 / 0, MAX_INTEGER = 17976931348623157e292;
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber(value);
      if (value === INFINITY$3 || value === -INFINITY$3) {
        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;
    }
    function identity(value) {
      return value;
    }
    var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", 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$1["__core-js_shared__"];
    const coreJsData$1 = coreJsData;
    var maskSrcKey = function() {
      var uid2 = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || "");
      return uid2 ? "Symbol(src)_1." + uid2 : "";
    }();
    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 = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var funcProto$1 = Function.prototype, objectProto$d = Object.prototype;
    var funcToString$1 = funcProto$1.toString;
    var hasOwnProperty$b = objectProto$d.hasOwnProperty;
    var reIsNative = RegExp(
      "^" + funcToString$1.call(hasOwnProperty$b).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
    );
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern2 = isFunction(value) ? reIsNative : reIsHostCtor;
      return pattern2.test(toSource(value));
    }
    function getValue$1(object2, key) {
      return object2 == null ? void 0 : object2[key];
    }
    function getNative(object2, key) {
      var value = getValue$1(object2, key);
      return baseIsNative(value) ? value : void 0;
    }
    var WeakMap$1 = getNative(root$1, "WeakMap");
    const WeakMap$2 = WeakMap$1;
    var objectCreate = Object.create;
    var baseCreate = function() {
      function object2() {
      }
      return function(proto) {
        if (!isObject(proto)) {
          return {};
        }
        if (objectCreate) {
          return objectCreate(proto);
        }
        object2.prototype = proto;
        var result = new object2();
        object2.prototype = void 0;
        return result;
      };
    }();
    const baseCreate$1 = baseCreate;
    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);
    }
    function noop() {
    }
    function copyArray(source, array2) {
      var index2 = -1, length = source.length;
      array2 || (array2 = Array(length));
      while (++index2 < length) {
        array2[index2] = source[index2];
      }
      return array2;
    }
    var HOT_COUNT = 800, 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);
      };
    }
    function constant(value) {
      return function() {
        return value;
      };
    }
    var defineProperty = function() {
      try {
        var func = getNative(Object, "defineProperty");
        func({}, "", {});
        return func;
      } catch (e) {
      }
    }();
    const defineProperty$1 = defineProperty;
    var baseSetToString = !defineProperty$1 ? identity : function(func, string2) {
      return defineProperty$1(func, "toString", {
        "configurable": true,
        "enumerable": false,
        "value": constant(string2),
        "writable": true
      });
    };
    const baseSetToString$1 = baseSetToString;
    var setToString = shortOut(baseSetToString$1);
    const setToString$1 = setToString;
    function arrayEach(array2, iteratee) {
      var index2 = -1, length = array2 == null ? 0 : array2.length;
      while (++index2 < length) {
        if (iteratee(array2[index2], index2, array2) === false) {
          break;
        }
      }
      return array2;
    }
    function baseFindIndex(array2, predicate, fromIndex, fromRight) {
      var length = array2.length, index2 = fromIndex + (fromRight ? 1 : -1);
      while (fromRight ? index2-- : ++index2 < length) {
        if (predicate(array2[index2], index2, array2)) {
          return index2;
        }
      }
      return -1;
    }
    function baseIsNaN(value) {
      return value !== value;
    }
    function strictIndexOf(array2, value, fromIndex) {
      var index2 = fromIndex - 1, length = array2.length;
      while (++index2 < length) {
        if (array2[index2] === value) {
          return index2;
        }
      }
      return -1;
    }
    function baseIndexOf(array2, value, fromIndex) {
      return value === value ? strictIndexOf(array2, value, fromIndex) : baseFindIndex(array2, baseIsNaN, fromIndex);
    }
    function arrayIncludes(array2, value) {
      var length = array2 == null ? 0 : array2.length;
      return !!length && baseIndexOf(array2, value, 0) > -1;
    }
    var MAX_SAFE_INTEGER$1 = 9007199254740991;
    var reIsUint = /^(?:0|[1-9]\d*)$/;
    function isIndex(value, length) {
      var type2 = typeof value;
      length = length == null ? MAX_SAFE_INTEGER$1 : length;
      return !!length && (type2 == "number" || type2 != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
    }
    function baseAssignValue(object2, key, value) {
      if (key == "__proto__" && defineProperty$1) {
        defineProperty$1(object2, key, {
          "configurable": true,
          "enumerable": true,
          "value": value,
          "writable": true
        });
      } else {
        object2[key] = value;
      }
    }
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
    var objectProto$c = Object.prototype;
    var hasOwnProperty$a = objectProto$c.hasOwnProperty;
    function assignValue(object2, key, value) {
      var objValue = object2[key];
      if (!(hasOwnProperty$a.call(object2, key) && eq(objValue, value)) || value === void 0 && !(key in object2)) {
        baseAssignValue(object2, key, value);
      }
    }
    function copyObject(source, props, object2, customizer) {
      var isNew = !object2;
      object2 || (object2 = {});
      var index2 = -1, length = props.length;
      while (++index2 < length) {
        var key = props[index2];
        var newValue = customizer ? customizer(object2[key], source[key], key, object2, source) : void 0;
        if (newValue === void 0) {
          newValue = source[key];
        }
        if (isNew) {
          baseAssignValue(object2, key, newValue);
        } else {
          assignValue(object2, key, newValue);
        }
      }
      return object2;
    }
    var nativeMax$2 = Math.max;
    function overRest(func, start, transform) {
      start = nativeMax$2(start === void 0 ? func.length - 1 : start, 0);
      return function() {
        var args = arguments, index2 = -1, length = nativeMax$2(args.length - start, 0), array2 = Array(length);
        while (++index2 < length) {
          array2[index2] = args[start + index2];
        }
        index2 = -1;
        var otherArgs = Array(start + 1);
        while (++index2 < start) {
          otherArgs[index2] = args[index2];
        }
        otherArgs[start] = transform(array2);
        return apply(func, this, otherArgs);
      };
    }
    function baseRest(func, start) {
      return setToString$1(overRest(func, start, identity), func + "");
    }
    var MAX_SAFE_INTEGER = 9007199254740991;
    function isLength(value) {
      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    }
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction(value);
    }
    function isIterateeCall(value, index2, object2) {
      if (!isObject(object2)) {
        return false;
      }
      var type2 = typeof index2;
      if (type2 == "number" ? isArrayLike(object2) && isIndex(index2, object2.length) : type2 == "string" && index2 in object2) {
        return eq(object2[index2], value);
      }
      return false;
    }
    function createAssigner(assigner) {
      return baseRest(function(object2, sources) {
        var index2 = -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;
        }
        object2 = Object(object2);
        while (++index2 < length) {
          var source = sources[index2];
          if (source) {
            assigner(object2, source, index2, customizer);
          }
        }
        return object2;
      });
    }
    var objectProto$b = Object.prototype;
    function isPrototype(value) {
      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$b;
      return value === proto;
    }
    function baseTimes(n, iteratee) {
      var index2 = -1, result = Array(n);
      while (++index2 < n) {
        result[index2] = iteratee(index2);
      }
      return result;
    }
    var argsTag$3 = "[object Arguments]";
    function baseIsArguments(value) {
      return isObjectLike(value) && baseGetTag(value) == argsTag$3;
    }
    var objectProto$a = Object.prototype;
    var hasOwnProperty$9 = objectProto$a.hasOwnProperty;
    var propertyIsEnumerable$1 = objectProto$a.propertyIsEnumerable;
    var isArguments = baseIsArguments(function() {
      return arguments;
    }()) ? baseIsArguments : function(value) {
      return isObjectLike(value) && hasOwnProperty$9.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
    };
    const isArguments$1 = isArguments;
    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$1.Buffer : void 0;
    var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
    var isBuffer = nativeIsBuffer || stubFalse;
    const isBuffer$1 = isBuffer;
    var argsTag$2 = "[object Arguments]", arrayTag$2 = "[object Array]", boolTag$3 = "[object Boolean]", dateTag$3 = "[object Date]", errorTag$2 = "[object Error]", funcTag$1 = "[object Function]", mapTag$5 = "[object Map]", numberTag$3 = "[object Number]", objectTag$4 = "[object Object]", regexpTag$3 = "[object RegExp]", setTag$5 = "[object Set]", stringTag$3 = "[object String]", weakMapTag$2 = "[object WeakMap]";
    var arrayBufferTag$3 = "[object ArrayBuffer]", dataViewTag$4 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", 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$3] = typedArrayTags[boolTag$3] = typedArrayTags[dataViewTag$4] = typedArrayTags[dateTag$3] = typedArrayTags[errorTag$2] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$5] = typedArrayTags[numberTag$3] = typedArrayTags[objectTag$4] = typedArrayTags[regexpTag$3] = typedArrayTags[setTag$5] = typedArrayTags[stringTag$3] = typedArrayTags[weakMapTag$2] = 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$1.process;
    var nodeUtil = function() {
      try {
        var types2 = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
        if (types2) {
          return types2;
        }
        return freeProcess && freeProcess.binding && freeProcess.binding("util");
      } catch (e) {
      }
    }();
    const nodeUtil$1 = nodeUtil;
    var nodeIsTypedArray = nodeUtil$1 && nodeUtil$1.isTypedArray;
    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
    const isTypedArray$1 = isTypedArray;
    var objectProto$9 = Object.prototype;
    var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
    function arrayLikeKeys(value, inherited) {
      var isArr = isArray$1(value), isArg = !isArr && isArguments$1(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
      for (var key in value) {
        if ((inherited || hasOwnProperty$8.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
        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);
    const nativeKeys$1 = nativeKeys;
    var objectProto$8 = Object.prototype;
    var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
    function baseKeys(object2) {
      if (!isPrototype(object2)) {
        return nativeKeys$1(object2);
      }
      var result = [];
      for (var key in Object(object2)) {
        if (hasOwnProperty$7.call(object2, key) && key != "constructor") {
          result.push(key);
        }
      }
      return result;
    }
    function keys(object2) {
      return isArrayLike(object2) ? arrayLikeKeys(object2) : baseKeys(object2);
    }
    function nativeKeysIn(object2) {
      var result = [];
      if (object2 != null) {
        for (var key in Object(object2)) {
          result.push(key);
        }
      }
      return result;
    }
    var objectProto$7 = Object.prototype;
    var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
    function baseKeysIn(object2) {
      if (!isObject(object2)) {
        return nativeKeysIn(object2);
      }
      var isProto = isPrototype(object2), result = [];
      for (var key in object2) {
        if (!(key == "constructor" && (isProto || !hasOwnProperty$6.call(object2, key)))) {
          result.push(key);
        }
      }
      return result;
    }
    function keysIn(object2) {
      return isArrayLike(object2) ? arrayLikeKeys(object2, true) : baseKeysIn(object2);
    }
    var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
    function isKey(value, object2) {
      if (isArray$1(value)) {
        return false;
      }
      var type2 = typeof value;
      if (type2 == "number" || type2 == "symbol" || type2 == "boolean" || value == null || isSymbol(value)) {
        return true;
      }
      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object2 != null && value in Object(object2);
    }
    var nativeCreate = getNative(Object, "create");
    const nativeCreate$1 = nativeCreate;
    function hashClear() {
      this.__data__ = nativeCreate$1 ? nativeCreate$1(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$6 = Object.prototype;
    var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate$1) {
        var result = data[key];
        return result === HASH_UNDEFINED$2 ? void 0 : result;
      }
      return hasOwnProperty$5.call(data, key) ? data[key] : void 0;
    }
    var objectProto$5 = Object.prototype;
    var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$4.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$1 && value === void 0 ? HASH_UNDEFINED$1 : value;
      return this;
    }
    function Hash(entries) {
      var index2 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index2 < length) {
        var entry = entries[index2];
        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(array2, key) {
      var length = array2.length;
      while (length--) {
        if (eq(array2[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    var arrayProto = Array.prototype;
    var splice = arrayProto.splice;
    function listCacheDelete(key) {
      var data = this.__data__, index2 = assocIndexOf(data, key);
      if (index2 < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index2 == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index2, 1);
      }
      --this.size;
      return true;
    }
    function listCacheGet(key) {
      var data = this.__data__, index2 = assocIndexOf(data, key);
      return index2 < 0 ? void 0 : data[index2][1];
    }
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }
    function listCacheSet(key, value) {
      var data = this.__data__, index2 = assocIndexOf(data, key);
      if (index2 < 0) {
        ++this.size;
        data.push([key, value]);
      } else {
        data[index2][1] = value;
      }
      return this;
    }
    function ListCache(entries) {
      var index2 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index2 < length) {
        var entry = entries[index2];
        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$1, "Map");
    const Map$2 = Map$1;
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map$2 || ListCache)(),
        "string": new Hash()
      };
    }
    function isKeyable(value) {
      var type2 = typeof value;
      return type2 == "string" || type2 == "number" || type2 == "symbol" || type2 == "boolean" ? value !== "__proto__" : value === null;
    }
    function getMapData(map2, key) {
      var data = map2.__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), size2 = data.size;
      data.set(key, value);
      this.size += data.size == size2 ? 0 : 1;
      return this;
    }
    function MapCache(entries) {
      var index2 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index2 < length) {
        var entry = entries[index2];
        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$2 = "Expected a function";
    function memoize(func, resolver) {
      if (typeof func != "function" || resolver != null && typeof resolver != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$2);
      }
      var memoized = function() {
        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
        if (cache2.has(key)) {
          return cache2.get(key);
        }
        var result = func.apply(this, args);
        memoized.cache = cache2.set(key, result) || cache2;
        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 (cache2.size === MAX_MEMOIZE_SIZE) {
          cache2.clear();
        }
        return key;
      });
      var cache2 = result.cache;
      return result;
    }
    var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
    var reEscapeChar = /\\(\\)?/g;
    var stringToPath = memoizeCapped(function(string2) {
      var result = [];
      if (string2.charCodeAt(0) === 46) {
        result.push("");
      }
      string2.replace(rePropName, function(match, number2, quote, subString) {
        result.push(quote ? subString.replace(reEscapeChar, "$1") : number2 || match);
      });
      return result;
    });
    const stringToPath$1 = stringToPath;
    function toString(value) {
      return value == null ? "" : baseToString(value);
    }
    function castPath(value, object2) {
      if (isArray$1(value)) {
        return value;
      }
      return isKey(value, object2) ? [value] : stringToPath$1(toString(value));
    }
    var INFINITY$2 = 1 / 0;
    function toKey(value) {
      if (typeof value == "string" || isSymbol(value)) {
        return value;
      }
      var result = value + "";
      return result == "0" && 1 / value == -INFINITY$2 ? "-0" : result;
    }
    function baseGet(object2, path) {
      path = castPath(path, object2);
      var index2 = 0, length = path.length;
      while (object2 != null && index2 < length) {
        object2 = object2[toKey(path[index2++])];
      }
      return index2 && index2 == length ? object2 : void 0;
    }
    function get(object2, path, defaultValue) {
      var result = object2 == null ? void 0 : baseGet(object2, path);
      return result === void 0 ? defaultValue : result;
    }
    function arrayPush(array2, values) {
      var index2 = -1, length = values.length, offset2 = array2.length;
      while (++index2 < length) {
        array2[offset2 + index2] = values[index2];
      }
      return array2;
    }
    var spreadableSymbol = Symbol$2 ? Symbol$2.isConcatSpreadable : void 0;
    function isFlattenable(value) {
      return isArray$1(value) || isArguments$1(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
    }
    function baseFlatten(array2, depth, predicate, isStrict, result) {
      var index2 = -1, length = array2.length;
      predicate || (predicate = isFlattenable);
      result || (result = []);
      while (++index2 < length) {
        var value = array2[index2];
        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(array2) {
      var length = array2 == null ? 0 : array2.length;
      return length ? baseFlatten(array2, 1) : [];
    }
    function flatRest(func) {
      return setToString$1(overRest(func, void 0, flatten), func + "");
    }
    var getPrototype = overArg(Object.getPrototypeOf, Object);
    const getPrototype$1 = getPrototype;
    var objectTag$3 = "[object Object]";
    var funcProto = Function.prototype, objectProto$4 = Object.prototype;
    var funcToString = funcProto.toString;
    var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
    var objectCtorString = funcToString.call(Object);
    function isPlainObject(value) {
      if (!isObjectLike(value) || baseGetTag(value) != objectTag$3) {
        return false;
      }
      var proto = getPrototype$1(value);
      if (proto === null) {
        return true;
      }
      var Ctor = hasOwnProperty$3.call(proto, "constructor") && proto.constructor;
      return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
    }
    function castArray$1() {
      if (!arguments.length) {
        return [];
      }
      var value = arguments[0];
      return isArray$1(value) ? value : [value];
    }
    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$1 = 200;
    function stackSet(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache) {
        var pairs = data.__data__;
        if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE$1 - 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(object2, source) {
      return object2 && copyObject(source, keys(source), object2);
    }
    function baseAssignIn(object2, source) {
      return object2 && copyObject(source, keysIn(source), object2);
    }
    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 Buffer2 = moduleExports ? root$1.Buffer : void 0, allocUnsafe = Buffer2 ? Buffer2.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(array2, predicate) {
      var index2 = -1, length = array2 == null ? 0 : array2.length, resIndex = 0, result = [];
      while (++index2 < length) {
        var value = array2[index2];
        if (predicate(value, index2, array2)) {
          result[resIndex++] = value;
        }
      }
      return result;
    }
    function stubArray() {
      return [];
    }
    var objectProto$3 = Object.prototype;
    var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
    var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
    var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object2) {
      if (object2 == null) {
        return [];
      }
      object2 = Object(object2);
      return arrayFilter(nativeGetSymbols$1(object2), function(symbol) {
        return propertyIsEnumerable.call(object2, symbol);
      });
    };
    const getSymbols$1 = getSymbols;
    function copySymbols(source, object2) {
      return copyObject(source, getSymbols$1(source), object2);
    }
    var nativeGetSymbols = Object.getOwnPropertySymbols;
    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object2) {
      var result = [];
      while (object2) {
        arrayPush(result, getSymbols$1(object2));
        object2 = getPrototype$1(object2);
      }
      return result;
    };
    const getSymbolsIn$1 = getSymbolsIn;
    function copySymbolsIn(source, object2) {
      return copyObject(source, getSymbolsIn$1(source), object2);
    }
    function baseGetAllKeys(object2, keysFunc, symbolsFunc) {
      var result = keysFunc(object2);
      return isArray$1(object2) ? result : arrayPush(result, symbolsFunc(object2));
    }
    function getAllKeys(object2) {
      return baseGetAllKeys(object2, keys, getSymbols$1);
    }
    function getAllKeysIn(object2) {
      return baseGetAllKeys(object2, keysIn, getSymbolsIn$1);
    }
    var DataView = getNative(root$1, "DataView");
    const DataView$1 = DataView;
    var Promise$1 = getNative(root$1, "Promise");
    const Promise$2 = Promise$1;
    var Set$1 = getNative(root$1, "Set");
    const Set$2 = Set$1;
    var mapTag$4 = "[object Map]", objectTag$2 = "[object Object]", promiseTag = "[object Promise]", setTag$4 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
    var dataViewTag$3 = "[object DataView]";
    var dataViewCtorString = toSource(DataView$1), mapCtorString = toSource(Map$2), promiseCtorString = toSource(Promise$2), setCtorString = toSource(Set$2), weakMapCtorString = toSource(WeakMap$2);
    var getTag = baseGetTag;
    if (DataView$1 && getTag(new DataView$1(new ArrayBuffer(1))) != dataViewTag$3 || Map$2 && getTag(new Map$2()) != mapTag$4 || Promise$2 && getTag(Promise$2.resolve()) != promiseTag || Set$2 && getTag(new Set$2()) != setTag$4 || WeakMap$2 && getTag(new WeakMap$2()) != weakMapTag$1) {
      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$4;
            case promiseCtorString:
              return promiseTag;
            case setCtorString:
              return setTag$4;
            case weakMapCtorString:
              return weakMapTag$1;
          }
        }
        return result;
      };
    }
    const getTag$1 = getTag;
    var objectProto$2 = Object.prototype;
    var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
    function initCloneArray(array2) {
      var length = array2.length, result = new array2.constructor(length);
      if (length && typeof array2[0] == "string" && hasOwnProperty$2.call(array2, "index")) {
        result.index = array2.index;
        result.input = array2.input;
      }
      return result;
    }
    var Uint8Array2 = root$1.Uint8Array;
    const Uint8Array$1 = Uint8Array2;
    function cloneArrayBuffer(arrayBuffer) {
      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
      new Uint8Array$1(result).set(new Uint8Array$1(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 = /\w*$/;
    function cloneRegExp(regexp2) {
      var result = new regexp2.constructor(regexp2.source, reFlags.exec(regexp2));
      result.lastIndex = regexp2.lastIndex;
      return result;
    }
    var symbolProto$1 = Symbol$2 ? Symbol$2.prototype : void 0, 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$2 = "[object Boolean]", dateTag$2 = "[object Date]", mapTag$3 = "[object Map]", numberTag$2 = "[object Number]", regexpTag$2 = "[object RegExp]", setTag$3 = "[object Set]", stringTag$2 = "[object String]", symbolTag$2 = "[object Symbol]";
    var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
    function initCloneByTag(object2, tag, isDeep) {
      var Ctor = object2.constructor;
      switch (tag) {
        case arrayBufferTag$2:
          return cloneArrayBuffer(object2);
        case boolTag$2:
        case dateTag$2:
          return new Ctor(+object2);
        case dataViewTag$2:
          return cloneDataView(object2, 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(object2, isDeep);
        case mapTag$3:
          return new Ctor();
        case numberTag$2:
        case stringTag$2:
          return new Ctor(object2);
        case regexpTag$2:
          return cloneRegExp(object2);
        case setTag$3:
          return new Ctor();
        case symbolTag$2:
          return cloneSymbol(object2);
      }
    }
    function initCloneObject(object2) {
      return typeof object2.constructor == "function" && !isPrototype(object2) ? baseCreate$1(getPrototype$1(object2)) : {};
    }
    var mapTag$2 = "[object Map]";
    function baseIsMap(value) {
      return isObjectLike(value) && getTag$1(value) == mapTag$2;
    }
    var nodeIsMap = nodeUtil$1 && nodeUtil$1.isMap;
    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
    const isMap$1 = isMap;
    var setTag$2 = "[object Set]";
    function baseIsSet(value) {
      return isObjectLike(value) && getTag$1(value) == setTag$2;
    }
    var nodeIsSet = nodeUtil$1 && nodeUtil$1.isSet;
    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
    const isSet$1 = isSet;
    var CLONE_DEEP_FLAG$1 = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG$2 = 4;
    var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag$1 = "[object Map]", numberTag$1 = "[object Number]", objectTag$1 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$1 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]", weakMapTag = "[object WeakMap]";
    var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
    var cloneableTags = {};
    cloneableTags[argsTag$1] = cloneableTags[arrayTag$1] = cloneableTags[arrayBufferTag$1] = cloneableTags[dataViewTag$1] = cloneableTags[boolTag$1] = cloneableTags[dateTag$1] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$1] = cloneableTags[numberTag$1] = cloneableTags[objectTag$1] = cloneableTags[regexpTag$1] = cloneableTags[setTag$1] = cloneableTags[stringTag$1] = cloneableTags[symbolTag$1] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
    cloneableTags[errorTag$1] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
    function baseClone(value, bitmask, customizer, key, object2, stack) {
      var result, isDeep = bitmask & CLONE_DEEP_FLAG$1, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG$2;
      if (customizer) {
        result = object2 ? customizer(value, key, object2, stack) : customizer(value);
      }
      if (result !== void 0) {
        return result;
      }
      if (!isObject(value)) {
        return value;
      }
      var isArr = isArray$1(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$1(value)) {
          return cloneBuffer(value, isDeep);
        }
        if (tag == objectTag$1 || tag == argsTag$1 || isFunc && !object2) {
          result = isFlat || isFunc ? {} : initCloneObject(value);
          if (!isDeep) {
            return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
          }
        } else {
          if (!cloneableTags[tag]) {
            return object2 ? 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$1(value)) {
        value.forEach(function(subValue) {
          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
        });
      } else if (isMap$1(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$1 = 4;
    function clone(value) {
      return baseClone(value, CLONE_SYMBOLS_FLAG$1);
    }
    var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
    function cloneDeep(value) {
      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
    }
    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 index2 = -1, length = values == null ? 0 : values.length;
      this.__data__ = new MapCache();
      while (++index2 < length) {
        this.add(values[index2]);
      }
    }
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;
    function arraySome(array2, predicate) {
      var index2 = -1, length = array2 == null ? 0 : array2.length;
      while (++index2 < length) {
        if (predicate(array2[index2], index2, array2)) {
          return true;
        }
      }
      return false;
    }
    function cacheHas(cache2, key) {
      return cache2.has(key);
    }
    var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
    function equalArrays(array2, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array2.length, othLength = other.length;
      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      var arrStacked = stack.get(array2);
      var othStacked = stack.get(other);
      if (arrStacked && othStacked) {
        return arrStacked == other && othStacked == array2;
      }
      var index2 = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
      stack.set(array2, other);
      stack.set(other, array2);
      while (++index2 < arrLength) {
        var arrValue = array2[index2], othValue = other[index2];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, arrValue, index2, other, array2, stack) : customizer(arrValue, othValue, index2, array2, 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"](array2);
      stack["delete"](other);
      return result;
    }
    function mapToArray(map2) {
      var index2 = -1, result = Array(map2.size);
      map2.forEach(function(value, key) {
        result[++index2] = [key, value];
      });
      return result;
    }
    function setToArray(set2) {
      var index2 = -1, result = Array(set2.size);
      set2.forEach(function(value) {
        result[++index2] = value;
      });
      return result;
    }
    var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
    var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
    var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
    var symbolProto = Symbol$2 ? Symbol$2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
    function equalByTag(object2, other, tag, bitmask, customizer, equalFunc, stack) {
      switch (tag) {
        case dataViewTag:
          if (object2.byteLength != other.byteLength || object2.byteOffset != other.byteOffset) {
            return false;
          }
          object2 = object2.buffer;
          other = other.buffer;
        case arrayBufferTag:
          if (object2.byteLength != other.byteLength || !equalFunc(new Uint8Array$1(object2), new Uint8Array$1(other))) {
            return false;
          }
          return true;
        case boolTag:
        case dateTag:
        case numberTag:
          return eq(+object2, +other);
        case errorTag:
          return object2.name == other.name && object2.message == other.message;
        case regexpTag:
        case stringTag:
          return object2 == other + "";
        case mapTag:
          var convert = mapToArray;
        case setTag:
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
          convert || (convert = setToArray);
          if (object2.size != other.size && !isPartial) {
            return false;
          }
          var stacked = stack.get(object2);
          if (stacked) {
            return stacked == other;
          }
          bitmask |= COMPARE_UNORDERED_FLAG$2;
          stack.set(object2, other);
          var result = equalArrays(convert(object2), convert(other), bitmask, customizer, equalFunc, stack);
          stack["delete"](object2);
          return result;
        case symbolTag:
          if (symbolValueOf) {
            return symbolValueOf.call(object2) == symbolValueOf.call(other);
          }
      }
      return false;
    }
    var COMPARE_PARTIAL_FLAG$3 = 1;
    var objectProto$1 = Object.prototype;
    var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
    function equalObjects(object2, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object2), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
      if (objLength != othLength && !isPartial) {
        return false;
      }
      var index2 = objLength;
      while (index2--) {
        var key = objProps[index2];
        if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
          return false;
        }
      }
      var objStacked = stack.get(object2);
      var othStacked = stack.get(other);
      if (objStacked && othStacked) {
        return objStacked == other && othStacked == object2;
      }
      var result = true;
      stack.set(object2, other);
      stack.set(other, object2);
      var skipCtor = isPartial;
      while (++index2 < objLength) {
        key = objProps[index2];
        var objValue = object2[key], othValue = other[key];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, objValue, key, other, object2, stack) : customizer(objValue, othValue, key, object2, 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 = object2.constructor, othCtor = other.constructor;
        if (objCtor != othCtor && ("constructor" in object2 && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
          result = false;
        }
      }
      stack["delete"](object2);
      stack["delete"](other);
      return result;
    }
    var COMPARE_PARTIAL_FLAG$2 = 1;
    var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function baseIsEqualDeep(object2, other, bitmask, customizer, equalFunc, stack) {
      var objIsArr = isArray$1(object2), othIsArr = isArray$1(other), objTag = objIsArr ? arrayTag : getTag$1(object2), 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$1(object2)) {
        if (!isBuffer$1(other)) {
          return false;
        }
        objIsArr = true;
        objIsObj = false;
      }
      if (isSameTag && !objIsObj) {
        stack || (stack = new Stack());
        return objIsArr || isTypedArray$1(object2) ? equalArrays(object2, other, bitmask, customizer, equalFunc, stack) : equalByTag(object2, other, objTag, bitmask, customizer, equalFunc, stack);
      }
      if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
        var objIsWrapped = objIsObj && hasOwnProperty.call(object2, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
        if (objIsWrapped || othIsWrapped) {
          var objUnwrapped = objIsWrapped ? object2.value() : object2, 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(object2, 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, COMPARE_UNORDERED_FLAG$1 = 2;
    function baseIsMatch(object2, source, matchData, customizer) {
      var index2 = matchData.length, length = index2, noCustomizer = !customizer;
      if (object2 == null) {
        return !length;
      }
      object2 = Object(object2);
      while (index2--) {
        var data = matchData[index2];
        if (noCustomizer && data[2] ? data[1] !== object2[data[0]] : !(data[0] in object2)) {
          return false;
        }
      }
      while (++index2 < length) {
        data = matchData[index2];
        var key = data[0], objValue = object2[key], srcValue = data[1];
        if (noCustomizer && data[2]) {
          if (objValue === void 0 && !(key in object2)) {
            return false;
          }
        } else {
          var stack = new Stack();
          if (customizer) {
            var result = customizer(objValue, srcValue, key, object2, 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(object2) {
      var result = keys(object2), length = result.length;
      while (length--) {
        var key = result[length], value = object2[key];
        result[length] = [key, value, isStrictComparable(value)];
      }
      return result;
    }
    function matchesStrictComparable(key, srcValue) {
      return function(object2) {
        if (object2 == null) {
          return false;
        }
        return object2[key] === srcValue && (srcValue !== void 0 || key in Object(object2));
      };
    }
    function baseMatches(source) {
      var matchData = getMatchData(source);
      if (matchData.length == 1 && matchData[0][2]) {
        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
      }
      return function(object2) {
        return object2 === source || baseIsMatch(object2, source, matchData);
      };
    }
    function baseHasIn(object2, key) {
      return object2 != null && key in Object(object2);
    }
    function hasPath(object2, path, hasFunc) {
      path = castPath(path, object2);
      var index2 = -1, length = path.length, result = false;
      while (++index2 < length) {
        var key = toKey(path[index2]);
        if (!(result = object2 != null && hasFunc(object2, key))) {
          break;
        }
        object2 = object2[key];
      }
      if (result || ++index2 != length) {
        return result;
      }
      length = object2 == null ? 0 : object2.length;
      return !!length && isLength(length) && isIndex(key, length) && (isArray$1(object2) || isArguments$1(object2));
    }
    function hasIn(object2, path) {
      return object2 != null && hasPath(object2, path, baseHasIn);
    }
    var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
    function baseMatchesProperty(path, srcValue) {
      if (isKey(path) && isStrictComparable(srcValue)) {
        return matchesStrictComparable(toKey(path), srcValue);
      }
      return function(object2) {
        var objValue = get(object2, path);
        return objValue === void 0 && objValue === srcValue ? hasIn(object2, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
      };
    }
    function baseProperty(key) {
      return function(object2) {
        return object2 == null ? void 0 : object2[key];
      };
    }
    function basePropertyDeep(path) {
      return function(object2) {
        return baseGet(object2, 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$1(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
      }
      return property(value);
    }
    function createBaseFor(fromRight) {
      return function(object2, iteratee, keysFunc) {
        var index2 = -1, iterable = Object(object2), props = keysFunc(object2), length = props.length;
        while (length--) {
          var key = props[fromRight ? length : ++index2];
          if (iteratee(iterable[key], key, iterable) === false) {
            break;
          }
        }
        return object2;
      };
    }
    var baseFor = createBaseFor();
    const baseFor$1 = baseFor;
    function baseForOwn(object2, iteratee) {
      return object2 && baseFor$1(object2, 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, index2 = fromRight ? length : -1, iterable = Object(collection);
        while (fromRight ? index2-- : ++index2 < length) {
          if (iteratee(iterable[index2], index2, iterable) === false) {
            break;
          }
        }
        return collection;
      };
    }
    var baseEach = createBaseEach(baseForOwn);
    const baseEach$1 = baseEach;
    var now = function() {
      return root$1.Date.now();
    };
    const now$1 = now;
    var FUNC_ERROR_TEXT$1 = "Expected a function";
    var nativeMax$1 = Math.max, nativeMin$1 = 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$1);
      }
      wait = toNumber(wait) || 0;
      if (isObject(options)) {
        leading = !!options.leading;
        maxing = "maxWait" in options;
        maxWait = maxing ? nativeMax$1(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$1(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$1();
        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$1());
      }
      function debounced() {
        var time = now$1(), 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 assignMergeValue(object2, key, value) {
      if (value !== void 0 && !eq(object2[key], value) || value === void 0 && !(key in object2)) {
        baseAssignValue(object2, key, value);
      }
    }
    function isArrayLikeObject(value) {
      return isObjectLike(value) && isArrayLike(value);
    }
    function safeGet(object2, key) {
      if (key === "constructor" && typeof object2[key] === "function") {
        return;
      }
      if (key == "__proto__") {
        return;
      }
      return object2[key];
    }
    function toPlainObject(value) {
      return copyObject(value, keysIn(value));
    }
    function baseMergeDeep(object2, source, key, srcIndex, mergeFunc, customizer, stack) {
      var objValue = safeGet(object2, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
      if (stacked) {
        assignMergeValue(object2, key, stacked);
        return;
      }
      var newValue = customizer ? customizer(objValue, srcValue, key + "", object2, source, stack) : void 0;
      var isCommon = newValue === void 0;
      if (isCommon) {
        var isArr = isArray$1(srcValue), isBuff = !isArr && isBuffer$1(srcValue), isTyped = !isArr && !isBuff && isTypedArray$1(srcValue);
        newValue = srcValue;
        if (isArr || isBuff || isTyped) {
          if (isArray$1(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$1(srcValue)) {
          newValue = objValue;
          if (isArguments$1(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(object2, key, newValue);
    }
    function baseMerge(object2, source, srcIndex, customizer, stack) {
      if (object2 === source) {
        return;
      }
      baseFor$1(source, function(srcValue, key) {
        stack || (stack = new Stack());
        if (isObject(srcValue)) {
          baseMergeDeep(object2, source, key, srcIndex, baseMerge, customizer, stack);
        } else {
          var newValue = customizer ? customizer(safeGet(object2, key), srcValue, key + "", object2, source, stack) : void 0;
          if (newValue === void 0) {
            newValue = srcValue;
          }
          assignMergeValue(object2, key, newValue);
        }
      }, keysIn);
    }
    function arrayIncludesWith(array2, value, comparator2) {
      var index2 = -1, length = array2 == null ? 0 : array2.length;
      while (++index2 < length) {
        if (comparator2(value, array2[index2])) {
          return true;
        }
      }
      return false;
    }
    var nativeMax = Math.max, nativeMin = Math.min;
    function findLastIndex(array2, predicate, fromIndex) {
      var length = array2 == null ? 0 : array2.length;
      if (!length) {
        return -1;
      }
      var index2 = length - 1;
      if (fromIndex !== void 0) {
        index2 = toInteger(fromIndex);
        index2 = fromIndex < 0 ? nativeMax(length + index2, 0) : nativeMin(index2, length - 1);
      }
      return baseFindIndex(array2, baseIteratee(predicate), index2, true);
    }
    function baseMap(collection, iteratee) {
      var index2 = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
      baseEach$1(collection, function(value, key, collection2) {
        result[++index2] = iteratee(value, key, collection2);
      });
      return result;
    }
    function map(collection, iteratee) {
      var func = isArray$1(collection) ? arrayMap : baseMap;
      return func(collection, baseIteratee(iteratee));
    }
    function flatMap(collection, iteratee) {
      return baseFlatten(map(collection, iteratee), 1);
    }
    var INFINITY$1 = 1 / 0;
    function flattenDeep(array2) {
      var length = array2 == null ? 0 : array2.length;
      return length ? baseFlatten(array2, INFINITY$1) : [];
    }
    function fromPairs(pairs) {
      var index2 = -1, length = pairs == null ? 0 : pairs.length, result = {};
      while (++index2 < length) {
        var pair = pairs[index2];
        result[pair[0]] = pair[1];
      }
      return result;
    }
    function isEqual$1(value, other) {
      return baseIsEqual(value, other);
    }
    function isNil(value) {
      return value == null;
    }
    function isUndefined$1(value) {
      return value === void 0;
    }
    var merge = createAssigner(function(object2, source, srcIndex) {
      baseMerge(object2, source, srcIndex);
    });
    const merge$1 = merge;
    function baseSet(object2, path, value, customizer) {
      if (!isObject(object2)) {
        return object2;
      }
      path = castPath(path, object2);
      var index2 = -1, length = path.length, lastIndex = length - 1, nested = object2;
      while (nested != null && ++index2 < length) {
        var key = toKey(path[index2]), newValue = value;
        if (key === "__proto__" || key === "constructor" || key === "prototype") {
          return object2;
        }
        if (index2 != lastIndex) {
          var objValue = nested[key];
          newValue = customizer ? customizer(objValue, key, nested) : void 0;
          if (newValue === void 0) {
            newValue = isObject(objValue) ? objValue : isIndex(path[index2 + 1]) ? [] : {};
          }
        }
        assignValue(nested, key, newValue);
        nested = nested[key];
      }
      return object2;
    }
    function basePickBy(object2, paths, predicate) {
      var index2 = -1, length = paths.length, result = {};
      while (++index2 < length) {
        var path = paths[index2], value = baseGet(object2, path);
        if (predicate(value, path)) {
          baseSet(result, castPath(path, object2), value);
        }
      }
      return result;
    }
    function basePick(object2, paths) {
      return basePickBy(object2, paths, function(value, path) {
        return hasIn(object2, path);
      });
    }
    var pick = flatRest(function(object2, paths) {
      return object2 == null ? {} : basePick(object2, paths);
    });
    const pick$1 = pick;
    function set(object2, path, value) {
      return object2 == null ? object2 : baseSet(object2, path, value);
    }
    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
      });
    }
    var INFINITY = 1 / 0;
    var createSet = !(Set$2 && 1 / setToArray(new Set$2([, -0]))[1] == INFINITY) ? noop : function(values) {
      return new Set$2(values);
    };
    const createSet$1 = createSet;
    var LARGE_ARRAY_SIZE = 200;
    function baseUniq(array2, iteratee, comparator2) {
      var index2 = -1, includes = arrayIncludes, length = array2.length, isCommon = true, result = [], seen = result;
      if (comparator2) {
        isCommon = false;
        includes = arrayIncludesWith;
      } else if (length >= LARGE_ARRAY_SIZE) {
        var set2 = iteratee ? null : createSet$1(array2);
        if (set2) {
          return setToArray(set2);
        }
        isCommon = false;
        includes = cacheHas;
        seen = new SetCache();
      } else {
        seen = iteratee ? [] : result;
      }
      outer:
        while (++index2 < length) {
          var value = array2[index2], computed2 = iteratee ? iteratee(value) : value;
          value = comparator2 || value !== 0 ? value : 0;
          if (isCommon && computed2 === computed2) {
            var seenIndex = seen.length;
            while (seenIndex--) {
              if (seen[seenIndex] === computed2) {
                continue outer;
              }
            }
            if (iteratee) {
              seen.push(computed2);
            }
            result.push(value);
          } else if (!includes(seen, computed2, comparator2)) {
            if (seen !== result) {
              seen.push(computed2);
            }
            result.push(value);
          }
        }
      return result;
    }
    var union = baseRest(function(arrays) {
      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
    });
    const union$1 = union;
    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$3(val) && val.length === 0 || isObject$1(val) && !Object.keys(val).length;
    const isElement$1 = (e) => {
      if (typeof Element === "undefined")
        return false;
      return e instanceof Element;
    };
    const isPropAbsent = (prop) => {
      return isNil(prop);
    };
    const isStringNumber = (val) => {
      if (!isString$1(val)) {
        return false;
      }
      return !Number.isNaN(Number(val));
    };
    const escapeStringRegexp = (string2 = "") => string2.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
    const capitalize = (str) => capitalize$1(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(m2) {
        super(m2);
        this.name = "ElementPlusError";
      }
    }
    function throwError(scope, m2) {
      throw new ElementPlusError(`[${scope}] ${m2}`);
    }
    function debugWarn(scope, message2) {
    }
    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 _a2;
      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 computed2 = (_a2 = document.defaultView) == null ? void 0 : _a2.getComputedStyle(element, "");
        return computed2 ? computed2[key] : "";
      } catch (e) {
        return element.style[key];
      }
    };
    function addUnit(value, defaultUnit = "px") {
      if (!value)
        return "";
      if (isNumber(value) || isStringNumber(value)) {
        return `${value}${defaultUnit}`;
      } else if (isString$1(value)) {
        return value;
      }
    }
    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((s2) => overflow.includes(s2));
    };
    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 _a2;
      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;
      (_a2 = outer.parentNode) == null ? void 0 : _a2.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;
      }
    }
    /*! Element Plus Icons Vue v2.3.1 */
    var arrow_down_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "ArrowDown",
      __name: "arrow-down",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M831.872 340.864 512 652.672 192.128 340.864a30.592 30.592 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.592 30.592 0 0 0-42.752 0z"
          })
        ]));
      }
    });
    var arrow_down_default = arrow_down_vue_vue_type_script_setup_true_lang_default;
    var arrow_left_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "ArrowLeft",
      __name: "arrow-left",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.592 30.592 0 0 0 0-42.752L339.264 511.936l311.872-319.872a30.592 30.592 0 0 0 0-42.688 29.12 29.12 0 0 0-41.728 0z"
          })
        ]));
      }
    });
    var arrow_left_default = arrow_left_vue_vue_type_script_setup_true_lang_default;
    var arrow_right_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "ArrowRight",
      __name: "arrow-right",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M340.864 149.312a30.592 30.592 0 0 0 0 42.752L652.736 512 340.864 831.872a30.592 30.592 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 = arrow_right_vue_vue_type_script_setup_true_lang_default;
    var arrow_up_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "ArrowUp",
      __name: "arrow-up",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = arrow_up_vue_vue_type_script_setup_true_lang_default;
    var back_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Back",
      __name: "back",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M224 480h640a32 32 0 1 1 0 64H224a32 32 0 0 1 0-64"
          }),
          createBaseVNode("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 = back_vue_vue_type_script_setup_true_lang_default;
    var calendar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Calendar",
      __name: "calendar",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = calendar_vue_vue_type_script_setup_true_lang_default;
    var caret_right_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "CaretRight",
      __name: "caret-right",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M384 192v640l384-320.064z"
          })
        ]));
      }
    });
    var caret_right_default = caret_right_vue_vue_type_script_setup_true_lang_default;
    var caret_top_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "CaretTop",
      __name: "caret-top",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M512 320 192 704h639.936z"
          })
        ]));
      }
    });
    var caret_top_default = caret_top_vue_vue_type_script_setup_true_lang_default;
    var check_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Check",
      __name: "check",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = check_vue_vue_type_script_setup_true_lang_default;
    var circle_check_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "CircleCheckFilled",
      __name: "circle-check-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.272 38.272 0 0 0 54.336 0l262.4-262.464a38.4 38.4 0 1 0-54.272-54.336z"
          })
        ]));
      }
    });
    var circle_check_filled_default = circle_check_filled_vue_vue_type_script_setup_true_lang_default;
    var circle_check_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "CircleCheck",
      __name: "circle-check",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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"
          }),
          createBaseVNode("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.752l265.344-265.408z"
          })
        ]));
      }
    });
    var circle_check_default = circle_check_vue_vue_type_script_setup_true_lang_default;
    var circle_close_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "CircleCloseFilled",
      __name: "circle-close-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = circle_close_filled_vue_vue_type_script_setup_true_lang_default;
    var circle_close_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "CircleClose",
      __name: "circle-close",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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"
          }),
          createBaseVNode("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 = circle_close_vue_vue_type_script_setup_true_lang_default;
    var clock_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Clock",
      __name: "clock",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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"
          }),
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M480 256a32 32 0 0 1 32 32v256a32 32 0 0 1-64 0V288a32 32 0 0 1 32-32"
          }),
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M480 512h256q32 0 32 32t-32 32H480q-32 0-32-32t32-32"
          })
        ]));
      }
    });
    var clock_default = clock_vue_vue_type_script_setup_true_lang_default;
    var close_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Close",
      __name: "close",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = close_vue_vue_type_script_setup_true_lang_default;
    var d_arrow_left_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "DArrowLeft",
      __name: "d-arrow-left",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M529.408 149.376a29.12 29.12 0 0 1 41.728 0 30.592 30.592 0 0 1 0 42.688L259.264 511.936l311.872 319.936a30.592 30.592 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.672l331.648-340.224zm256 0a29.12 29.12 0 0 1 41.728 0 30.592 30.592 0 0 1 0 42.688L515.264 511.936l311.872 319.936a30.592 30.592 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.672l331.648-340.224z"
          })
        ]));
      }
    });
    var d_arrow_left_default = d_arrow_left_vue_vue_type_script_setup_true_lang_default;
    var d_arrow_right_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "DArrowRight",
      __name: "d-arrow-right",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.592 30.592 0 0 1 0-42.752L764.736 512 452.864 192a30.592 30.592 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.592 30.592 0 0 1 0-42.752L508.736 512 196.864 192a30.592 30.592 0 0 1 0-42.688z"
          })
        ]));
      }
    });
    var d_arrow_right_default = d_arrow_right_vue_vue_type_script_setup_true_lang_default;
    var delete_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Delete",
      __name: "delete",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = delete_vue_vue_type_script_setup_true_lang_default;
    var document_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Document",
      __name: "document",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = document_vue_vue_type_script_setup_true_lang_default;
    var full_screen_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "FullScreen",
      __name: "full-screen",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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-64l192-.192zm0 831.872-192-.192a32 32 0 0 1 0-64l192 .192V672a32 32 0 1 1 64 0v256h-64z"
          })
        ]));
      }
    });
    var full_screen_default = full_screen_vue_vue_type_script_setup_true_lang_default;
    var hide_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Hide",
      __name: "hide",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M876.8 156.8c0-9.6-3.2-16-9.6-22.4-6.4-6.4-12.8-9.6-22.4-9.6-9.6 0-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 176C44.8 438.4 0 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.4 0 9.6 3.2 16 9.6 22.4 6.4 6.4 12.8 9.6 22.4 9.6 9.6 0 16-3.2 22.4-9.6l704-710.4c3.2-6.4 6.4-12.8 6.4-22.4Zm-646.4 528c-76.8-70.4-128-128-153.6-172.8 28.8-48 80-105.6 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.4Zm140.8-96c-12.8-22.4-19.2-48-19.2-76.8 0-44.8 16-83.2 48-112 32-28.8 67.2-48 112-48 28.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.6-28.8 48-80 105.6-153.6 172.8-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-176C979.199 585.6 1024 528 1024 512s-48.001-73.6-134.401-176Z"
          }),
          createBaseVNode("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 112-32 28.8-67.2 48-112 48Z"
          })
        ]));
      }
    });
    var hide_default = hide_vue_vue_type_script_setup_true_lang_default;
    var info_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "InfoFilled",
      __name: "info-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.992 12.992 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 = info_filled_vue_vue_type_script_setup_true_lang_default;
    var loading_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Loading",
      __name: "loading",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.248zm452.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.248zM828.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 0z"
          })
        ]));
      }
    });
    var loading_default = loading_vue_vue_type_script_setup_true_lang_default;
    var minus_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Minus",
      __name: "minus",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M128 544h768a32 32 0 1 0 0-64H128a32 32 0 0 0 0 64"
          })
        ]));
      }
    });
    var minus_default = minus_vue_vue_type_script_setup_true_lang_default;
    var more_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "MoreFilled",
      __name: "more-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = more_filled_vue_vue_type_script_setup_true_lang_default;
    var more_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "More",
      __name: "more",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = more_vue_vue_type_script_setup_true_lang_default;
    var picture_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "PictureFilled",
      __name: "picture-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = picture_filled_vue_vue_type_script_setup_true_lang_default;
    var plus_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Plus",
      __name: "plus",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = plus_vue_vue_type_script_setup_true_lang_default;
    var question_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "QuestionFilled",
      __name: "question-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.592 0-42.944-14.08-76.736-42.24-101.376-28.16-25.344-65.472-37.312-111.232-37.312zm-12.672 406.208a54.272 54.272 0 0 0-38.72 14.784 49.408 49.408 0 0 0-15.488 38.016c0 15.488 4.928 28.16 15.488 38.016A54.848 54.848 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.968 51.968 0 0 0-15.488-38.016 55.936 55.936 0 0 0-39.424-14.784z"
          })
        ]));
      }
    });
    var question_filled_default = question_filled_vue_vue_type_script_setup_true_lang_default;
    var refresh_left_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "RefreshLeft",
      __name: "refresh-left",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = refresh_left_vue_vue_type_script_setup_true_lang_default;
    var refresh_right_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "RefreshRight",
      __name: "refresh-right",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.88z"
          })
        ]));
      }
    });
    var refresh_right_default = refresh_right_vue_vue_type_script_setup_true_lang_default;
    var scale_to_original_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "ScaleToOriginal",
      __name: "scale-to-original",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.118 30.118 0 0 0-30.118 30.118v301.177a30.118 30.118 0 0 0 60.236 0V331.294a30.118 30.118 0 0 0-30.118-30.118zm-361.412 0a30.118 30.118 0 0 0-30.118 30.118v301.177a30.118 30.118 0 1 0 60.236 0V331.294a30.118 30.118 0 0 0-30.118-30.118M512 361.412a30.118 30.118 0 0 0-30.118 30.117v30.118a30.118 30.118 0 0 0 60.236 0V391.53A30.118 30.118 0 0 0 512 361.412M512 512a30.118 30.118 0 0 0-30.118 30.118v30.117a30.118 30.118 0 0 0 60.236 0v-30.117A30.118 30.118 0 0 0 512 512"
          })
        ]));
      }
    });
    var scale_to_original_default = scale_to_original_vue_vue_type_script_setup_true_lang_default;
    var search_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Search",
      __name: "search",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = search_vue_vue_type_script_setup_true_lang_default;
    var sort_down_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "SortDown",
      __name: "sort-down",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = sort_down_vue_vue_type_script_setup_true_lang_default;
    var sort_up_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "SortUp",
      __name: "sort-up",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = sort_up_vue_vue_type_script_setup_true_lang_default;
    var star_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "StarFilled",
      __name: "star-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M283.84 867.84 512 747.776l228.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.72z"
          })
        ]));
      }
    });
    var star_filled_default = star_filled_vue_vue_type_script_setup_true_lang_default;
    var star_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "Star",
      __name: "star",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = star_vue_vue_type_script_setup_true_lang_default;
    var success_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "SuccessFilled",
      __name: "success-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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.272 38.272 0 0 0 54.336 0l262.4-262.464a38.4 38.4 0 1 0-54.272-54.336z"
          })
        ]));
      }
    });
    var success_filled_default = success_filled_vue_vue_type_script_setup_true_lang_default;
    var view_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "View",
      __name: "view",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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-288zm0 64a224 224 0 1 1 0 448 224 224 0 0 1 0-448m0 64a160.192 160.192 0 0 0-160 160c0 88.192 71.744 160 160 160s160-71.808 160-160-71.744-160-160-160"
          })
        ]));
      }
    });
    var view_default = view_vue_vue_type_script_setup_true_lang_default;
    var warning_filled_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "WarningFilled",
      __name: "warning-filled",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("path", {
            fill: "currentColor",
            d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896m0 192a58.432 58.432 0 0 0-58.24 63.744l23.36 256.384a35.072 35.072 0 0 0 69.76 0l23.296-256.384A58.432 58.432 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 = warning_filled_vue_vue_type_script_setup_true_lang_default;
    var zoom_in_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "ZoomIn",
      __name: "zoom-in",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = zoom_in_vue_vue_type_script_setup_true_lang_default;
    var zoom_out_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
      name: "ZoomOut",
      __name: "zoom-out",
      setup(__props) {
        return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
          xmlns: "http://www.w3.org/2000/svg",
          viewBox: "0 0 1024 1024"
        }, [
          createBaseVNode("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 = zoom_out_vue_vue_type_script_setup_true_lang_default;
    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: required2, default: defaultValue, type: type2, 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(", ");
          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: type2,
        required: !!required2,
        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 = {
      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 = (fn2, name) => {
      fn2.install = (app) => {
        fn2._context = app._context;
        app.config.globalProperties[name] = fn2;
      };
      return fn2;
    };
    const withInstallDirective = (directive, name) => {
      directive.install = (app) => {
        app.directive(name, directive);
      };
      return directive;
    };
    const withNoopInstall = (component2) => {
      component2.install = NOOP;
      return component2;
    };
    const composeRefs = (...refs) => {
      return (el) => {
        refs.forEach((ref2) => {
          if (isFunction$2(ref2)) {
            ref2(el);
          } else {
            ref2.value = el;
          }
        });
      };
    };
    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",
      "month",
      "date",
      "dates",
      "week",
      "datetime",
      "datetimerange",
      "daterange",
      "monthrange"
    ];
    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 getComponentSize = (size2) => {
      return componentSizeMap[size2 || "default"];
    };
    const isValidComponentSize = (val) => ["", ...componentSizes].includes(val);
    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 isVNode(node) && node.type === Fragment;
    }
    function isComment(node) {
      return isVNode(node) && node.type === Comment;
    }
    function isValidElementNode(node) {
      return isVNode(node) && !isFragment(node) && !isComment(node);
    }
    const getNormalizedProps = (node) => {
      if (!isVNode(node)) {
        return {};
      }
      const raw = node.props || {};
      const type2 = (isVNode(node.type) ? node.type.props : void 0) || {};
      const props = {};
      Object.keys(type2).forEach((key) => {
        if (hasOwn(type2[key], "default")) {
          props[key] = type2[key].default;
        }
      });
      Object.keys(raw).forEach((key) => {
        props[camelize(key)] = raw[key];
      });
      return props;
    };
    const ensureOnlyChild = (children) => {
      if (!isArray$3(children) || children.length > 1) {
        throw new Error("expect to receive a single Vue element child");
      }
      return children[0];
    };
    const flattedChildren = (children) => {
      const vNodes = isArray$3(children) ? children : [children];
      const result = [];
      vNodes.forEach((child) => {
        var _a2;
        if (isArray$3(child)) {
          result.push(...flattedChildren(child));
        } else if (isVNode(child) && isArray$3(child.children)) {
          result.push(...flattedChildren(child.children));
        } else {
          result.push(child);
          if (isVNode(child) && ((_a2 = child.component) == null ? void 0 : _a2.subTree)) {
            result.push(...flattedChildren(child.component.subTree));
          }
        }
      });
      return result;
    };
    const unique = (arr) => [...new Set(arr)];
    const castArray = (arr) => {
      if (!arr && arr !== 0)
        return [];
      return Array.isArray(arr) ? arr : [arr];
    };
    const isKorean = (text) => /([\uAC00-\uD7AF\u3130-\u318F])+/gi.test(text);
    const rAF = (fn2) => isClient ? window.requestAnimationFrame(fn2) : setTimeout(fn2, 16);
    const cAF = (handle) => isClient ? window.cancelAnimationFrame(handle) : clearTimeout(handle);
    const generateId = () => Math.floor(Math.random() * 1e4);
    const mutable = (val) => val;
    const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
    const LISTENER_PREFIX = /^on[A-Z]/;
    const useAttrs = (params = {}) => {
      const { excludeListeners = false, excludeKeys } = params;
      const allExcludeKeys = computed(() => {
        return ((excludeKeys == null ? void 0 : excludeKeys.value) || []).concat(DEFAULT_EXCLUDE_KEYS);
      });
      const instance = getCurrentInstance();
      if (!instance) {
        return computed(() => ({}));
      }
      return computed(() => {
        var _a2;
        return fromPairs(Object.entries((_a2 = instance.proxy) == null ? void 0 : _a2.$attrs).filter(([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
      });
    };
    const useDeprecated = ({ from, replacement, scope, version: version2, ref: ref2, type: type2 = "API" }, condition) => {
      watch(() => unref(condition), (val) => {
      }, {
        immediate: true
      });
    };
    const useDraggable = (targetRef, dragRef, draggable2) => {
      let transform = {
        offsetX: 0,
        offsetY: 0
      };
      const onMousedown = (e) => {
        const downX = e.clientX;
        const downY = e.clientY;
        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 + offsetY;
        const onMousemove = (e2) => {
          const moveX = Math.min(Math.max(offsetX + e2.clientX - downX, minLeft), maxLeft);
          const moveY = Math.min(Math.max(offsetY + e2.clientY - downY, minTop), maxTop);
          transform = {
            offsetX: moveX,
            offsetY: moveY
          };
          if (targetRef.value) {
            targetRef.value.style.transform = `translate(${addUnit(moveX)}, ${addUnit(moveY)})`;
          }
        };
        const onMouseup = () => {
          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);
        }
      };
      const offDraggable = () => {
        if (dragRef.value && targetRef.value) {
          dragRef.value.removeEventListener("mousedown", onMousedown);
        }
      };
      onMounted(() => {
        watchEffect(() => {
          if (draggable2.value) {
            onDraggable();
          } else {
            offDraggable();
          }
        });
      });
      onBeforeUnmount(() => {
        offDraggable();
      });
    };
    var English = {
      name: "en",
      el: {
        colorpicker: {
          confirm: "OK",
          clear: "Clear",
          defaultLabel: "color picker",
          description: "current color is {color}. press enter to select a new 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",
          week: "week",
          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"
        },
        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"
        },
        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"
        }
      }
    };
    const buildTranslator = (locale) => (path, option) => translate(path, option, unref(locale));
    const translate = (path, option, locale) => get(locale, path, path).replace(/\{(\w+)\}/g, (_2, key) => {
      var _a2;
      return `${(_a2 = option == null ? void 0 : option[key]) != null ? _a2 : `{${key}}`}`;
    });
    const buildLocaleContext = (locale) => {
      const lang = computed(() => unref(locale).name);
      const localeRef = isRef(locale) ? locale : ref(locale);
      return {
        lang,
        locale: localeRef,
        t: buildTranslator(locale)
      };
    };
    const localeContextKey = Symbol("localeContextKey");
    const useLocale = (localeOverrides) => {
      const locale = localeOverrides || inject(localeContextKey, ref());
      return buildLocaleContext(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 || (getCurrentInstance() ? inject(namespaceContextKey, ref(defaultNamespace)) : ref(defaultNamespace));
      const namespace = computed(() => {
        return unref(derivedNamespace) || defaultNamespace;
      });
      return namespace;
    };
    const useNamespace = (block, namespaceOverrides) => {
      const namespace = useGetDerivedNamespace(namespaceOverrides);
      const b2 = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
      const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
      const m2 = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
      const be2 = (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 = (object2) => {
        const styles = {};
        for (const key in object2) {
          if (object2[key]) {
            styles[`--${namespace.value}-${key}`] = object2[key];
          }
        }
        return styles;
      };
      const cssVarBlock = (object2) => {
        const styles = {};
        for (const key in object2) {
          if (object2[key]) {
            styles[`--${namespace.value}-${block}-${key}`] = object2[key];
          }
        }
        return styles;
      };
      const cssVarName = (name) => `--${namespace.value}-${name}`;
      const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
      return {
        namespace,
        b: b2,
        e,
        m: m2,
        be: be2,
        em,
        bm,
        bem,
        is,
        cssVar,
        cssVarName,
        cssVarBlock,
        cssVarBlockName
      };
    };
    const useLockscreen = (trigger2, options = {}) => {
      if (!isRef(trigger2)) {
        throwError("[useLockscreen]", "You need to pass a ref param to this function");
      }
      const ns = options.ns || useNamespace("popup");
      const hiddenCls = computed$1(() => ns.bm("parent", "hidden"));
      if (!isClient || hasClass(document.body, hiddenCls.value)) {
        return;
      }
      let scrollBarWidth2 = 0;
      let withoutHiddenClass = false;
      let bodyWidth = "0";
      const cleanup = () => {
        setTimeout(() => {
          removeClass(document == null ? void 0 : document.body, hiddenCls.value);
          if (withoutHiddenClass && document) {
            document.body.style.width = bodyWidth;
          }
        }, 200);
      };
      watch(trigger2, (val) => {
        if (!val) {
          cleanup();
          return;
        }
        withoutHiddenClass = !hasClass(document.body, hiddenCls.value);
        if (withoutHiddenClass) {
          bodyWidth = document.body.style.width;
        }
        scrollBarWidth2 = getScrollBarWidth(ns.namespace.value);
        const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
        const bodyOverflowY = getStyle(document.body, "overflowY");
        if (scrollBarWidth2 > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
          document.body.style.width = `calc(100% - ${scrollBarWidth2}px)`;
        }
        addClass(document.body, hiddenCls.value);
      });
      onScopeDispose(() => cleanup());
    };
    const _prop = buildProp({
      type: definePropType(Boolean),
      default: null
    });
    const _event = buildProp({
      type: definePropType(Function)
    });
    const createModelToggleComposable = (name) => {
      const updateEventKey = `update:${name}`;
      const updateEventKeyRaw2 = `onUpdate:${name}`;
      const useModelToggleEmits2 = [updateEventKey];
      const useModelToggleProps2 = {
        [name]: _prop,
        [updateEventKeyRaw2]: _event
      };
      const useModelToggle2 = ({
        indicator,
        toggleReason,
        shouldHideWhenRouteChanges,
        shouldProceed,
        onShow,
        onHide
      }) => {
        const instance = getCurrentInstance();
        const { emit: emit2 } = instance;
        const props = instance.props;
        const hasUpdateHandler = computed(() => isFunction$2(props[updateEventKeyRaw2]));
        const isModelBindingAbsent = computed(() => props[name] === null);
        const doShow = (event) => {
          if (indicator.value === true) {
            return;
          }
          indicator.value = true;
          if (toggleReason) {
            toggleReason.value = event;
          }
          if (isFunction$2(onShow)) {
            onShow(event);
          }
        };
        const doHide = (event) => {
          if (indicator.value === false) {
            return;
          }
          indicator.value = false;
          if (toggleReason) {
            toggleReason.value = event;
          }
          if (isFunction$2(onHide)) {
            onHide(event);
          }
        };
        const show = (event) => {
          if (props.disabled === true || isFunction$2(shouldProceed) && !shouldProceed())
            return;
          const shouldEmit = hasUpdateHandler.value && isClient;
          if (shouldEmit) {
            emit2(updateEventKey, true);
          }
          if (isModelBindingAbsent.value || !shouldEmit) {
            doShow(event);
          }
        };
        const hide = (event) => {
          if (props.disabled === true || !isClient)
            return;
          const shouldEmit = hasUpdateHandler.value && isClient;
          if (shouldEmit) {
            emit2(updateEventKey, false);
          }
          if (isModelBindingAbsent.value || !shouldEmit) {
            doHide(event);
          }
        };
        const onChange = (val) => {
          if (!isBoolean(val))
            return;
          if (props.disabled && val) {
            if (hasUpdateHandler.value) {
              emit2(updateEventKey, false);
            }
          } else if (indicator.value !== val) {
            if (val) {
              doShow();
            } else {
              doHide();
            }
          }
        };
        const toggle = () => {
          if (indicator.value) {
            hide();
          } else {
            show();
          }
        };
        watch(() => props[name], onChange);
        if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
          watch(() => ({
            ...instance.proxy.$route
          }), () => {
            if (shouldHideWhenRouteChanges.value && indicator.value) {
              hide();
            }
          });
        }
        onMounted(() => {
          onChange(props[name]);
        });
        return {
          hide,
          show,
          toggle,
          hasUpdateHandler
        };
      };
      return {
        useModelToggle: useModelToggle2,
        useModelToggleProps: useModelToggleProps2,
        useModelToggleEmits: useModelToggleEmits2
      };
    };
    createModelToggleComposable("modelValue");
    const useProp = (name) => {
      const vm = getCurrentInstance();
      return computed(() => {
        var _a2, _b;
        return (_b = (_a2 = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a2.$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 false;
      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] || {}, o2 = e.attributes[n] || {}, i = e.elements[n];
        !B(i) || !C(i) || (Object.assign(i.style, r), Object.keys(o2).forEach(function(a2) {
          var s2 = o2[a2];
          s2 === false ? i.removeAttribute(a2) : i.setAttribute(a2, s2 === true ? "" : s2);
        }));
      });
    }
    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 o2 = e.elements[r], i = e.attributes[r] || {}, a2 = Object.keys(e.styles.hasOwnProperty(r) ? e.styles[r] : n[r]), s2 = a2.reduce(function(f2, c2) {
            return f2[c2] = "", f2;
          }, {});
          !B(o2) || !C(o2) || (Object.assign(o2.style, s2), Object.keys(i).forEach(function(f2) {
            o2.removeAttribute(f2);
          }));
        });
      };
    }
    var Ae = { name: "applyStyles", enabled: true, 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 = false);
      var n = t.getBoundingClientRect(), r = 1, o2 = 1;
      if (B(t) && e) {
        var i = t.offsetHeight, a2 = t.offsetWidth;
        a2 > 0 && (r = Z(n.width) / a2 || 1), i > 0 && (o2 = Z(n.height) / i || 1);
      }
      return { width: n.width / r, height: n.height / o2, top: n.top / o2, right: n.right / r, bottom: n.bottom / o2, left: n.left / r, x: n.left / r, y: n.top / o2 };
    }
    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 true;
      if (n && Pe(n)) {
        var r = e;
        do {
          if (r && t.isSameNode(r))
            return true;
          r = r.parentNode || r.host;
        } while (r);
      }
      return false;
    }
    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 o2 = ge(t);
      for (Pe(o2) && (o2 = o2.host); B(o2) && ["html", "body"].indexOf(C(o2)) < 0; ) {
        var i = N$1(o2);
        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 o2;
        o2 = o2.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, o2 = t.options, i = n.elements.arrow, a2 = n.modifiersData.popperOffsets, s2 = q(n.placement), f2 = Le(s2), c2 = [P$1, W].indexOf(s2) >= 0, u2 = c2 ? "height" : "width";
      if (!(!i || !a2)) {
        var m2 = Tt(o2.padding, n), v2 = ke(i), l2 = f2 === "y" ? E$1 : P$1, h2 = f2 === "y" ? R : W, p2 = n.rects.reference[u2] + n.rects.reference[f2] - a2[f2] - n.rects.popper[u2], g = a2[f2] - n.rects.reference[f2], x2 = se(i), y = x2 ? f2 === "y" ? x2.clientHeight || 0 : x2.clientWidth || 0 : 0, $ = p2 / 2 - g / 2, d2 = m2[l2], b2 = y - v2[u2] - m2[h2], w2 = y / 2 - v2[u2] / 2 + $, O2 = fe(d2, w2, b2), j = f2;
        n.modifiersData[r] = (e = {}, e[j] = O2, e.centerOffset = O2 - w2, e);
      }
    }
    function Ct(t) {
      var e = t.state, n = t.options, r = n.element, o2 = r === void 0 ? "[data-popper-arrow]" : r;
      o2 != null && (typeof o2 == "string" && (o2 = e.elements.popper.querySelector(o2), !o2) || !it(e.elements.popper, o2) || (e.elements.arrow = o2));
    }
    var pt = { name: "arrow", enabled: true, 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, o2 = r.devicePixelRatio || 1;
      return { x: Z(e * o2) / o2 || 0, y: Z(n * o2) / o2 || 0 };
    }
    function ut(t) {
      var e, n = t.popper, r = t.popperRect, o2 = t.placement, i = t.variation, a2 = t.offsets, s2 = t.position, f2 = t.gpuAcceleration, c2 = t.adaptive, u2 = t.roundOffsets, m2 = t.isFixed, v2 = a2.x, l2 = v2 === void 0 ? 0 : v2, h2 = a2.y, p2 = h2 === void 0 ? 0 : h2, g = typeof u2 == "function" ? u2({ x: l2, y: p2 }) : { x: l2, y: p2 };
      l2 = g.x, p2 = g.y;
      var x2 = a2.hasOwnProperty("x"), y = a2.hasOwnProperty("y"), $ = P$1, d2 = E$1, b2 = window;
      if (c2) {
        var w2 = se(n), O2 = "clientHeight", j = "clientWidth";
        if (w2 === H(n) && (w2 = I$1(n), N$1(w2).position !== "static" && s2 === "absolute" && (O2 = "scrollHeight", j = "scrollWidth")), w2 = w2, o2 === E$1 || (o2 === P$1 || o2 === W) && i === J) {
          d2 = R;
          var A2 = m2 && w2 === b2 && b2.visualViewport ? b2.visualViewport.height : w2[O2];
          p2 -= A2 - r.height, p2 *= f2 ? 1 : -1;
        }
        if (o2 === P$1 || (o2 === E$1 || o2 === R) && i === J) {
          $ = W;
          var k = m2 && w2 === b2 && b2.visualViewport ? b2.visualViewport.width : w2[j];
          l2 -= k - r.width, l2 *= f2 ? 1 : -1;
        }
      }
      var D2 = Object.assign({ position: s2 }, c2 && qt), S2 = u2 === true ? Vt({ x: l2, y: p2 }) : { x: l2, y: p2 };
      if (l2 = S2.x, p2 = S2.y, f2) {
        var L;
        return Object.assign({}, D2, (L = {}, L[d2] = y ? "0" : "", L[$] = x2 ? "0" : "", L.transform = (b2.devicePixelRatio || 1) <= 1 ? "translate(" + l2 + "px, " + p2 + "px)" : "translate3d(" + l2 + "px, " + p2 + "px, 0)", L));
      }
      return Object.assign({}, D2, (e = {}, e[d2] = y ? p2 + "px" : "", e[$] = x2 ? l2 + "px" : "", e.transform = "", e));
    }
    function Nt(t) {
      var e = t.state, n = t.options, r = n.gpuAcceleration, o2 = r === void 0 ? true : r, i = n.adaptive, a2 = i === void 0 ? true : i, s2 = n.roundOffsets, f2 = s2 === void 0 ? true : s2, c2 = { placement: q(e.placement), variation: te(e.placement), popper: e.elements.popper, popperRect: e.rects.popper, gpuAcceleration: o2, isFixed: e.options.strategy === "fixed" };
      e.modifiersData.popperOffsets != null && (e.styles.popper = Object.assign({}, e.styles.popper, ut(Object.assign({}, c2, { offsets: e.modifiersData.popperOffsets, position: e.options.strategy, adaptive: a2, roundOffsets: f2 })))), e.modifiersData.arrow != null && (e.styles.arrow = Object.assign({}, e.styles.arrow, ut(Object.assign({}, c2, { offsets: e.modifiersData.arrow, position: "absolute", adaptive: false, roundOffsets: f2 })))), e.attributes.popper = Object.assign({}, e.attributes.popper, { "data-popper-placement": e.placement });
    }
    var Me = { name: "computeStyles", enabled: true, phase: "beforeWrite", fn: Nt, data: {} }, ye = { passive: true };
    function It(t) {
      var e = t.state, n = t.instance, r = t.options, o2 = r.scroll, i = o2 === void 0 ? true : o2, a2 = r.resize, s2 = a2 === void 0 ? true : a2, f2 = H(e.elements.popper), c2 = [].concat(e.scrollParents.reference, e.scrollParents.popper);
      return i && c2.forEach(function(u2) {
        u2.addEventListener("scroll", n.update, ye);
      }), s2 && f2.addEventListener("resize", n.update, ye), function() {
        i && c2.forEach(function(u2) {
          u2.removeEventListener("scroll", n.update, ye);
        }), s2 && f2.removeEventListener("resize", n.update, ye);
      };
    }
    var Re = { name: "eventListeners", enabled: true, 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, o2 = n.clientWidth, i = n.clientHeight, a2 = 0, s2 = 0;
      return r && (o2 = r.width, i = r.height, /^((?!chrome|android).)*safari/i.test(navigator.userAgent) || (a2 = r.offsetLeft, s2 = r.offsetTop)), { width: o2, height: i, x: a2 + Be(t), y: s2 };
    }
    function Ut(t) {
      var e, n = I$1(t), r = We(t), o2 = (e = t.ownerDocument) == null ? void 0 : e.body, i = X$1(n.scrollWidth, n.clientWidth, o2 ? o2.scrollWidth : 0, o2 ? o2.clientWidth : 0), a2 = X$1(n.scrollHeight, n.clientHeight, o2 ? o2.scrollHeight : 0, o2 ? o2.clientHeight : 0), s2 = -r.scrollLeft + Be(t), f2 = -r.scrollTop;
      return N$1(o2 || n).direction === "rtl" && (s2 += X$1(n.clientWidth, o2 ? o2.clientWidth : 0) - i), { width: i, height: a2, x: s2, y: f2 };
    }
    function Se(t) {
      var e = N$1(t), n = e.overflow, r = e.overflowX, o2 = e.overflowY;
      return /auto|scroll|overlay|hidden/.test(n + o2 + 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), o2 = r === ((n = t.ownerDocument) == null ? void 0 : n.body), i = H(r), a2 = o2 ? [i].concat(i.visualViewport || [], Se(r) ? r : []) : r, s2 = e.concat(a2);
      return o2 ? s2 : s2.concat(ce(ge(a2)));
    }
    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(o2) {
        return Q(o2) && it(o2, r) && C(o2) !== "body";
      }) : [];
    }
    function Gt(t, e, n) {
      var r = e === "clippingParents" ? Yt(t) : [].concat(e), o2 = [].concat(r, [n]), i = o2[0], a2 = o2.reduce(function(s2, f2) {
        var c2 = ht(t, f2);
        return s2.top = X$1(c2.top, s2.top), s2.right = ve(c2.right, s2.right), s2.bottom = ve(c2.bottom, s2.bottom), s2.left = X$1(c2.left, s2.left), s2;
      }, ht(t, i));
      return a2.width = a2.right - a2.left, a2.height = a2.bottom - a2.top, a2.x = a2.left, a2.y = a2.top, a2;
    }
    function mt(t) {
      var e = t.reference, n = t.element, r = t.placement, o2 = r ? q(r) : null, i = r ? te(r) : null, a2 = e.x + e.width / 2 - n.width / 2, s2 = e.y + e.height / 2 - n.height / 2, f2;
      switch (o2) {
        case E$1:
          f2 = { x: a2, y: e.y - n.height };
          break;
        case R:
          f2 = { x: a2, y: e.y + e.height };
          break;
        case W:
          f2 = { x: e.x + e.width, y: s2 };
          break;
        case P$1:
          f2 = { x: e.x - n.width, y: s2 };
          break;
        default:
          f2 = { x: e.x, y: e.y };
      }
      var c2 = o2 ? Le(o2) : null;
      if (c2 != null) {
        var u2 = c2 === "y" ? "height" : "width";
        switch (i) {
          case U$1:
            f2[c2] = f2[c2] - (e[u2] / 2 - n[u2] / 2);
            break;
          case J:
            f2[c2] = f2[c2] + (e[u2] / 2 - n[u2] / 2);
            break;
        }
      }
      return f2;
    }
    function ne(t, e) {
      e === void 0 && (e = {});
      var n = e, r = n.placement, o2 = r === void 0 ? t.placement : r, i = n.boundary, a2 = i === void 0 ? Xe : i, s2 = n.rootBoundary, f2 = s2 === void 0 ? je : s2, c2 = n.elementContext, u2 = c2 === void 0 ? K : c2, m2 = n.altBoundary, v2 = m2 === void 0 ? false : m2, l2 = n.padding, h2 = l2 === void 0 ? 0 : l2, p2 = ft(typeof h2 != "number" ? h2 : ct(h2, G)), g = u2 === K ? Ye : K, x2 = t.rects.popper, y = t.elements[v2 ? g : u2], $ = Gt(Q(y) ? y : y.contextElement || I$1(t.elements.popper), a2, f2), d2 = ee(t.elements.reference), b2 = mt({ reference: d2, element: x2, strategy: "absolute", placement: o2 }), w2 = Te(Object.assign({}, x2, b2)), O2 = u2 === K ? w2 : d2, j = { top: $.top - O2.top + p2.top, bottom: O2.bottom - $.bottom + p2.bottom, left: $.left - O2.left + p2.left, right: O2.right - $.right + p2.right }, A2 = t.modifiersData.offset;
      if (u2 === K && A2) {
        var k = A2[o2];
        Object.keys(j).forEach(function(D2) {
          var S2 = [W, R].indexOf(D2) >= 0 ? 1 : -1, L = [E$1, R].indexOf(D2) >= 0 ? "y" : "x";
          j[D2] += k[L] * S2;
        });
      }
      return j;
    }
    function Jt(t, e) {
      e === void 0 && (e = {});
      var n = e, r = n.placement, o2 = n.boundary, i = n.rootBoundary, a2 = n.padding, s2 = n.flipVariations, f2 = n.allowedAutoPlacements, c2 = f2 === void 0 ? Ee : f2, u2 = te(r), m2 = u2 ? s2 ? De : De.filter(function(h2) {
        return te(h2) === u2;
      }) : G, v2 = m2.filter(function(h2) {
        return c2.indexOf(h2) >= 0;
      });
      v2.length === 0 && (v2 = m2);
      var l2 = v2.reduce(function(h2, p2) {
        return h2[p2] = ne(t, { placement: p2, boundary: o2, rootBoundary: i, padding: a2 })[q(p2)], h2;
      }, {});
      return Object.keys(l2).sort(function(h2, p2) {
        return l2[h2] - l2[p2];
      });
    }
    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 o2 = n.mainAxis, i = o2 === void 0 ? true : o2, a2 = n.altAxis, s2 = a2 === void 0 ? true : a2, f2 = n.fallbackPlacements, c2 = n.padding, u2 = n.boundary, m2 = n.rootBoundary, v2 = n.altBoundary, l2 = n.flipVariations, h2 = l2 === void 0 ? true : l2, p2 = n.allowedAutoPlacements, g = e.options.placement, x2 = q(g), y = x2 === g, $ = f2 || (y || !h2 ? [be(g)] : Kt(g)), d2 = [g].concat($).reduce(function(z, V) {
          return z.concat(q(V) === me ? Jt(e, { placement: V, boundary: u2, rootBoundary: m2, padding: c2, flipVariations: h2, allowedAutoPlacements: p2 }) : V);
        }, []), b2 = e.rects.reference, w2 = e.rects.popper, O2 = /* @__PURE__ */ new Map(), j = true, A2 = d2[0], k = 0; k < d2.length; k++) {
          var D2 = d2[k], S2 = q(D2), L = te(D2) === U$1, re = [E$1, R].indexOf(S2) >= 0, oe = re ? "width" : "height", M2 = ne(e, { placement: D2, boundary: u2, rootBoundary: m2, altBoundary: v2, padding: c2 }), T2 = re ? L ? W : P$1 : L ? R : E$1;
          b2[oe] > w2[oe] && (T2 = be(T2));
          var pe = be(T2), _2 = [];
          if (i && _2.push(M2[S2] <= 0), s2 && _2.push(M2[T2] <= 0, M2[pe] <= 0), _2.every(function(z) {
            return z;
          })) {
            A2 = D2, j = false;
            break;
          }
          O2.set(D2, _2);
        }
        if (j)
          for (var ue = h2 ? 3 : 1, xe = function(z) {
            var V = d2.find(function(de) {
              var ae = O2.get(de);
              if (ae)
                return ae.slice(0, z).every(function(Y2) {
                  return Y2;
                });
            });
            if (V)
              return A2 = V, "break";
          }, ie = ue; ie > 0; ie--) {
            var le = xe(ie);
            if (le === "break")
              break;
          }
        e.placement !== A2 && (e.modifiersData[r]._skip = true, e.placement = A2, e.reset = true);
      }
    }
    var vt = { name: "flip", enabled: true, phase: "main", fn: Qt, requiresIfExists: ["offset"], data: { _skip: false } };
    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, o2 = e.rects.popper, i = e.modifiersData.preventOverflow, a2 = ne(e, { elementContext: "reference" }), s2 = ne(e, { altBoundary: true }), f2 = gt(a2, r), c2 = gt(s2, o2, i), u2 = yt(f2), m2 = yt(c2);
      e.modifiersData[n] = { referenceClippingOffsets: f2, popperEscapeOffsets: c2, isReferenceHidden: u2, hasPopperEscaped: m2 }, e.attributes.popper = Object.assign({}, e.attributes.popper, { "data-popper-reference-hidden": u2, "data-popper-escaped": m2 });
    }
    var bt = { name: "hide", enabled: true, phase: "main", requiresIfExists: ["preventOverflow"], fn: Zt };
    function en(t, e, n) {
      var r = q(t), o2 = [P$1, E$1].indexOf(r) >= 0 ? -1 : 1, i = typeof n == "function" ? n(Object.assign({}, e, { placement: t })) : n, a2 = i[0], s2 = i[1];
      return a2 = a2 || 0, s2 = (s2 || 0) * o2, [P$1, W].indexOf(r) >= 0 ? { x: s2, y: a2 } : { x: a2, y: s2 };
    }
    function tn(t) {
      var e = t.state, n = t.options, r = t.name, o2 = n.offset, i = o2 === void 0 ? [0, 0] : o2, a2 = Ee.reduce(function(u2, m2) {
        return u2[m2] = en(m2, e.rects, i), u2;
      }, {}), s2 = a2[e.placement], f2 = s2.x, c2 = s2.y;
      e.modifiersData.popperOffsets != null && (e.modifiersData.popperOffsets.x += f2, e.modifiersData.popperOffsets.y += c2), e.modifiersData[r] = a2;
    }
    var wt = { name: "offset", enabled: true, 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: true, 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, o2 = n.mainAxis, i = o2 === void 0 ? true : o2, a2 = n.altAxis, s2 = a2 === void 0 ? false : a2, f2 = n.boundary, c2 = n.rootBoundary, u2 = n.altBoundary, m2 = n.padding, v2 = n.tether, l2 = v2 === void 0 ? true : v2, h2 = n.tetherOffset, p2 = h2 === void 0 ? 0 : h2, g = ne(e, { boundary: f2, rootBoundary: c2, padding: m2, altBoundary: u2 }), x2 = q(e.placement), y = te(e.placement), $ = !y, d2 = Le(x2), b2 = rn(d2), w2 = e.modifiersData.popperOffsets, O2 = e.rects.reference, j = e.rects.popper, A2 = typeof p2 == "function" ? p2(Object.assign({}, e.rects, { placement: e.placement })) : p2, k = typeof A2 == "number" ? { mainAxis: A2, altAxis: A2 } : Object.assign({ mainAxis: 0, altAxis: 0 }, A2), D2 = e.modifiersData.offset ? e.modifiersData.offset[e.placement] : null, S2 = { x: 0, y: 0 };
      if (w2) {
        if (i) {
          var L, re = d2 === "y" ? E$1 : P$1, oe = d2 === "y" ? R : W, M2 = d2 === "y" ? "height" : "width", T2 = w2[d2], pe = T2 + g[re], _2 = T2 - g[oe], ue = l2 ? -j[M2] / 2 : 0, xe = y === U$1 ? O2[M2] : j[M2], ie = y === U$1 ? -j[M2] : -O2[M2], le = e.elements.arrow, z = l2 && le ? ke(le) : { width: 0, height: 0 }, V = e.modifiersData["arrow#persistent"] ? e.modifiersData["arrow#persistent"].padding : st(), de = V[re], ae = V[oe], Y2 = fe(0, O2[M2], z[M2]), jt = $ ? O2[M2] / 2 - ue - Y2 - de - k.mainAxis : xe - Y2 - de - k.mainAxis, Dt = $ ? -O2[M2] / 2 + ue + Y2 + ae + k.mainAxis : ie + Y2 + ae + k.mainAxis, Oe = e.elements.arrow && se(e.elements.arrow), Et = Oe ? d2 === "y" ? Oe.clientTop || 0 : Oe.clientLeft || 0 : 0, Ce = (L = D2 == null ? void 0 : D2[d2]) != null ? L : 0, Pt = T2 + jt - Ce - Et, At = T2 + Dt - Ce, qe = fe(l2 ? ve(pe, Pt) : pe, T2, l2 ? X$1(_2, At) : _2);
          w2[d2] = qe, S2[d2] = qe - T2;
        }
        if (s2) {
          var Ve, kt = d2 === "x" ? E$1 : P$1, Lt = d2 === "x" ? R : W, F2 = w2[b2], he = b2 === "y" ? "height" : "width", Ne = F2 + g[kt], Ie = F2 - g[Lt], $e = [E$1, P$1].indexOf(x2) !== -1, _e = (Ve = D2 == null ? void 0 : D2[b2]) != null ? Ve : 0, ze = $e ? Ne : F2 - O2[he] - j[he] - _e + k.altAxis, Fe = $e ? F2 + O2[he] + j[he] - _e - k.altAxis : Ie, Ue = l2 && $e ? St(ze, F2, Fe) : fe(l2 ? ze : Ne, F2, l2 ? Fe : Ie);
          w2[b2] = Ue, S2[b2] = Ue - F2;
        }
        e.modifiersData[r] = S2;
      }
    }
    var xt = { name: "preventOverflow", enabled: true, 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 = false);
      var r = B(e), o2 = B(e) && fn(e), i = I$1(e), a2 = ee(t, o2), s2 = { scrollLeft: 0, scrollTop: 0 }, f2 = { x: 0, y: 0 };
      return (r || !r && !n) && ((C(e) !== "body" || Se(i)) && (s2 = sn(e)), B(e) ? (f2 = ee(e, true), f2.x += e.clientLeft, f2.y += e.clientTop) : i && (f2.x = Be(i))), { x: a2.left + s2.scrollLeft - f2.x, y: a2.top + s2.scrollTop - f2.y, width: a2.width, height: a2.height };
    }
    function pn(t) {
      var e = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(), r = [];
      t.forEach(function(i) {
        e.set(i.name, i);
      });
      function o2(i) {
        n.add(i.name);
        var a2 = [].concat(i.requires || [], i.requiresIfExists || []);
        a2.forEach(function(s2) {
          if (!n.has(s2)) {
            var f2 = e.get(s2);
            f2 && o2(f2);
          }
        }), r.push(i);
      }
      return t.forEach(function(i) {
        n.has(i.name) || o2(i);
      }), r;
    }
    function un(t) {
      var e = pn(t);
      return ot.reduce(function(n, r) {
        return n.concat(e.filter(function(o2) {
          return o2.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 o2 = n[r.name];
        return n[r.name] = o2 ? Object.assign({}, o2, r, { options: Object.assign({}, o2.options, r.options), data: Object.assign({}, o2.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, o2 = e.defaultOptions, i = o2 === void 0 ? Ot : o2;
      return function(a2, s2, f2) {
        f2 === void 0 && (f2 = i);
        var c2 = { placement: "bottom", orderedModifiers: [], options: Object.assign({}, Ot, i), modifiersData: {}, elements: { reference: a2, popper: s2 }, attributes: {}, styles: {} }, u2 = [], m2 = false, v2 = { state: c2, setOptions: function(p2) {
          var g = typeof p2 == "function" ? p2(c2.options) : p2;
          h2(), c2.options = Object.assign({}, i, c2.options, g), c2.scrollParents = { reference: Q(a2) ? ce(a2) : a2.contextElement ? ce(a2.contextElement) : [], popper: ce(s2) };
          var x2 = un(dn([].concat(r, c2.options.modifiers)));
          return c2.orderedModifiers = x2.filter(function(y) {
            return y.enabled;
          }), l2(), v2.update();
        }, forceUpdate: function() {
          if (!m2) {
            var p2 = c2.elements, g = p2.reference, x2 = p2.popper;
            if ($t(g, x2)) {
              c2.rects = { reference: cn(g, se(x2), c2.options.strategy === "fixed"), popper: ke(x2) }, c2.reset = false, c2.placement = c2.options.placement, c2.orderedModifiers.forEach(function(j) {
                return c2.modifiersData[j.name] = Object.assign({}, j.data);
              });
              for (var y = 0; y < c2.orderedModifiers.length; y++) {
                if (c2.reset === true) {
                  c2.reset = false, y = -1;
                  continue;
                }
                var $ = c2.orderedModifiers[y], d2 = $.fn, b2 = $.options, w2 = b2 === void 0 ? {} : b2, O2 = $.name;
                typeof d2 == "function" && (c2 = d2({ state: c2, options: w2, name: O2, instance: v2 }) || c2);
              }
            }
          }
        }, update: ln(function() {
          return new Promise(function(p2) {
            v2.forceUpdate(), p2(c2);
          });
        }), destroy: function() {
          h2(), m2 = true;
        } };
        if (!$t(a2, s2))
          return v2;
        v2.setOptions(f2).then(function(p2) {
          !m2 && f2.onFirstUpdate && f2.onFirstUpdate(p2);
        });
        function l2() {
          c2.orderedModifiers.forEach(function(p2) {
            var g = p2.name, x2 = p2.options, y = x2 === void 0 ? {} : x2, $ = p2.effect;
            if (typeof $ == "function") {
              var d2 = $({ state: c2, name: g, instance: v2, options: y }), b2 = function() {
              };
              u2.push(d2 || b2);
            }
          });
        }
        function h2() {
          u2.forEach(function(p2) {
            return p2();
          }), u2 = [];
        }
        return v2;
      };
    }
    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 = computed(() => {
        const { onFirstUpdate, placement, strategy, modifiers } = unref(opts);
        return {
          onFirstUpdate,
          placement: placement || "bottom",
          strategy: strategy || "absolute",
          modifiers: [
            ...modifiers || [],
            stateUpdater,
            { name: "applyStyles", enabled: false }
          ]
        };
      });
      const instanceRef = shallowRef();
      const states = ref({
        styles: {
          popper: {
            position: unref(options).strategy,
            left: "0",
            top: "0"
          },
          arrow: {
            position: "absolute"
          }
        },
        attributes: {}
      });
      const destroy = () => {
        if (!instanceRef.value)
          return;
        instanceRef.value.destroy();
        instanceRef.value = void 0;
      };
      watch(options, (newOptions) => {
        const instance = unref(instanceRef);
        if (instance) {
          instance.setOptions(newOptions);
        }
      }, {
        deep: true
      });
      watch([referenceElementRef, popperElementRef], ([referenceElement, popperElement]) => {
        destroy();
        if (!referenceElement || !popperElement)
          return;
        instanceRef.value = yn(referenceElement, popperElement, unref(options));
      });
      onBeforeUnmount(() => {
        destroy();
      });
      return {
        state: computed(() => {
          var _a2;
          return { ...((_a2 = unref(instanceRef)) == null ? void 0 : _a2.state) || {} };
        }),
        styles: computed(() => unref(states).styles),
        attributes: computed(() => unref(states).attributes),
        update: () => {
          var _a2;
          return (_a2 = unref(instanceRef)) == null ? void 0 : _a2.update();
        },
        forceUpdate: () => {
          var _a2;
          return (_a2 = unref(instanceRef)) == null ? void 0 : _a2.forceUpdate();
        },
        instanceRef: computed(() => unref(instanceRef))
      };
    };
    function deriveState(state) {
      const elements = Object.keys(state.elements);
      const styles = fromPairs(elements.map((element) => [element, state.styles[element] || {}]));
      const attributes2 = fromPairs(elements.map((element) => [element, state.attributes[element]]));
      return {
        styles,
        attributes: attributes2
      };
    }
    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 useThrottleRender = (loading, throttle2 = 0) => {
      if (throttle2 === 0)
        return loading;
      const throttled = ref(false);
      let timeoutHandle = 0;
      const dispatchThrottling = () => {
        if (timeoutHandle) {
          clearTimeout(timeoutHandle);
        }
        timeoutHandle = window.setTimeout(() => {
          throttled.value = loading.value;
        }, throttle2);
      };
      onMounted(dispatchThrottling);
      watch(() => loading.value, (val) => {
        if (val) {
          dispatchThrottling();
        } else {
          throttled.value = val;
        }
      });
      return throttled;
    };
    function useTimeout() {
      let timeoutHandle;
      const registerTimeout = (fn2, delay) => {
        cancelTimeout();
        timeoutHandle = window.setTimeout(fn2, delay);
      };
      const cancelTimeout = () => window.clearTimeout(timeoutHandle);
      tryOnScopeDispose(() => cancelTimeout());
      return {
        registerTimeout,
        cancelTimeout
      };
    }
    const defaultIdInjection = {
      prefix: Math.floor(Math.random() * 1e4),
      current: 0
    };
    const ID_INJECTION_KEY = Symbol("elIdInjection");
    const useIdInjection = () => {
      return getCurrentInstance() ? inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
    };
    const useId = (deterministicId) => {
      const idInjection = useIdInjection();
      const namespace = useGetDerivedNamespace();
      const idRef = computed(() => unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
      return idRef;
    };
    let registeredEscapeHandlers = [];
    const cachedHandler = (e) => {
      const event = e;
      if (event.key === EVENT_CODE.esc) {
        registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event));
      }
    };
    const useEscapeKeydown = (handler) => {
      onMounted(() => {
        if (registeredEscapeHandlers.length === 0) {
          document.addEventListener("keydown", cachedHandler);
        }
        if (isClient)
          registeredEscapeHandlers.push(handler);
      });
      onBeforeUnmount(() => {
        registeredEscapeHandlers = registeredEscapeHandlers.filter((registeredHandler) => registeredHandler !== handler);
        if (registeredEscapeHandlers.length === 0) {
          if (isClient)
            document.removeEventListener("keydown", cachedHandler);
        }
      });
    };
    let cachedContainer;
    const usePopperContainerId = () => {
      const namespace = useGetDerivedNamespace();
      const idInjection = useIdInjection();
      const id = computed(() => {
        return `${namespace.value}-popper-container-${idInjection.prefix}`;
      });
      const selector = 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();
      onBeforeMount(() => {
        if (!isClient)
          return;
        if (!cachedContainer && !document.body.querySelector(selector.value)) {
          cachedContainer = createContainer(id.value);
        }
      });
      return {
        id,
        selector
      };
    };
    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: close2
    }) => {
      const { registerTimeout } = useTimeout();
      const {
        registerTimeout: registerTimeoutForAutoClose,
        cancelTimeout: cancelTimeoutForAutoClose
      } = useTimeout();
      const onOpen = (event) => {
        registerTimeout(() => {
          open(event);
          const _autoClose = unref(autoClose);
          if (isNumber(_autoClose) && _autoClose > 0) {
            registerTimeoutForAutoClose(() => {
              close2(event);
            }, _autoClose);
          }
        }, unref(showAfter));
      };
      const onClose = (event) => {
        cancelTimeoutForAutoClose();
        registerTimeout(() => {
          close2(event);
        }, unref(hideAfter));
      };
      return {
        onOpen,
        onClose
      };
    };
    const FORWARD_REF_INJECTION_KEY = Symbol("elForwardRef");
    const useForwardRef = (forwardRef) => {
      const setForwardRef = (el) => {
        forwardRef.value = el;
      };
      provide(FORWARD_REF_INJECTION_KEY, {
        setForwardRef
      });
    };
    const useForwardRefDirective = (setForwardRef) => {
      return {
        mounted(el) {
          setForwardRef(el);
        },
        updated(el) {
          setForwardRef(el);
        },
        unmounted() {
          setForwardRef(null);
        }
      };
    };
    const zIndex = ref(0);
    const defaultInitialZIndex = 2e3;
    const zIndexContextKey = Symbol("zIndexContextKey");
    const useZIndex = (zIndexOverrides) => {
      const zIndexInjection = zIndexOverrides || (getCurrentInstance() ? inject(zIndexContextKey, void 0) : void 0);
      const initialZIndex = computed(() => {
        const zIndexFromInjection = unref(zIndexInjection);
        return isNumber(zIndexFromInjection) ? zIndexFromInjection : defaultInitialZIndex;
      });
      const currentZIndex = computed(() => initialZIndex.value + zIndex.value);
      const nextZIndex = () => {
        zIndex.value++;
        return currentZIndex.value;
      };
      return {
        initialZIndex,
        currentZIndex,
        nextZIndex
      };
    };
    const min$1 = Math.min;
    const max$1 = Math.max;
    const round = Math.round;
    const createCoords = (v2) => ({
      x: v2,
      y: v2
    });
    function clamp(start, value, end2) {
      return max$1(start, min$1(value, end2));
    }
    function evaluate(value, param) {
      return typeof value === "function" ? value(param) : value;
    }
    function getSide(placement) {
      return placement.split("-")[0];
    }
    function getAlignment(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(placement)) ? "y" : "x";
    }
    function getAlignmentAxis(placement) {
      return getOppositeAxis(getSideAxis(placement));
    }
    function expandPaddingObject(padding) {
      return {
        top: 0,
        right: 0,
        bottom: 0,
        left: 0,
        ...padding
      };
    }
    function getPaddingObject(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
      };
    }
    function computeCoordsFromPlacement(_ref, placement, rtl) {
      let {
        reference,
        floating
      } = _ref;
      const sideAxis = getSideAxis(placement);
      const alignmentAxis = getAlignmentAxis(placement);
      const alignLength = getAxisLength(alignmentAxis);
      const side = getSide(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(placement)) {
        case "start":
          coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
          break;
        case "end":
          coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
          break;
      }
      return coords;
    }
    const computePosition$1 = async (reference, floating, config) => {
      const {
        placement = "bottom",
        strategy = "absolute",
        middleware = [],
        platform: platform2
      } = config;
      const validMiddleware = middleware.filter(Boolean);
      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
      let rects = await platform2.getElementRects({
        reference,
        floating,
        strategy
      });
      let {
        x: x2,
        y
      } = computeCoordsFromPlacement(rects, placement, rtl);
      let statefulPlacement = placement;
      let middlewareData = {};
      let resetCount = 0;
      for (let i = 0; i < validMiddleware.length; i++) {
        const {
          name,
          fn: fn2
        } = validMiddleware[i];
        const {
          x: nextX,
          y: nextY,
          data,
          reset
        } = await fn2({
          x: x2,
          y,
          initialPlacement: placement,
          placement: statefulPlacement,
          strategy,
          middlewareData,
          rects,
          platform: platform2,
          elements: {
            reference,
            floating
          }
        });
        x2 = nextX != null ? nextX : x2;
        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 platform2.getElementRects({
                reference,
                floating,
                strategy
              }) : reset.rects;
            }
            ({
              x: x2,
              y
            } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
          }
          i = -1;
          continue;
        }
      }
      return {
        x: x2,
        y,
        placement: statefulPlacement,
        strategy,
        middlewareData
      };
    };
    const arrow = (options) => ({
      name: "arrow",
      options,
      async fn(state) {
        const {
          x: x2,
          y,
          placement,
          rects,
          platform: platform2,
          elements,
          middlewareData
        } = state;
        const {
          element,
          padding = 0
        } = evaluate(options, state) || {};
        if (element == null) {
          return {};
        }
        const paddingObject = getPaddingObject(padding);
        const coords = {
          x: x2,
          y
        };
        const axis = getAlignmentAxis(placement);
        const length = getAxisLength(axis);
        const arrowDimensions = await platform2.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 (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
        let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
        if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
          clientSize = elements.floating[clientProp] || rects.floating[length];
        }
        const centerToReference = endDiff / 2 - startDiff / 2;
        const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
        const minPadding = min$1(paddingObject[minProp], largestPossiblePadding);
        const maxPadding = min$1(paddingObject[maxProp], largestPossiblePadding);
        const min$1$1 = minPadding;
        const max2 = clientSize - arrowDimensions[length] - maxPadding;
        const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
        const offset2 = clamp(min$1$1, center, max2);
        const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center != offset2 && rects.reference[length] / 2 - (center < min$1$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
        const alignmentOffset = shouldAddOffset ? center < min$1$1 ? center - min$1$1 : center - max2 : 0;
        return {
          [axis]: coords[axis] + alignmentOffset,
          data: {
            [axis]: offset2,
            centerOffset: center - offset2 - alignmentOffset,
            ...shouldAddOffset && {
              alignmentOffset
            }
          },
          reset: shouldAddOffset
        };
      }
    });
    async function convertValueToCoords(state, options) {
      const {
        placement,
        platform: platform2,
        elements
      } = state;
      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
      const side = getSide(placement);
      const alignment = getAlignment(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);
      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
      };
    }
    const offset = function(options) {
      if (options === void 0) {
        options = 0;
      }
      return {
        name: "offset",
        options,
        async fn(state) {
          var _middlewareData$offse, _middlewareData$arrow;
          const {
            x: x2,
            y,
            placement,
            middlewareData
          } = state;
          const diffCoords = await convertValueToCoords(state, options);
          if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
            return {};
          }
          return {
            x: x2 + diffCoords.x,
            y: y + diffCoords.y,
            data: {
              ...diffCoords,
              placement
            }
          };
        }
      };
    };
    function getNodeName(node) {
      if (isNode(node)) {
        return (node.nodeName || "").toLowerCase();
      }
      return "#document";
    }
    function getWindow(node) {
      var _node$ownerDocument;
      return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
    }
    function getDocumentElement(node) {
      var _ref;
      return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
    }
    function isNode(value) {
      return value instanceof Node || value instanceof getWindow(value).Node;
    }
    function isElement(value) {
      return value instanceof Element || value instanceof getWindow(value).Element;
    }
    function isHTMLElement(value) {
      return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
    }
    function isShadowRoot(value) {
      if (typeof ShadowRoot === "undefined") {
        return false;
      }
      return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
    }
    function isOverflowElement(element) {
      const {
        overflow,
        overflowX,
        overflowY,
        display
      } = getComputedStyle$1(element);
      return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
    }
    function isTableElement(element) {
      return ["table", "td", "th"].includes(getNodeName(element));
    }
    function isContainingBlock(element) {
      const webkit = isWebKit();
      const css = getComputedStyle$1(element);
      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(element) {
      let currentNode = getParentNode(element);
      while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
        if (isContainingBlock(currentNode)) {
          return currentNode;
        } else {
          currentNode = getParentNode(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(node));
    }
    function getComputedStyle$1(element) {
      return getWindow(element).getComputedStyle(element);
    }
    function getNodeScroll(element) {
      if (isElement(element)) {
        return {
          scrollLeft: element.scrollLeft,
          scrollTop: element.scrollTop
        };
      }
      return {
        scrollLeft: element.pageXOffset,
        scrollTop: element.pageYOffset
      };
    }
    function getParentNode(node) {
      if (getNodeName(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(node) && node.host || // Fallback.
        getDocumentElement(node)
      );
      return isShadowRoot(result) ? result.host : result;
    }
    function getNearestOverflowAncestor(node) {
      const parentNode = getParentNode(node);
      if (isLastTraversableNode(parentNode)) {
        return node.ownerDocument ? node.ownerDocument.body : node.body;
      }
      if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
        return parentNode;
      }
      return getNearestOverflowAncestor(parentNode);
    }
    function getOverflowAncestors(node, list, traverseIframes) {
      var _node$ownerDocument2;
      if (list === void 0) {
        list = [];
      }
      if (traverseIframes === void 0) {
        traverseIframes = true;
      }
      const scrollableAncestor = getNearestOverflowAncestor(node);
      const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
      const win = getWindow(scrollableAncestor);
      if (isBody) {
        return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
      }
      return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
    }
    function getCssDimensions(element) {
      const css = getComputedStyle$1(element);
      let width = parseFloat(css.width) || 0;
      let height = parseFloat(css.height) || 0;
      const hasOffset = isHTMLElement(element);
      const offsetWidth = hasOffset ? element.offsetWidth : width;
      const offsetHeight = hasOffset ? element.offsetHeight : height;
      const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
      if (shouldFallback) {
        width = offsetWidth;
        height = offsetHeight;
      }
      return {
        width,
        height,
        $: shouldFallback
      };
    }
    function unwrapElement(element) {
      return !isElement(element) ? element.contextElement : element;
    }
    function getScale(element) {
      const domElement = unwrapElement(element);
      if (!isHTMLElement(domElement)) {
        return createCoords(1);
      }
      const rect = domElement.getBoundingClientRect();
      const {
        width,
        height,
        $
      } = getCssDimensions(domElement);
      let x2 = ($ ? round(rect.width) : rect.width) / width;
      let y = ($ ? round(rect.height) : rect.height) / height;
      if (!x2 || !Number.isFinite(x2)) {
        x2 = 1;
      }
      if (!y || !Number.isFinite(y)) {
        y = 1;
      }
      return {
        x: x2,
        y
      };
    }
    const noOffsets = /* @__PURE__ */ createCoords(0);
    function getVisualOffsets(element) {
      const win = getWindow(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(element)) {
        return false;
      }
      return isFixed;
    }
    function getBoundingClientRect(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(offsetParent)) {
            scale = getScale(offsetParent);
          }
        } else {
          scale = getScale(element);
        }
      }
      const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
      let x2 = (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(domElement);
        const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
        let currentIFrame = win.frameElement;
        while (currentIFrame && offsetParent && offsetWin !== win) {
          const iframeScale = getScale(currentIFrame);
          const iframeRect = currentIFrame.getBoundingClientRect();
          const css = getComputedStyle$1(currentIFrame);
          const left2 = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
          const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
          x2 *= iframeScale.x;
          y *= iframeScale.y;
          width *= iframeScale.x;
          height *= iframeScale.y;
          x2 += left2;
          y += top;
          currentIFrame = getWindow(currentIFrame).frameElement;
        }
      }
      return rectToClientRect({
        width,
        height,
        x: x2,
        y
      });
    }
    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
      };
      let scale = createCoords(1);
      const offsets = createCoords(0);
      if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
        if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
          scroll = getNodeScroll(offsetParent);
        }
        if (isHTMLElement(offsetParent)) {
          const offsetRect = getBoundingClientRect(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(element) {
      return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
    }
    function getDocumentRect(element) {
      const html = getDocumentElement(element);
      const scroll = getNodeScroll(element);
      const body = element.ownerDocument.body;
      const width = max$1(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
      const height = max$1(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
      let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
      const y = -scroll.scrollTop;
      if (getComputedStyle$1(body).direction === "rtl") {
        x2 += max$1(html.clientWidth, body.clientWidth) - width;
      }
      return {
        width,
        height,
        x: x2,
        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 x2 = 0;
      let y = 0;
      if (visualViewport) {
        width = visualViewport.width;
        height = visualViewport.height;
        const visualViewportBased = isWebKit();
        if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
          x2 = visualViewport.offsetLeft;
          y = visualViewport.offsetTop;
        }
      }
      return {
        width,
        height,
        x: x2,
        y
      };
    }
    function getInnerBoundingClientRect(element, strategy) {
      const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
      const top = clientRect.top + element.clientTop;
      const left2 = clientRect.left + element.clientLeft;
      const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
      const width = element.clientWidth * scale.x;
      const height = element.clientHeight * scale.y;
      const x2 = left2 * scale.x;
      const y = top * scale.y;
      return {
        width,
        height,
        x: x2,
        y
      };
    }
    function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
      let rect;
      if (clippingAncestor === "viewport") {
        rect = getViewportRect(element, strategy);
      } else if (clippingAncestor === "document") {
        rect = getDocumentRect(getDocumentElement(element));
      } else if (isElement(clippingAncestor)) {
        rect = getInnerBoundingClientRect(clippingAncestor, strategy);
      } else {
        const visualOffsets = getVisualOffsets(element);
        rect = {
          ...clippingAncestor,
          x: clippingAncestor.x - visualOffsets.x,
          y: clippingAncestor.y - visualOffsets.y
        };
      }
      return rectToClientRect(rect);
    }
    function hasFixedPositionAncestor(element, stopNode) {
      const parentNode = getParentNode(element);
      if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
        return false;
      }
      return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
    }
    function getClippingElementAncestors(element, cache2) {
      const cachedResult = cache2.get(element);
      if (cachedResult) {
        return cachedResult;
      }
      let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
      let currentContainingBlockComputedStyle = null;
      const elementIsFixed = getComputedStyle$1(element).position === "fixed";
      let currentNode = elementIsFixed ? getParentNode(element) : element;
      while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
        const computedStyle = getComputedStyle$1(currentNode);
        const currentNodeIsContaining = isContainingBlock(currentNode);
        if (!currentNodeIsContaining && computedStyle.position === "fixed") {
          currentContainingBlockComputedStyle = null;
        }
        const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
        if (shouldDropCurrentNode) {
          result = result.filter((ancestor) => ancestor !== currentNode);
        } else {
          currentContainingBlockComputedStyle = computedStyle;
        }
        currentNode = getParentNode(currentNode);
      }
      cache2.set(element, result);
      return result;
    }
    function getClippingRect(_ref) {
      let {
        element,
        boundary,
        rootBoundary,
        strategy
      } = _ref;
      const elementClippingAncestors = boundary === "clippingAncestors" ? getClippingElementAncestors(element, this._c) : [].concat(boundary);
      const clippingAncestors = [...elementClippingAncestors, rootBoundary];
      const firstClippingAncestor = clippingAncestors[0];
      const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
        const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
        accRect.top = max$1(rect.top, accRect.top);
        accRect.right = min$1(rect.right, accRect.right);
        accRect.bottom = min$1(rect.bottom, accRect.bottom);
        accRect.left = max$1(rect.left, accRect.left);
        return accRect;
      }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
      return {
        width: clippingRect.right - clippingRect.left,
        height: clippingRect.bottom - clippingRect.top,
        x: clippingRect.left,
        y: clippingRect.top
      };
    }
    function getDimensions(element) {
      return getCssDimensions(element);
    }
    function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
      const isOffsetParentAnElement = isHTMLElement(offsetParent);
      const documentElement = getDocumentElement(offsetParent);
      const isFixed = strategy === "fixed";
      const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
      let scroll = {
        scrollLeft: 0,
        scrollTop: 0
      };
      const offsets = createCoords(0);
      if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
        if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
          scroll = getNodeScroll(offsetParent);
        }
        if (isOffsetParentAnElement) {
          const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
          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 getTrueOffsetParent(element, polyfill) {
      if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") {
        return null;
      }
      if (polyfill) {
        return polyfill(element);
      }
      return element.offsetParent;
    }
    function getOffsetParent(element, polyfill) {
      const window2 = getWindow(element);
      if (!isHTMLElement(element)) {
        return window2;
      }
      let offsetParent = getTrueOffsetParent(element, polyfill);
      while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === "static") {
        offsetParent = getTrueOffsetParent(offsetParent, polyfill);
      }
      if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle$1(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
        return window2;
      }
      return offsetParent || getContainingBlock(element) || window2;
    }
    const getElementRects = async function(_ref) {
      let {
        reference,
        floating,
        strategy
      } = _ref;
      const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
      const getDimensionsFn = this.getDimensions;
      return {
        reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
        floating: {
          x: 0,
          y: 0,
          ...await getDimensionsFn(floating)
        }
      };
    };
    function isRTL$1(element) {
      return getComputedStyle$1(element).direction === "rtl";
    }
    const platform = {
      convertOffsetParentRelativeRectToViewportRelativeRect,
      getDocumentElement,
      getClippingRect,
      getOffsetParent,
      getElementRects,
      getClientRects,
      getDimensions,
      getScale,
      isElement,
      isRTL: isRTL$1
    };
    const computePosition = (reference, floating, options) => {
      const cache2 = /* @__PURE__ */ new Map();
      const mergedOptions = {
        platform,
        ...options
      };
      const platformWithCache = {
        ...mergedOptions.platform,
        _c: cache2
      };
      return computePosition$1(reference, floating, {
        ...mergedOptions,
        platform: platformWithCache
      });
    };
    buildProps({});
    const unrefReference = (elRef) => {
      if (!isClient)
        return;
      if (!elRef)
        return elRef;
      const unrefEl = unrefElement(elRef);
      if (unrefEl)
        return unrefEl;
      return isRef(elRef) ? unrefEl : elRef;
    };
    const useFloating = ({
      middleware,
      placement,
      strategy
    }) => {
      const referenceRef = ref();
      const contentRef = ref();
      const x2 = ref();
      const y = ref();
      const middlewareData = ref({});
      const states = {
        x: x2,
        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(referenceEl, contentEl, {
          placement: unref(placement),
          strategy: unref(strategy),
          middleware: unref(middleware)
        });
        keysOf(states).forEach((key) => {
          states[key].value = data[key];
        });
      };
      onMounted(() => {
        watchEffect(() => {
          update();
        });
      });
      return {
        ...states,
        update,
        referenceRef,
        contentRef
      };
    };
    const arrowMiddleware = ({
      arrowRef,
      padding
    }) => {
      return {
        name: "arrow",
        options: {
          element: arrowRef,
          padding
        },
        fn(args) {
          const arrowEl = unref(arrowRef);
          if (!arrowEl)
            return {};
          return arrow({
            element: arrowEl,
            padding
          }).fn(args);
        }
      };
    };
    function useCursor(input) {
      const selectionRef = ref();
      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));
        selectionRef.value = {
          selectionStart,
          selectionEnd,
          value,
          beforeTxt,
          afterTxt
        };
      }
      function setCursor() {
        if (input.value == void 0 || selectionRef.value == void 0)
          return;
        const { value } = input.value;
        const { beforeTxt, afterTxt, selectionStart } = selectionRef.value;
        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 _a2;
        return isVNode(n) && ((_a2 = n.type) == null ? void 0 : _a2.name) === childComponentName && !!n.component;
      });
      const uids = nodes.map((n) => n.component.uid);
      return uids.map((uid2) => children[uid2]).filter((p2) => !!p2);
    };
    const useOrderedChildren = (vm, childComponentName) => {
      const children = {};
      const orderedChildren = shallowRef([]);
      const addChild = (child) => {
        children[child.uid] = child;
        orderedChildren.value = getOrderedChildren(vm, childComponentName, children);
      };
      const removeChild = (uid2) => {
        delete children[uid2];
        orderedChildren.value = orderedChildren.value.filter((children2) => children2.uid !== uid2);
      };
      return {
        children: orderedChildren,
        addChild,
        removeChild
      };
    };
    const useSizeProp = buildProp({
      type: String,
      values: componentSizes,
      required: false
    });
    const SIZE_INJECTION_KEY = Symbol("size");
    const useGlobalSize = () => {
      const injectedSize = inject(SIZE_INJECTION_KEY, {});
      return computed(() => {
        return unref(injectedSize.size) || "";
      });
    };
    function useFocusController(target, { afterFocus, beforeBlur, afterBlur } = {}) {
      const instance = getCurrentInstance();
      const { emit: emit2 } = instance;
      const wrapperRef = shallowRef();
      const isFocused = ref(false);
      const handleFocus = (event) => {
        if (isFocused.value)
          return;
        isFocused.value = true;
        emit2("focus", event);
        afterFocus == null ? void 0 : afterFocus();
      };
      const handleBlur = (event) => {
        var _a2;
        const cancelBlur = isFunction$2(beforeBlur) ? beforeBlur(event) : false;
        if (cancelBlur || event.relatedTarget && ((_a2 = wrapperRef.value) == null ? void 0 : _a2.contains(event.relatedTarget)))
          return;
        isFocused.value = false;
        emit2("blur", event);
        afterBlur == null ? void 0 : afterBlur();
      };
      const handleClick = () => {
        var _a2;
        (_a2 = target.value) == null ? void 0 : _a2.focus();
      };
      watch(wrapperRef, (el) => {
        if (el) {
          el.setAttribute("tabindex", "-1");
        }
      });
      useEventListener(wrapperRef, "click", handleClick);
      return {
        wrapperRef,
        isFocused,
        handleFocus,
        handleBlur
      };
    }
    const configProviderContextKey = Symbol();
    const globalConfig = ref();
    function useGlobalConfig(key, defaultValue = void 0) {
      const config = getCurrentInstance() ? inject(configProviderContextKey, globalConfig) : globalConfig;
      if (key) {
        return computed(() => {
          var _a2, _b;
          return (_b = (_a2 = config.value) == null ? void 0 : _a2[key]) != null ? _b : defaultValue;
        });
      } else {
        return config;
      }
    }
    function useGlobalComponentSettings(block, sizeFallback) {
      const config = useGlobalConfig();
      const ns = useNamespace(block, computed(() => {
        var _a2;
        return ((_a2 = config.value) == null ? void 0 : _a2.namespace) || defaultNamespace;
      }));
      const locale = useLocale(computed(() => {
        var _a2;
        return (_a2 = config.value) == null ? void 0 : _a2.locale;
      }));
      const zIndex2 = useZIndex(computed(() => {
        var _a2;
        return ((_a2 = config.value) == null ? void 0 : _a2.zIndex) || defaultInitialZIndex;
      }));
      const size2 = computed(() => {
        var _a2;
        return unref(sizeFallback) || ((_a2 = config.value) == null ? void 0 : _a2.size) || "";
      });
      provideGlobalConfig(computed(() => unref(config) || {}));
      return {
        ns,
        locale,
        zIndex: zIndex2,
        size: size2
      };
    }
    const provideGlobalConfig = (config, app, global2 = false) => {
      var _a2;
      const inSetup = !!getCurrentInstance();
      const oldConfig = inSetup ? useGlobalConfig() : void 0;
      const provideFn = (_a2 = app == null ? void 0 : app.provide) != null ? _a2 : inSetup ? provide : void 0;
      if (!provideFn) {
        return;
      }
      const context = computed(() => {
        const cfg = unref(config);
        if (!(oldConfig == null ? void 0 : oldConfig.value))
          return cfg;
        return mergeConfig(oldConfig.value, cfg);
      });
      provideFn(configProviderContextKey, context);
      provideFn(localeContextKey, computed(() => context.value.locale));
      provideFn(namespaceContextKey, computed(() => context.value.namespace));
      provideFn(zIndexContextKey, computed(() => context.value.zIndex));
      provideFn(SIZE_INJECTION_KEY, {
        size: computed(() => context.value.size || "")
      });
      if (global2 || !globalConfig.value) {
        globalConfig.value = context.value;
      }
      return context;
    };
    const mergeConfig = (a2, b2) => {
      var _a2;
      const keys2 = [.../* @__PURE__ */ new Set([...keysOf(a2), ...keysOf(b2)])];
      const obj = {};
      for (const key of keys2) {
        obj[key] = (_a2 = b2[key]) != null ? _a2 : a2[key];
      }
      return obj;
    };
    const configProviderProps = buildProps({
      a11y: {
        type: Boolean,
        default: true
      },
      locale: {
        type: definePropType(Object)
      },
      size: useSizeProp,
      button: {
        type: definePropType(Object)
      },
      experimentalFeatures: {
        type: definePropType(Object)
      },
      keyboardNavigation: {
        type: Boolean,
        default: true
      },
      message: {
        type: definePropType(Object)
      },
      zIndex: Number,
      namespace: {
        type: String,
        default: "el"
      }
    });
    const messageConfig = {};
    const ConfigProvider = /* @__PURE__ */ defineComponent({
      name: "ElConfigProvider",
      props: configProviderProps,
      setup(props, { slots }) {
        watch(() => props.message, (val) => {
          Object.assign(messageConfig, val != null ? val : {});
        }, { immediate: true, deep: true });
        const config = provideGlobalConfig(props);
        return () => renderSlot(slots, "default", { config: config == null ? void 0 : config.value });
      }
    });
    const ElConfigProvider = withInstall(ConfigProvider);
    const version = "2.4.3";
    const makeInstaller = (components = []) => {
      const install = (app, options) => {
        if (app[INSTALLED_KEY])
          return;
        app[INSTALLED_KEY] = true;
        components.forEach((c2) => app.use(c2));
        if (options)
          provideGlobalConfig(options, app, true);
      };
      return {
        version,
        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$1 = (sfc, props) => {
      const target = sfc.__vccOpts || sfc;
      for (const [key, val] of props) {
        target[key] = val;
      }
      return target;
    };
    const COMPONENT_NAME$n = "ElAffix";
    const __default__$1D = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$n
    });
    const _sfc_main$2n = /* @__PURE__ */ defineComponent({
      ...__default__$1D,
      props: affixProps,
      emits: affixEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("affix");
        const target = shallowRef();
        const root2 = shallowRef();
        const scrollContainer = shallowRef();
        const { height: windowHeight } = useWindowSize();
        const {
          height: rootHeight,
          width: rootWidth,
          top: rootTop,
          bottom: rootBottom,
          update: updateRoot
        } = useElementBounding(root2, { windowScroll: false });
        const targetRect = useElementBounding(target);
        const fixed = ref(false);
        const scrollTop = ref(0);
        const transform = ref(0);
        const rootStyle = computed(() => {
          return {
            height: fixed.value ? `${rootHeight.value}px` : "",
            width: fixed.value ? `${rootWidth.value}px` : ""
          };
        });
        const affixStyle = computed(() => {
          if (!fixed.value)
            return {};
          const offset2 = props.offset ? addUnit(props.offset) : 0;
          return {
            height: `${rootHeight.value}px`,
            width: `${rootWidth.value}px`,
            top: props.position === "top" ? offset2 : "",
            bottom: props.position === "bottom" ? offset2 : "",
            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;
          if (props.position === "top") {
            if (props.target) {
              const difference = targetRect.bottom.value - props.offset - rootHeight.value;
              fixed.value = props.offset > rootTop.value && targetRect.bottom.value > 0;
              transform.value = difference < 0 ? difference : 0;
            } else {
              fixed.value = props.offset > rootTop.value;
            }
          } else if (props.target) {
            const difference = windowHeight.value - targetRect.top.value - props.offset - rootHeight.value;
            fixed.value = windowHeight.value - props.offset < rootBottom.value && windowHeight.value > targetRect.top.value;
            transform.value = difference < 0 ? -difference : 0;
          } else {
            fixed.value = windowHeight.value - props.offset < rootBottom.value;
          }
        };
        const handleScroll2 = () => {
          updateRoot();
          emit2("scroll", {
            scrollTop: scrollTop.value,
            fixed: fixed.value
          });
        };
        watch(fixed, (val) => emit2("change", val));
        onMounted(() => {
          var _a2;
          if (props.target) {
            target.value = (_a2 = document.querySelector(props.target)) != null ? _a2 : void 0;
            if (!target.value)
              throwError(COMPONENT_NAME$n, `Target is not existed: ${props.target}`);
          } else {
            target.value = document.documentElement;
          }
          scrollContainer.value = getScrollContainer(root2.value, true);
          updateRoot();
        });
        useEventListener(scrollContainer, "scroll", handleScroll2);
        watchEffect(update);
        expose({
          update,
          updateRoot
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "root",
            ref: root2,
            class: normalizeClass(unref(ns).b()),
            style: normalizeStyle(unref(rootStyle))
          }, [
            createBaseVNode("div", {
              class: normalizeClass({ [unref(ns).m("fixed")]: fixed.value }),
              style: normalizeStyle(unref(affixStyle))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 6)
          ], 6);
        };
      }
    });
    var Affix = /* @__PURE__ */ _export_sfc$1(_sfc_main$2n, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/affix/src/affix.vue"]]);
    const ElAffix = withInstall(Affix);
    const iconProps = buildProps({
      size: {
        type: definePropType([Number, String])
      },
      color: {
        type: String
      }
    });
    const __default__$1C = /* @__PURE__ */ defineComponent({
      name: "ElIcon",
      inheritAttrs: false
    });
    const _sfc_main$2m = /* @__PURE__ */ defineComponent({
      ...__default__$1C,
      props: iconProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("icon");
        const style = computed(() => {
          const { size: size2, color } = props;
          if (!size2 && !color)
            return {};
          return {
            fontSize: isUndefined(size2) ? void 0 : addUnit(size2),
            "--color": color
          };
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("i", mergeProps({
            class: unref(ns).b(),
            style: unref(style)
          }, _ctx.$attrs), [
            renderSlot(_ctx.$slots, "default")
          ], 16);
        };
      }
    });
    var Icon = /* @__PURE__ */ _export_sfc$1(_sfc_main$2m, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/icon/src/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"
      }
    });
    const alertEmits = {
      close: (evt) => evt instanceof MouseEvent
    };
    const __default__$1B = /* @__PURE__ */ defineComponent({
      name: "ElAlert"
    });
    const _sfc_main$2l = /* @__PURE__ */ defineComponent({
      ...__default__$1B,
      props: alertProps,
      emits: alertEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const { Close } = TypeComponents;
        const slots = useSlots();
        const ns = useNamespace("alert");
        const visible = ref(true);
        const iconComponent = computed(() => TypeComponentsMap[props.type]);
        const iconClass = computed(() => [
          ns.e("icon"),
          { [ns.is("big")]: !!props.description || !!slots.default }
        ]);
        const isBoldTitle = computed(() => {
          return { [ns.is("bold")]: props.description || slots.default };
        });
        const close2 = (evt) => {
          visible.value = false;
          emit2("close", evt);
        };
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Transition, {
            name: unref(ns).b("fade"),
            persisted: ""
          }, {
            default: withCtx(() => [
              withDirectives(createBaseVNode("div", {
                class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.type), unref(ns).is("center", _ctx.center), unref(ns).is(_ctx.effect)]),
                role: "alert"
              }, [
                _ctx.showIcon && unref(iconComponent) ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 0,
                  class: normalizeClass(unref(iconClass))
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
                  ]),
                  _: 1
                }, 8, ["class"])) : createCommentVNode("v-if", true),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("content"))
                }, [
                  _ctx.title || _ctx.$slots.title ? (openBlock(), createElementBlock("span", {
                    key: 0,
                    class: normalizeClass([unref(ns).e("title"), unref(isBoldTitle)])
                  }, [
                    renderSlot(_ctx.$slots, "title", {}, () => [
                      createTextVNode(toDisplayString(_ctx.title), 1)
                    ])
                  ], 2)) : createCommentVNode("v-if", true),
                  _ctx.$slots.default || _ctx.description ? (openBlock(), createElementBlock("p", {
                    key: 1,
                    class: normalizeClass(unref(ns).e("description"))
                  }, [
                    renderSlot(_ctx.$slots, "default", {}, () => [
                      createTextVNode(toDisplayString(_ctx.description), 1)
                    ])
                  ], 2)) : createCommentVNode("v-if", true),
                  _ctx.closable ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
                    _ctx.closeText ? (openBlock(), createElementBlock("div", {
                      key: 0,
                      class: normalizeClass([unref(ns).e("close-btn"), unref(ns).is("customed")]),
                      onClick: close2
                    }, toDisplayString(_ctx.closeText), 3)) : (openBlock(), createBlock(unref(ElIcon), {
                      key: 1,
                      class: normalizeClass(unref(ns).e("close-btn")),
                      onClick: close2
                    }, {
                      default: withCtx(() => [
                        createVNode(unref(Close))
                      ]),
                      _: 1
                    }, 8, ["class"]))
                  ], 64)) : createCommentVNode("v-if", true)
                ], 2)
              ], 2), [
                [vShow, visible.value]
              ])
            ]),
            _: 3
          }, 8, ["name"]);
        };
      }
    });
    var Alert = /* @__PURE__ */ _export_sfc$1(_sfc_main$2l, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/alert/src/alert.vue"]]);
    const ElAlert = withInstall(Alert);
    const formContextKey = Symbol("formContextKey");
    const formItemContextKey = Symbol("formItemContextKey");
    const useFormSize = (fallback, ignore = {}) => {
      const emptyRef = ref(void 0);
      const size2 = ignore.prop ? emptyRef : useProp("size");
      const globalConfig2 = ignore.global ? emptyRef : useGlobalSize();
      const form = ignore.form ? { size: void 0 } : inject(formContextKey, void 0);
      const formItem = ignore.formItem ? { size: void 0 } : inject(formItemContextKey, void 0);
      return computed(() => size2.value || unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig2.value || "");
    };
    const useFormDisabled = (fallback) => {
      const disabled = useProp("disabled");
      const form = inject(formContextKey, void 0);
      return computed(() => disabled.value || unref(fallback) || (form == null ? void 0 : form.disabled) || false);
    };
    const useFormItem = () => {
      const form = inject(formContextKey, void 0);
      const formItem = inject(formItemContextKey, void 0);
      return {
        form,
        formItem
      };
    };
    const useFormItemInputId = (props, {
      formItemContext,
      disableIdGeneration,
      disableIdManagement
    }) => {
      if (!disableIdGeneration) {
        disableIdGeneration = ref(false);
      }
      if (!disableIdManagement) {
        disableIdManagement = ref(false);
      }
      const inputId = ref();
      let idUnwatch = void 0;
      const isLabeledByFormItem = computed(() => {
        var _a2;
        return !!(!props.label && formItemContext && formItemContext.inputIds && ((_a2 = formItemContext.inputIds) == null ? void 0 : _a2.length) <= 1);
      });
      onMounted(() => {
        idUnwatch = watch([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) {
              inputId.value && formItemContext.removeInputId(inputId.value);
              if (!(disableIdManagement == null ? void 0 : disableIdManagement.value) && !disableIdGeneration2 && newId) {
                formItemContext.addInputId(newId);
              }
            }
            inputId.value = newId;
          }
        }, { immediate: true });
      });
      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: [Object, Boolean]
      }
    });
    const formEmits = {
      validate: (prop, isValid, message2) => (isArray$3(prop) || isString$1(prop)) && isBoolean(isValid) && isString$1(message2)
    };
    function useFormLabelWidth() {
      const potentialLabelWidthArr = ref([]);
      const autoLabelWidth = computed(() => {
        if (!potentialLabelWidthArr.value.length)
          return "0";
        const max2 = Math.max(...potentialLabelWidthArr.value);
        return max2 ? `${max2}px` : "";
      });
      function getLabelWidthIndex(width) {
        const index2 = potentialLabelWidthArr.value.indexOf(width);
        if (index2 === -1 && autoLabelWidth.value === "0")
          ;
        return index2;
      }
      function registerLabelWidth(val, oldVal) {
        if (val && oldVal) {
          const index2 = getLabelWidthIndex(oldVal);
          potentialLabelWidthArr.value.splice(index2, 1, val);
        } else if (val) {
          potentialLabelWidthArr.value.push(val);
        }
      }
      function deregisterLabelWidth(val) {
        const index2 = getLabelWidthIndex(val);
        if (index2 > -1) {
          potentialLabelWidthArr.value.splice(index2, 1);
        }
      }
      return {
        autoLabelWidth,
        registerLabelWidth,
        deregisterLabelWidth
      };
    }
    const filterFields = (fields, props) => {
      const normalized = castArray$1(props);
      return normalized.length > 0 ? fields.filter((field) => field.prop && normalized.includes(field.prop)) : fields;
    };
    const COMPONENT_NAME$m = "ElForm";
    const __default__$1A = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$m
    });
    const _sfc_main$2k = /* @__PURE__ */ defineComponent({
      ...__default__$1A,
      props: formProps,
      emits: formEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const fields = [];
        const formSize = useFormSize();
        const ns = useNamespace("form");
        const formClasses = computed(() => {
          const { labelPosition, inline } = props;
          return [
            ns.b(),
            ns.m(formSize.value || "default"),
            {
              [ns.m(`label-${labelPosition}`)]: labelPosition,
              [ns.m("inline")]: inline
            }
          ];
        });
        const addField = (field) => {
          fields.push(field);
        };
        const removeField = (field) => {
          if (field.prop) {
            fields.splice(fields.indexOf(field), 1);
          }
        };
        const resetFields = (properties = []) => {
          if (!props.model) {
            return;
          }
          filterFields(fields, properties).forEach((field) => field.resetField());
        };
        const clearValidate = (props2 = []) => {
          filterFields(fields, props2).forEach((field) => field.clearValidate());
        };
        const isValidatable = computed(() => {
          const hasModel = !!props.model;
          return hasModel;
        });
        const obtainValidateFields = (props2) => {
          if (fields.length === 0)
            return [];
          const filteredFields = filterFields(fields, props2);
          if (!filteredFields.length) {
            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("");
            } catch (fields3) {
              validationErrors = {
                ...validationErrors,
                ...fields3
              };
            }
          }
          if (Object.keys(validationErrors).length === 0)
            return true;
          return Promise.reject(validationErrors);
        };
        const validateField = async (modelProps = [], callback) => {
          const shouldThrow = !isFunction$2(callback);
          try {
            const result = await doValidateField(modelProps);
            if (result === true) {
              callback == null ? void 0 : callback(result);
            }
            return result;
          } catch (e) {
            if (e instanceof Error)
              throw e;
            const invalidFields = e;
            if (props.scrollToError) {
              scrollToField(Object.keys(invalidFields)[0]);
            }
            callback == null ? void 0 : callback(false, invalidFields);
            return shouldThrow && Promise.reject(invalidFields);
          }
        };
        const scrollToField = (prop) => {
          var _a2;
          const field = filterFields(fields, prop)[0];
          if (field) {
            (_a2 = field.$el) == null ? void 0 : _a2.scrollIntoView(props.scrollIntoViewOptions);
          }
        };
        watch(() => props.rules, () => {
          if (props.validateOnRuleChange) {
            validate().catch((err) => debugWarn());
          }
        }, { deep: true });
        provide(formContextKey, reactive({
          ...toRefs(props),
          emit: emit2,
          resetFields,
          clearValidate,
          validateField,
          addField,
          removeField,
          ...useFormLabelWidth()
        }));
        expose({
          validate,
          validateField,
          resetFields,
          clearValidate,
          scrollToField
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("form", {
            class: normalizeClass(unref(formClasses))
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Form = /* @__PURE__ */ _export_sfc$1(_sfc_main$2k, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/form/src/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(o2) {
      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o3) {
        return o3.__proto__ || Object.getPrototypeOf(o3);
      };
      return _getPrototypeOf(o2);
    }
    function _setPrototypeOf(o2, p2) {
      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o3, p3) {
        o3.__proto__ = p3;
        return o3;
      };
      return _setPrototypeOf(o2, p2);
    }
    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 a2 = [null];
          a2.push.apply(a2, args2);
          var Constructor = Function.bind.apply(Parent2, a2);
          var instance = new Constructor();
          if (Class2)
            _setPrototypeOf(instance, Class2.prototype);
          return instance;
        };
      }
      return _construct.apply(null, arguments);
    }
    function _isNativeFunction(fn2) {
      return Function.toString.call(fn2).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 warning2(type2, errors) {
        if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
          if (errors.every(function(e) {
            return typeof e === "string";
          })) {
            console.warn(type2, 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(x2) {
          if (x2 === "%%") {
            return "%";
          }
          if (i >= len) {
            return x2;
          }
          switch (x2) {
            case "%s":
              return String(args[i++]);
            case "%d":
              return Number(args[i++]);
            case "%j":
              try {
                return JSON.stringify(args[i++]);
              } catch (_2) {
                return "[Circular]";
              }
              break;
            default:
              return x2;
          }
        });
        return str;
      }
      return template;
    }
    function isNativeStringType(type2) {
      return type2 === "string" || type2 === "url" || type2 === "hex" || type2 === "email" || type2 === "date" || type2 === "pattern";
    }
    function isEmptyValue(value, type2) {
      if (value === void 0 || value === null) {
        return true;
      }
      if (type2 === "array" && Array.isArray(value) && !value.length) {
        return true;
      }
      if (isNativeStringType(type2) && typeof value === "string" && !value) {
        return true;
      }
      return false;
    }
    function asyncParallelArray(arr, func, callback) {
      var results = [];
      var total2 = 0;
      var arrLength = arr.length;
      function count(errors) {
        results.push.apply(results, errors || []);
        total2++;
        if (total2 === arrLength) {
          callback(results);
        }
      }
      arr.forEach(function(a2) {
        func(a2, count);
      });
    }
    function asyncSerialArray(arr, func, callback) {
      var index2 = 0;
      var arrLength = arr.length;
      function next(errors) {
        if (errors && errors.length) {
          callback(errors);
          return;
        }
        var original = index2;
        index2 = index2 + 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(resolve2, reject) {
          var next = function next2(errors) {
            callback(errors);
            return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve2(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 total2 = 0;
      var results = [];
      var pending = new Promise(function(resolve2, reject) {
        var next = function next2(errors) {
          results.push.apply(results, errors);
          total2++;
          if (total2 === objArrLength) {
            callback(results);
            return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve2(source);
          }
        };
        if (!objArrKeys.length) {
          callback(results);
          resolve2(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 v2 = value;
      for (var i = 0; i < path.length; i++) {
        if (v2 == void 0) {
          return v2;
        }
        v2 = v2[path[i]];
      }
      return v2;
    }
    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 s2 in source) {
          if (source.hasOwnProperty(s2)) {
            var value = source[s2];
            if (typeof value === "object" && typeof target[s2] === "object") {
              target[s2] = _extends({}, target[s2], value);
            } else {
              target[s2] = value;
            }
          }
        }
      }
      return target;
    }
    var required$1 = function required2(rule, value, source, errors, options, type2) {
      if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type2 || 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 b2 = function b3(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("(?:" + b2(options) + v4 + b2(options) + ")|(?:" + b2(options) + v6 + b2(options) + ")", "g");
      };
      ip.v4 = function(options) {
        return options && options.exact ? v4exact : new RegExp("" + b2(options) + v4 + b2(options), "g");
      };
      ip.v6 = function(options) {
        return options && options.exact ? v6exact : new RegExp("" + b2(options) + v6 + b2(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 = {
      // http://emailregex.com/
      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,}))$/,
      // url: new RegExp(
      //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
      //   'i',
      // ),
      hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
    };
    var types = {
      integer: function integer2(value) {
        return types.number(value) && parseInt(value, 10) === value;
      },
      "float": function float(value) {
        return types.number(value) && !types.integer(value);
      },
      array: function array2(value) {
        return Array.isArray(value);
      },
      regexp: function regexp2(value) {
        if (value instanceof RegExp) {
          return true;
        }
        try {
          return !!new RegExp(value);
        } catch (e) {
          return false;
        }
      },
      date: function date2(value) {
        return typeof value.getTime === "function" && typeof value.getMonth === "function" && typeof value.getYear === "function" && !isNaN(value.getTime());
      },
      number: function number2(value) {
        if (isNaN(value)) {
          return false;
        }
        return typeof value === "number";
      },
      object: function object2(value) {
        return typeof value === "object" && !types.array(value);
      },
      method: function method2(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 type2(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 min2 = typeof rule.min === "number";
      var max2 = typeof rule.max === "number";
      var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
      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.replace(spRegexp, "_").length;
      }
      if (len) {
        if (val !== rule.len) {
          errors.push(format(options.messages[key].len, rule.fullField, rule.len));
        }
      } else if (min2 && !max2 && val < rule.min) {
        errors.push(format(options.messages[key].min, rule.fullField, rule.min));
      } else if (max2 && !min2 && val > rule.max) {
        errors.push(format(options.messages[key].max, rule.fullField, rule.max));
      } else if (min2 && max2 && (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 enumerable2(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 pattern2(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 method = function method2(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 number = function number2(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 regexp = function regexp2(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 integer = function integer2(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 array = function array2(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 object = function object2(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 enumerable = function enumerable2(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 pattern = function pattern2(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 date$1 = function date2(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 required = function required2(rule, value, callback, source, options) {
      var errors = [];
      var type2 = Array.isArray(value) ? "array" : typeof value;
      rules.required(rule, value, source, errors, options, type2);
      callback(errors);
    };
    var type = function type2(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,
      number,
      "boolean": _boolean,
      regexp,
      integer,
      "float": floatFn,
      array,
      object,
      "enum": enumerable,
      pattern,
      date: date$1,
      url: type,
      hex: type,
      email: type,
      required,
      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 clone2() {
          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_, o2, oc) {
        var _this2 = this;
        if (o2 === void 0) {
          o2 = {};
        }
        if (oc === void 0) {
          oc = function oc2() {
          };
        }
        var source = source_;
        var options = o2;
        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 add2(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++) {
            add2(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 keys2 = options.keys || Object.keys(this.rules);
        keys2.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 getType2(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 keys2 = Object.keys(rule);
        var messageIndex = keys2.indexOf("message");
        if (messageIndex !== -1) {
          keys2.splice(messageIndex, 1);
        }
        if (keys2.length === 1 && keys2[0] === "required") {
          return validators.required;
        }
        return validators[this.getType(rule)] || void 0;
      };
      return Schema2;
    }();
    Schema.register = function register(type2, validator) {
      if (typeof validator !== "function") {
        throw new Error("Cannot register a validator by type, validator is not a function");
      }
      validators[type2] = 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: ""
      },
      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: [String, Boolean],
        default: ""
      },
      showMessage: {
        type: Boolean,
        default: true
      },
      size: {
        type: String,
        values: componentSizes
      }
    });
    const COMPONENT_NAME$l = "ElLabelWrap";
    var FormLabelWrap = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$l,
      props: {
        isAutoWidth: Boolean,
        updateAll: Boolean
      },
      setup(props, {
        slots
      }) {
        const formContext = inject(formContextKey, void 0);
        const formItemContext = inject(formItemContextKey);
        if (!formItemContext)
          throwError(COMPONENT_NAME$l, "usage: <el-form-item><label-wrap /></el-form-item>");
        const ns = useNamespace("form");
        const el = ref();
        const computedWidth = ref(0);
        const getLabelWidth = () => {
          var _a2;
          if ((_a2 = el.value) == null ? void 0 : _a2.firstElementChild) {
            const width = window.getComputedStyle(el.value.firstElementChild).width;
            return Math.ceil(Number.parseFloat(width));
          } else {
            return 0;
          }
        };
        const updateLabelWidth = (action = "update") => {
          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");
        onMounted(() => {
          updateLabelWidthFn();
        });
        onBeforeUnmount(() => {
          updateLabelWidth("remove");
        });
        onUpdated(() => updateLabelWidthFn());
        watch(computedWidth, (val, oldVal) => {
          if (props.updateAll) {
            formContext == null ? void 0 : formContext.registerLabelWidth(val, oldVal);
          }
        });
        useResizeObserver(computed(() => {
          var _a2, _b;
          return (_b = (_a2 = el.value) == null ? void 0 : _a2.firstElementChild) != null ? _b : null;
        }), updateLabelWidthFn);
        return () => {
          var _a2, _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 marginPosition = formContext.labelPosition === "left" ? "marginRight" : "marginLeft";
              if (marginWidth) {
                style[marginPosition] = `${marginWidth}px`;
              }
            }
            return createVNode("div", {
              "ref": el,
              "class": [ns.be("item", "label-wrap")],
              "style": style
            }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]);
          } else {
            return createVNode(Fragment, {
              "ref": el
            }, [(_b = slots.default) == null ? void 0 : _b.call(slots)]);
          }
        };
      }
    });
    const _hoisted_1$15 = ["role", "aria-labelledby"];
    const __default__$1z = /* @__PURE__ */ defineComponent({
      name: "ElFormItem"
    });
    const _sfc_main$2j = /* @__PURE__ */ defineComponent({
      ...__default__$1z,
      props: formItemProps,
      setup(__props, { expose }) {
        const props = __props;
        const slots = useSlots();
        const formContext = inject(formContextKey, void 0);
        const parentFormItemContext = inject(formItemContextKey, void 0);
        const _size = useFormSize(void 0, { formItem: false });
        const ns = useNamespace("form-item");
        const labelId = useId().value;
        const inputIds = ref([]);
        const validateState = ref("");
        const validateStateDebounced = refDebounced(validateState, 100);
        const validateMessage = ref("");
        const formItemRef = ref();
        let initialValue = void 0;
        let isResettingField = false;
        const labelStyle = computed(() => {
          if ((formContext == null ? void 0 : formContext.labelPosition) === "top") {
            return {};
          }
          const labelWidth = addUnit(props.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
          if (labelWidth)
            return { width: labelWidth };
          return {};
        });
        const contentStyle = computed(() => {
          if ((formContext == null ? void 0 : formContext.labelPosition) === "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 = 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 }
        ]);
        const _inlineMessage = computed(() => isBoolean(props.inlineMessage) ? props.inlineMessage : (formContext == null ? void 0 : formContext.inlineMessage) || false);
        const validateClasses = computed(() => [
          ns.e("error"),
          { [ns.em("error", "inline")]: _inlineMessage.value }
        ]);
        const propString = computed(() => {
          if (!props.prop)
            return "";
          return isString$1(props.prop) ? props.prop : props.prop.join(".");
        });
        const hasLabel = computed(() => {
          return !!(props.label || slots.label);
        });
        const labelFor = computed(() => {
          return props.for || (inputIds.value.length === 1 ? inputIds.value[0] : void 0);
        });
        const isGroup = computed(() => {
          return !labelFor.value && hasLabel.value;
        });
        const isNested = !!parentFormItemContext;
        const fieldValue = computed(() => {
          const model = formContext == null ? void 0 : formContext.model;
          if (!model || !props.prop) {
            return;
          }
          return getProp(model, props.prop).value;
        });
        const normalizedRules = computed(() => {
          const { required: required2 } = props;
          const rules2 = [];
          if (props.rules) {
            rules2.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) {
              rules2.push(...castArray$1(_rules));
            }
          }
          if (required2 !== void 0) {
            const requiredRules = rules2.map((rule, i) => [rule, i]).filter(([rule]) => Object.keys(rule).includes("required"));
            if (requiredRules.length > 0) {
              for (const [rule, i] of requiredRules) {
                if (rule.required === required2)
                  continue;
                rules2[i] = { ...rule, required: required2 };
              }
            } else {
              rules2.push({ required: required2 });
            }
          }
          return rules2;
        });
        const validateEnabled = computed(() => normalizedRules.value.length > 0);
        const getFilteredRule = (trigger2) => {
          const rules2 = normalizedRules.value;
          return rules2.filter((rule) => {
            if (!rule.trigger || !trigger2)
              return true;
            if (Array.isArray(rule.trigger)) {
              return rule.trigger.includes(trigger2);
            } else {
              return rule.trigger === trigger2;
            }
          }).map(({ trigger: trigger22, ...rule }) => rule);
        };
        const isRequired = computed(() => normalizedRules.value.some((rule) => rule.required));
        const shouldShowError = computed(() => {
          var _a2;
          return validateStateDebounced.value === "error" && props.showMessage && ((_a2 = formContext == null ? void 0 : formContext.showMessage) != null ? _a2 : true);
        });
        const currentLabel = computed(() => `${props.label || ""}${(formContext == null ? void 0 : formContext.labelSuffix) || ""}`);
        const setValidationState = (state) => {
          validateState.value = state;
        };
        const onValidationFailed = (error) => {
          var _a2, _b;
          const { errors, fields } = error;
          if (!errors || !fields) {
            console.error(error);
          }
          setValidationState("error");
          validateMessage.value = errors ? (_b = (_a2 = errors == null ? void 0 : errors[0]) == null ? void 0 : _a2.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 (rules2) => {
          const modelName = propString.value;
          const validator = new Schema({
            [modelName]: rules2
          });
          return validator.validate({ [modelName]: fieldValue.value }, { firstFields: true }).then(() => {
            onValidationSucceeded();
            return true;
          }).catch((err) => {
            onValidationFailed(err);
            return Promise.reject(err);
          });
        };
        const validate = async (trigger2, callback) => {
          if (isResettingField || !props.prop) {
            return false;
          }
          const hasCallback = isFunction$2(callback);
          if (!validateEnabled.value) {
            callback == null ? void 0 : callback(false);
            return false;
          }
          const rules2 = getFilteredRule(trigger2);
          if (rules2.length === 0) {
            callback == null ? void 0 : callback(true);
            return true;
          }
          setValidationState("validating");
          return doValidate(rules2).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 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);
        };
        watch(() => props.error, (val) => {
          validateMessage.value = val || "";
          setValidationState(val ? "error" : "");
        }, { immediate: true });
        watch(() => props.validateStatus, (val) => setValidationState(val || ""));
        const context = reactive({
          ...toRefs(props),
          $el: formItemRef,
          size: _size,
          validateState,
          labelId,
          inputIds,
          isGroup,
          hasLabel,
          addInputId,
          removeInputId,
          resetField,
          clearValidate,
          validate
        });
        provide(formItemContextKey, context);
        onMounted(() => {
          if (props.prop) {
            formContext == null ? void 0 : formContext.addField(context);
            initialValue = clone(fieldValue.value);
          }
        });
        onBeforeUnmount(() => {
          formContext == null ? void 0 : formContext.removeField(context);
        });
        expose({
          size: _size,
          validateMessage,
          validateState,
          validate,
          clearValidate,
          resetField
        });
        return (_ctx, _cache) => {
          var _a2;
          return openBlock(), createElementBlock("div", {
            ref_key: "formItemRef",
            ref: formItemRef,
            class: normalizeClass(unref(formItemClasses)),
            role: unref(isGroup) ? "group" : void 0,
            "aria-labelledby": unref(isGroup) ? unref(labelId) : void 0
          }, [
            createVNode(unref(FormLabelWrap), {
              "is-auto-width": unref(labelStyle).width === "auto",
              "update-all": ((_a2 = unref(formContext)) == null ? void 0 : _a2.labelWidth) === "auto"
            }, {
              default: withCtx(() => [
                unref(hasLabel) ? (openBlock(), createBlock(resolveDynamicComponent(unref(labelFor) ? "label" : "div"), {
                  key: 0,
                  id: unref(labelId),
                  for: unref(labelFor),
                  class: normalizeClass(unref(ns).e("label")),
                  style: normalizeStyle(unref(labelStyle))
                }, {
                  default: withCtx(() => [
                    renderSlot(_ctx.$slots, "label", { label: unref(currentLabel) }, () => [
                      createTextVNode(toDisplayString(unref(currentLabel)), 1)
                    ])
                  ]),
                  _: 3
                }, 8, ["id", "for", "class", "style"])) : createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["is-auto-width", "update-all"]),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("content")),
              style: normalizeStyle(unref(contentStyle))
            }, [
              renderSlot(_ctx.$slots, "default"),
              createVNode(TransitionGroup, {
                name: `${unref(ns).namespace.value}-zoom-in-top`
              }, {
                default: withCtx(() => [
                  unref(shouldShowError) ? renderSlot(_ctx.$slots, "error", {
                    key: 0,
                    error: validateMessage.value
                  }, () => [
                    createBaseVNode("div", {
                      class: normalizeClass(unref(validateClasses))
                    }, toDisplayString(validateMessage.value), 3)
                  ]) : createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 8, ["name"])
            ], 6)
          ], 10, _hoisted_1$15);
        };
      }
    });
    var FormItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$2j, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/form/src/form-item.vue"]]);
    const ElForm = withInstall(Form, {
      FormItem
    });
    const ElFormItem = withNoopInstall(FormItem);
    let hiddenTextarea = void 0;
    const HIDDEN_STYLE = `
  height:0 !important;
  visibility:hidden !important;
  ${isFirefox() ? "" : "overflow:hidden !important;"}
  position:absolute !important;
  z-index:-1000 !important;
  top:0 !important;
  right:0 !important;
`;
    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"
    ];
    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)}`).join(";");
      return { contextStyle, paddingSize, borderSize, boxSizing };
    }
    function calcTextareaHeight(targetElement, minRows = 1, maxRows) {
      var _a2;
      if (!hiddenTextarea) {
        hiddenTextarea = document.createElement("textarea");
        document.body.appendChild(hiddenTextarea);
      }
      const { paddingSize, borderSize, boxSizing, contextStyle } = calculateNodeStyling(targetElement);
      hiddenTextarea.setAttribute("style", `${contextStyle};${HIDDEN_STYLE}`);
      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`;
      (_a2 = hiddenTextarea.parentNode) == null ? void 0 : _a2.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: ""
      },
      type: {
        type: String,
        default: "text"
      },
      resize: {
        type: String,
        values: ["none", "both", "horizontal", "vertical"]
      },
      autosize: {
        type: definePropType([Boolean, Object]),
        default: false
      },
      autocomplete: {
        type: String,
        default: "off"
      },
      formatter: {
        type: Function
      },
      parser: {
        type: Function
      },
      placeholder: {
        type: String
      },
      form: {
        type: String
      },
      readonly: {
        type: Boolean,
        default: false
      },
      clearable: {
        type: Boolean,
        default: false
      },
      showPassword: {
        type: Boolean,
        default: false
      },
      showWordLimit: {
        type: Boolean,
        default: false
      },
      suffixIcon: {
        type: iconPropType
      },
      prefixIcon: {
        type: iconPropType
      },
      containerRole: {
        type: String,
        default: void 0
      },
      label: {
        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: {
        type: Boolean,
        default: false
      }
    });
    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 _hoisted_1$14 = ["role"];
    const _hoisted_2$I = ["id", "type", "disabled", "formatter", "parser", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder", "form", "autofocus"];
    const _hoisted_3$k = ["id", "tabindex", "disabled", "readonly", "autocomplete", "aria-label", "placeholder", "form", "autofocus"];
    const __default__$1y = /* @__PURE__ */ defineComponent({
      name: "ElInput",
      inheritAttrs: false
    });
    const _sfc_main$2i = /* @__PURE__ */ defineComponent({
      ...__default__$1y,
      props: inputProps,
      emits: inputEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const rawAttrs = useAttrs$1();
        const slots = useSlots();
        const containerAttrs = computed(() => {
          const comboBoxAttrs = {};
          if (props.containerRole === "combobox") {
            comboBoxAttrs["aria-haspopup"] = rawAttrs["aria-haspopup"];
            comboBoxAttrs["aria-owns"] = rawAttrs["aria-owns"];
            comboBoxAttrs["aria-expanded"] = rawAttrs["aria-expanded"];
          }
          return comboBoxAttrs;
        });
        const containerKls = 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.bm("group", "append")]: slots.append,
            [nsInput.bm("group", "prepend")]: slots.prepend,
            [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
          },
          rawAttrs.class
        ]);
        const wrapperKls = computed(() => [
          nsInput.e("wrapper"),
          nsInput.is("focus", isFocused.value)
        ]);
        const attrs = useAttrs({
          excludeKeys: computed(() => {
            return Object.keys(containerAttrs.value);
          })
        });
        const { form, formItem } = useFormItem();
        const { inputId } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const inputSize = useFormSize();
        const inputDisabled = useFormDisabled();
        const nsInput = useNamespace("input");
        const nsTextarea = useNamespace("textarea");
        const input = shallowRef();
        const textarea = shallowRef();
        const hovering = ref(false);
        const isComposing = ref(false);
        const passwordVisible = ref(false);
        const countStyle = ref();
        const textareaCalcStyle = shallowRef(props.inputStyle);
        const _ref = computed(() => input.value || textarea.value);
        const { wrapperRef, isFocused, handleFocus, handleBlur } = useFocusController(_ref, {
          afterBlur() {
            var _a2;
            if (props.validateEvent) {
              (_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "blur").catch((err) => debugWarn());
            }
          }
        });
        const needStatusIcon = computed(() => {
          var _a2;
          return (_a2 = form == null ? void 0 : form.statusIcon) != null ? _a2 : false;
        });
        const validateState = computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
        const validateIcon = computed(() => validateState.value && ValidateComponentsMap[validateState.value]);
        const passwordIcon = computed(() => passwordVisible.value ? view_default : hide_default);
        const containerStyle = computed(() => [
          rawAttrs.style,
          props.inputStyle
        ]);
        const textareaStyle = computed(() => [
          props.inputStyle,
          textareaCalcStyle.value,
          { resize: props.resize }
        ]);
        const nativeInputValue = computed(() => isNil(props.modelValue) ? "" : String(props.modelValue));
        const showClear = computed(() => props.clearable && !inputDisabled.value && !props.readonly && !!nativeInputValue.value && (isFocused.value || hovering.value));
        const showPwdVisible = computed(() => props.showPassword && !inputDisabled.value && !props.readonly && !!nativeInputValue.value && (!!nativeInputValue.value || isFocused.value));
        const isWordLimitVisible = computed(() => props.showWordLimit && !!attrs.value.maxlength && (props.type === "text" || props.type === "textarea") && !inputDisabled.value && !props.readonly && !props.showPassword);
        const textLength = computed(() => nativeInputValue.value.length);
        const inputExceed = computed(() => !!isWordLimitVisible.value && textLength.value > Number(attrs.value.maxlength));
        const suffixVisible = computed(() => !!slots.suffix || !!props.suffixIcon || showClear.value || props.showPassword || isWordLimitVisible.value || !!validateState.value && needStatusIcon.value);
        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: type2, autosize } = props;
          if (!isClient || type2 !== "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
            };
            nextTick(() => {
              textarea.value.offsetHeight;
              textareaCalcStyle.value = textareaStyle2;
            });
          } else {
            textareaCalcStyle.value = {
              minHeight: calcTextareaHeight(textarea.value).minHeight
            };
          }
        };
        const createOnceInitResize = (resizeTextarea2) => {
          let isInit = false;
          return () => {
            var _a2;
            if (isInit || !props.autosize)
              return;
            const isElHidden = ((_a2 = textarea.value) == null ? void 0 : _a2.offsetParent) === null;
            if (!isElHidden) {
              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 handleInput = async (event) => {
          recordCursor();
          let { value } = event.target;
          if (props.formatter) {
            value = props.parser ? props.parser(value) : value;
          }
          if (isComposing.value)
            return;
          if (value === nativeInputValue.value) {
            setNativeInputValue();
            return;
          }
          emit2(UPDATE_MODEL_EVENT, value);
          emit2("input", value);
          await nextTick();
          setNativeInputValue();
          setCursor();
        };
        const handleChange = (event) => {
          emit2("change", event.target.value);
        };
        const handleCompositionStart = (event) => {
          emit2("compositionstart", event);
          isComposing.value = true;
        };
        const handleCompositionUpdate = (event) => {
          var _a2;
          emit2("compositionupdate", event);
          const text = (_a2 = event.target) == null ? void 0 : _a2.value;
          const lastCharacter = text[text.length - 1] || "";
          isComposing.value = !isKorean(lastCharacter);
        };
        const handleCompositionEnd = (event) => {
          emit2("compositionend", event);
          if (isComposing.value) {
            isComposing.value = false;
            handleInput(event);
          }
        };
        const handlePasswordVisible = () => {
          passwordVisible.value = !passwordVisible.value;
          focus();
        };
        const focus = async () => {
          var _a2;
          await nextTick();
          (_a2 = _ref.value) == null ? void 0 : _a2.focus();
        };
        const blur = () => {
          var _a2;
          return (_a2 = _ref.value) == null ? void 0 : _a2.blur();
        };
        const handleMouseLeave = (evt) => {
          hovering.value = false;
          emit2("mouseleave", evt);
        };
        const handleMouseEnter = (evt) => {
          hovering.value = true;
          emit2("mouseenter", evt);
        };
        const handleKeydown = (evt) => {
          emit2("keydown", evt);
        };
        const select = () => {
          var _a2;
          (_a2 = _ref.value) == null ? void 0 : _a2.select();
        };
        const clear2 = () => {
          emit2(UPDATE_MODEL_EVENT, "");
          emit2("change", "");
          emit2("clear");
          emit2("input", "");
        };
        watch(() => props.modelValue, () => {
          var _a2;
          nextTick(() => resizeTextarea());
          if (props.validateEvent) {
            (_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn());
          }
        });
        watch(nativeInputValue, () => setNativeInputValue());
        watch(() => props.type, async () => {
          await nextTick();
          setNativeInputValue();
          resizeTextarea();
        });
        onMounted(() => {
          if (!props.formatter && props.parser)
            ;
          setNativeInputValue();
          nextTick(resizeTextarea);
        });
        expose({
          input,
          textarea,
          ref: _ref,
          textareaStyle,
          autosize: toRef(props, "autosize"),
          focus,
          blur,
          select,
          clear: clear2,
          resizeTextarea
        });
        return (_ctx, _cache) => {
          return withDirectives((openBlock(), createElementBlock("div", mergeProps(unref(containerAttrs), {
            class: unref(containerKls),
            style: unref(containerStyle),
            role: _ctx.containerRole,
            onMouseenter: handleMouseEnter,
            onMouseleave: handleMouseLeave
          }), [
            createCommentVNode(" input "),
            _ctx.type !== "textarea" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
              createCommentVNode(" prepend slot "),
              _ctx.$slots.prepend ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(nsInput).be("group", "prepend"))
              }, [
                renderSlot(_ctx.$slots, "prepend")
              ], 2)) : createCommentVNode("v-if", true),
              createBaseVNode("div", {
                ref_key: "wrapperRef",
                ref: wrapperRef,
                class: normalizeClass(unref(wrapperKls))
              }, [
                createCommentVNode(" prefix slot "),
                _ctx.$slots.prefix || _ctx.prefixIcon ? (openBlock(), createElementBlock("span", {
                  key: 0,
                  class: normalizeClass(unref(nsInput).e("prefix"))
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass(unref(nsInput).e("prefix-inner"))
                  }, [
                    renderSlot(_ctx.$slots, "prefix"),
                    _ctx.prefixIcon ? (openBlock(), createBlock(unref(ElIcon), {
                      key: 0,
                      class: normalizeClass(unref(nsInput).e("icon"))
                    }, {
                      default: withCtx(() => [
                        (openBlock(), createBlock(resolveDynamicComponent(_ctx.prefixIcon)))
                      ]),
                      _: 1
                    }, 8, ["class"])) : createCommentVNode("v-if", true)
                  ], 2)
                ], 2)) : createCommentVNode("v-if", true),
                createBaseVNode("input", mergeProps({
                  id: unref(inputId),
                  ref_key: "input",
                  ref: input,
                  class: unref(nsInput).e("inner")
                }, unref(attrs), {
                  type: _ctx.showPassword ? passwordVisible.value ? "text" : "password" : _ctx.type,
                  disabled: unref(inputDisabled),
                  formatter: _ctx.formatter,
                  parser: _ctx.parser,
                  readonly: _ctx.readonly,
                  autocomplete: _ctx.autocomplete,
                  tabindex: _ctx.tabindex,
                  "aria-label": _ctx.label,
                  placeholder: _ctx.placeholder,
                  style: _ctx.inputStyle,
                  form: props.form,
                  autofocus: props.autofocus,
                  onCompositionstart: handleCompositionStart,
                  onCompositionupdate: handleCompositionUpdate,
                  onCompositionend: handleCompositionEnd,
                  onInput: handleInput,
                  onFocus: _cache[0] || (_cache[0] = (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
                  onBlur: _cache[1] || (_cache[1] = (...args) => unref(handleBlur) && unref(handleBlur)(...args)),
                  onChange: handleChange,
                  onKeydown: handleKeydown
                }), null, 16, _hoisted_2$I),
                createCommentVNode(" suffix slot "),
                unref(suffixVisible) ? (openBlock(), createElementBlock("span", {
                  key: 1,
                  class: normalizeClass(unref(nsInput).e("suffix"))
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass(unref(nsInput).e("suffix-inner"))
                  }, [
                    !unref(showClear) || !unref(showPwdVisible) || !unref(isWordLimitVisible) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                      renderSlot(_ctx.$slots, "suffix"),
                      _ctx.suffixIcon ? (openBlock(), createBlock(unref(ElIcon), {
                        key: 0,
                        class: normalizeClass(unref(nsInput).e("icon"))
                      }, {
                        default: withCtx(() => [
                          (openBlock(), createBlock(resolveDynamicComponent(_ctx.suffixIcon)))
                        ]),
                        _: 1
                      }, 8, ["class"])) : createCommentVNode("v-if", true)
                    ], 64)) : createCommentVNode("v-if", true),
                    unref(showClear) ? (openBlock(), createBlock(unref(ElIcon), {
                      key: 1,
                      class: normalizeClass([unref(nsInput).e("icon"), unref(nsInput).e("clear")]),
                      onMousedown: withModifiers(unref(NOOP), ["prevent"]),
                      onClick: clear2
                    }, {
                      default: withCtx(() => [
                        createVNode(unref(circle_close_default))
                      ]),
                      _: 1
                    }, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true),
                    unref(showPwdVisible) ? (openBlock(), createBlock(unref(ElIcon), {
                      key: 2,
                      class: normalizeClass([unref(nsInput).e("icon"), unref(nsInput).e("password")]),
                      onClick: handlePasswordVisible
                    }, {
                      default: withCtx(() => [
                        (openBlock(), createBlock(resolveDynamicComponent(unref(passwordIcon))))
                      ]),
                      _: 1
                    }, 8, ["class"])) : createCommentVNode("v-if", true),
                    unref(isWordLimitVisible) ? (openBlock(), createElementBlock("span", {
                      key: 3,
                      class: normalizeClass(unref(nsInput).e("count"))
                    }, [
                      createBaseVNode("span", {
                        class: normalizeClass(unref(nsInput).e("count-inner"))
                      }, toDisplayString(unref(textLength)) + " / " + toDisplayString(unref(attrs).maxlength), 3)
                    ], 2)) : createCommentVNode("v-if", true),
                    unref(validateState) && unref(validateIcon) && unref(needStatusIcon) ? (openBlock(), createBlock(unref(ElIcon), {
                      key: 4,
                      class: normalizeClass([
                        unref(nsInput).e("icon"),
                        unref(nsInput).e("validateIcon"),
                        unref(nsInput).is("loading", unref(validateState) === "validating")
                      ])
                    }, {
                      default: withCtx(() => [
                        (openBlock(), createBlock(resolveDynamicComponent(unref(validateIcon))))
                      ]),
                      _: 1
                    }, 8, ["class"])) : createCommentVNode("v-if", true)
                  ], 2)
                ], 2)) : createCommentVNode("v-if", true)
              ], 2),
              createCommentVNode(" append slot "),
              _ctx.$slots.append ? (openBlock(), createElementBlock("div", {
                key: 1,
                class: normalizeClass(unref(nsInput).be("group", "append"))
              }, [
                renderSlot(_ctx.$slots, "append")
              ], 2)) : createCommentVNode("v-if", true)
            ], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
              createCommentVNode(" textarea "),
              createBaseVNode("textarea", mergeProps({
                id: unref(inputId),
                ref_key: "textarea",
                ref: textarea,
                class: unref(nsTextarea).e("inner")
              }, unref(attrs), {
                tabindex: _ctx.tabindex,
                disabled: unref(inputDisabled),
                readonly: _ctx.readonly,
                autocomplete: _ctx.autocomplete,
                style: unref(textareaStyle),
                "aria-label": _ctx.label,
                placeholder: _ctx.placeholder,
                form: props.form,
                autofocus: props.autofocus,
                onCompositionstart: handleCompositionStart,
                onCompositionupdate: handleCompositionUpdate,
                onCompositionend: handleCompositionEnd,
                onInput: handleInput,
                onFocus: _cache[2] || (_cache[2] = (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
                onBlur: _cache[3] || (_cache[3] = (...args) => unref(handleBlur) && unref(handleBlur)(...args)),
                onChange: handleChange,
                onKeydown: handleKeydown
              }), null, 16, _hoisted_3$k),
              unref(isWordLimitVisible) ? (openBlock(), createElementBlock("span", {
                key: 0,
                style: normalizeStyle(countStyle.value),
                class: normalizeClass(unref(nsInput).e("count"))
              }, toDisplayString(unref(textLength)) + " / " + toDisplayString(unref(attrs).maxlength), 7)) : createCommentVNode("v-if", true)
            ], 64))
          ], 16, _hoisted_1$14)), [
            [vShow, _ctx.type !== "hidden"]
          ]);
        };
      }
    });
    var Input = /* @__PURE__ */ _export_sfc$1(_sfc_main$2i, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/input/src/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: size2,
      bar
    }) => ({
      [bar.size]: size2,
      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$k = "Thumb";
    const _sfc_main$2h = /* @__PURE__ */ defineComponent({
      __name: "thumb",
      props: thumbProps,
      setup(__props) {
        const props = __props;
        const scrollbar = inject(scrollbarContextKey);
        const ns = useNamespace("scrollbar");
        if (!scrollbar)
          throwError(COMPONENT_NAME$k, "can not inject scrollbar context");
        const instance = ref();
        const thumb = ref();
        const thumbState = ref({});
        const visible = ref(false);
        let cursorDown = false;
        let cursorLeave = false;
        let originalOnSelectStart = isClient ? document.onselectstart : null;
        const bar = computed(() => BAR_MAP[props.vertical ? "vertical" : "horizontal"]);
        const thumbStyle = computed(() => renderThumbStyle$1({
          size: props.size,
          move: props.move,
          bar: bar.value
        }));
        const offsetRatio = computed(() => instance.value[bar.value.offset] ** 2 / scrollbar.wrapElement[bar.value.scrollSize] / props.ratio / thumb.value[bar.value.offset]);
        const clickThumbHandler = (e) => {
          var _a2;
          e.stopPropagation();
          if (e.ctrlKey || [1, 2].includes(e.button))
            return;
          (_a2 = window.getSelection()) == null ? void 0 : _a2.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 offset2 = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
          const thumbHalf = thumb.value[bar.value.offset] / 2;
          const thumbPositionPercentage = (offset2 - 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;
          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 offset2 = (instance.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
          const thumbClickPosition = thumb.value[bar.value.offset] - prevPage;
          const thumbPositionPercentage = (offset2 - thumbClickPosition) * 100 * offsetRatio.value / instance.value[bar.value.offset];
          scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize] / 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;
        };
        onBeforeUnmount(() => {
          restoreOnselectstart();
          document.removeEventListener("mouseup", mouseUpDocumentHandler);
        });
        const restoreOnselectstart = () => {
          if (document.onselectstart !== originalOnSelectStart)
            document.onselectstart = originalOnSelectStart;
        };
        useEventListener(toRef(scrollbar, "scrollbarElement"), "mousemove", mouseMoveScrollbarHandler);
        useEventListener(toRef(scrollbar, "scrollbarElement"), "mouseleave", mouseLeaveScrollbarHandler);
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Transition, {
            name: unref(ns).b("fade"),
            persisted: ""
          }, {
            default: withCtx(() => [
              withDirectives(createBaseVNode("div", {
                ref_key: "instance",
                ref: instance,
                class: normalizeClass([unref(ns).e("bar"), unref(ns).is(unref(bar).key)]),
                onMousedown: clickTrackHandler
              }, [
                createBaseVNode("div", {
                  ref_key: "thumb",
                  ref: thumb,
                  class: normalizeClass(unref(ns).e("thumb")),
                  style: normalizeStyle(unref(thumbStyle)),
                  onMousedown: clickThumbHandler
                }, null, 38)
              ], 34), [
                [vShow, _ctx.always || visible.value]
              ])
            ]),
            _: 1
          }, 8, ["name"]);
        };
      }
    });
    var Thumb = /* @__PURE__ */ _export_sfc$1(_sfc_main$2h, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/scrollbar/src/thumb.vue"]]);
    const barProps = buildProps({
      always: {
        type: Boolean,
        default: true
      },
      width: String,
      height: String,
      ratioX: {
        type: Number,
        default: 1
      },
      ratioY: {
        type: Number,
        default: 1
      }
    });
    const _sfc_main$2g = /* @__PURE__ */ defineComponent({
      __name: "bar",
      props: barProps,
      setup(__props, { expose }) {
        const props = __props;
        const moveX = ref(0);
        const moveY = ref(0);
        const handleScroll2 = (wrap) => {
          if (wrap) {
            const offsetHeight = wrap.offsetHeight - GAP;
            const offsetWidth = wrap.offsetWidth - GAP;
            moveY.value = wrap.scrollTop * 100 / offsetHeight * props.ratioY;
            moveX.value = wrap.scrollLeft * 100 / offsetWidth * props.ratioX;
          }
        };
        expose({
          handleScroll: handleScroll2
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock(Fragment, null, [
            createVNode(Thumb, {
              move: moveX.value,
              ratio: _ctx.ratioX,
              size: _ctx.width,
              always: _ctx.always
            }, null, 8, ["move", "ratio", "size", "always"]),
            createVNode(Thumb, {
              move: moveY.value,
              ratio: _ctx.ratioY,
              size: _ctx.height,
              vertical: "",
              always: _ctx.always
            }, null, 8, ["move", "ratio", "size", "always"])
          ], 64);
        };
      }
    });
    var Bar = /* @__PURE__ */ _export_sfc$1(_sfc_main$2g, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/scrollbar/src/bar.vue"]]);
    const scrollbarProps = buildProps({
      height: {
        type: [String, Number],
        default: ""
      },
      maxHeight: {
        type: [String, Number],
        default: ""
      },
      native: {
        type: Boolean,
        default: false
      },
      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
      },
      id: String,
      role: String,
      ariaLabel: String,
      ariaOrientation: {
        type: String,
        values: ["horizontal", "vertical"]
      }
    });
    const scrollbarEmits = {
      scroll: ({
        scrollTop,
        scrollLeft
      }) => [scrollTop, scrollLeft].every(isNumber)
    };
    const COMPONENT_NAME$j = "ElScrollbar";
    const __default__$1x = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$j
    });
    const _sfc_main$2f = /* @__PURE__ */ defineComponent({
      ...__default__$1x,
      props: scrollbarProps,
      emits: scrollbarEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("scrollbar");
        let stopResizeObserver = void 0;
        let stopResizeListener = void 0;
        const scrollbarRef = ref();
        const wrapRef = ref();
        const resizeRef = ref();
        const sizeWidth = ref("0");
        const sizeHeight = ref("0");
        const barRef = ref();
        const ratioY = ref(1);
        const ratioX = ref(1);
        const wrapStyle = 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 = computed(() => {
          return [
            props.wrapClass,
            ns.e("wrap"),
            { [ns.em("wrap", "hidden-default")]: !props.native }
          ];
        });
        const resizeKls = computed(() => {
          return [ns.e("view"), props.viewClass];
        });
        const handleScroll2 = () => {
          var _a2;
          if (wrapRef.value) {
            (_a2 = barRef.value) == null ? void 0 : _a2.handleScroll(wrapRef.value);
            emit2("scroll", {
              scrollTop: wrapRef.value.scrollTop,
              scrollLeft: wrapRef.value.scrollLeft
            });
          }
        };
        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)) {
            return;
          }
          wrapRef.value.scrollTop = value;
        };
        const setScrollLeft = (value) => {
          if (!isNumber(value)) {
            return;
          }
          wrapRef.value.scrollLeft = value;
        };
        const update = () => {
          if (!wrapRef.value)
            return;
          const offsetHeight = wrapRef.value.offsetHeight - GAP;
          const offsetWidth = wrapRef.value.offsetWidth - GAP;
          const originalHeight = offsetHeight ** 2 / wrapRef.value.scrollHeight;
          const originalWidth = offsetWidth ** 2 / wrapRef.value.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` : "";
        };
        watch(() => props.noresize, (noresize) => {
          if (noresize) {
            stopResizeObserver == null ? void 0 : stopResizeObserver();
            stopResizeListener == null ? void 0 : stopResizeListener();
          } else {
            ({ stop: stopResizeObserver } = useResizeObserver(resizeRef, update));
            stopResizeListener = useEventListener("resize", update);
          }
        }, { immediate: true });
        watch(() => [props.maxHeight, props.height], () => {
          if (!props.native)
            nextTick(() => {
              var _a2;
              update();
              if (wrapRef.value) {
                (_a2 = barRef.value) == null ? void 0 : _a2.handleScroll(wrapRef.value);
              }
            });
        });
        provide(scrollbarContextKey, reactive({
          scrollbarElement: scrollbarRef,
          wrapElement: wrapRef
        }));
        onMounted(() => {
          if (!props.native)
            nextTick(() => {
              update();
            });
        });
        onUpdated(() => update());
        expose({
          wrapRef,
          update,
          scrollTo,
          setScrollTop,
          setScrollLeft,
          handleScroll: handleScroll2
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "scrollbarRef",
            ref: scrollbarRef,
            class: normalizeClass(unref(ns).b())
          }, [
            createBaseVNode("div", {
              ref_key: "wrapRef",
              ref: wrapRef,
              class: normalizeClass(unref(wrapKls)),
              style: normalizeStyle(unref(wrapStyle)),
              onScroll: handleScroll2
            }, [
              (openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
                id: _ctx.id,
                ref_key: "resizeRef",
                ref: resizeRef,
                class: normalizeClass(unref(resizeKls)),
                style: normalizeStyle(_ctx.viewStyle),
                role: _ctx.role,
                "aria-label": _ctx.ariaLabel,
                "aria-orientation": _ctx.ariaOrientation
              }, {
                default: withCtx(() => [
                  renderSlot(_ctx.$slots, "default")
                ]),
                _: 3
              }, 8, ["id", "class", "style", "role", "aria-label", "aria-orientation"]))
            ], 38),
            !_ctx.native ? (openBlock(), createBlock(Bar, {
              key: 0,
              ref_key: "barRef",
              ref: barRef,
              height: sizeHeight.value,
              width: sizeWidth.value,
              always: _ctx.always,
              "ratio-x": ratioX.value,
              "ratio-y": ratioY.value
            }, null, 8, ["height", "width", "always", "ratio-x", "ratio-y"])) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var Scrollbar = /* @__PURE__ */ _export_sfc$1(_sfc_main$2f, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/scrollbar/src/scrollbar.vue"]]);
    const ElScrollbar = withInstall(Scrollbar);
    const POPPER_INJECTION_KEY = Symbol("popper");
    const POPPER_CONTENT_INJECTION_KEY = Symbol("popperContent");
    const roleTypes = [
      "dialog",
      "grid",
      "group",
      "listbox",
      "menu",
      "navigation",
      "tooltip",
      "tree"
    ];
    const popperProps = buildProps({
      role: {
        type: String,
        values: roleTypes,
        default: "tooltip"
      }
    });
    const __default__$1w = /* @__PURE__ */ defineComponent({
      name: "ElPopper",
      inheritAttrs: false
    });
    const _sfc_main$2e = /* @__PURE__ */ defineComponent({
      ...__default__$1w,
      props: popperProps,
      setup(__props, { expose }) {
        const props = __props;
        const triggerRef2 = ref();
        const popperInstanceRef = ref();
        const contentRef = ref();
        const referenceRef = ref();
        const role = computed(() => props.role);
        const popperProvides = {
          triggerRef: triggerRef2,
          popperInstanceRef,
          contentRef,
          referenceRef,
          role
        };
        expose(popperProvides);
        provide(POPPER_INJECTION_KEY, popperProvides);
        return (_ctx, _cache) => {
          return renderSlot(_ctx.$slots, "default");
        };
      }
    });
    var Popper = /* @__PURE__ */ _export_sfc$1(_sfc_main$2e, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/popper.vue"]]);
    const popperArrowProps = buildProps({
      arrowOffset: {
        type: Number,
        default: 5
      }
    });
    const __default__$1v = /* @__PURE__ */ defineComponent({
      name: "ElPopperArrow",
      inheritAttrs: false
    });
    const _sfc_main$2d = /* @__PURE__ */ defineComponent({
      ...__default__$1v,
      props: popperArrowProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("popper");
        const { arrowOffset, arrowRef, arrowStyle } = inject(POPPER_CONTENT_INJECTION_KEY, void 0);
        watch(() => props.arrowOffset, (val) => {
          arrowOffset.value = val;
        });
        onBeforeUnmount(() => {
          arrowRef.value = void 0;
        });
        expose({
          arrowRef
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("span", {
            ref_key: "arrowRef",
            ref: arrowRef,
            class: normalizeClass(unref(ns).e("arrow")),
            style: normalizeStyle(unref(arrowStyle)),
            "data-popper-arrow": ""
          }, null, 6);
        };
      }
    });
    var ElPopperArrow = /* @__PURE__ */ _export_sfc$1(_sfc_main$2d, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/arrow.vue"]]);
    const NAME = "ElOnlyChild";
    const OnlyChild = /* @__PURE__ */ defineComponent({
      name: NAME,
      setup(_2, {
        slots,
        attrs
      }) {
        var _a2;
        const forwardRefInjection = inject(FORWARD_REF_INJECTION_KEY);
        const forwardRefDirective = useForwardRefDirective((_a2 = forwardRefInjection == null ? void 0 : forwardRefInjection.setForwardRef) != null ? _a2 : NOOP);
        return () => {
          var _a22;
          const defaultSlot = (_a22 = slots.default) == null ? void 0 : _a22.call(slots, attrs);
          if (!defaultSlot)
            return null;
          if (defaultSlot.length > 1) {
            return null;
          }
          const firstLegitNode = findFirstLegitChild(defaultSlot);
          if (!firstLegitNode) {
            return null;
          }
          return withDirectives(cloneVNode(firstLegitNode, attrs), [[forwardRefDirective]]);
        };
      }
    });
    function findFirstLegitChild(node) {
      if (!node)
        return null;
      const children = node;
      for (const child of children) {
        if (isObject$1(child)) {
          switch (child.type) {
            case Comment:
              continue;
            case Text$1:
            case "svg":
              return wrapTextContent(child);
            case Fragment:
              return findFirstLegitChild(child.children);
            default:
              return child;
          }
        }
        return wrapTextContent(child);
      }
      return null;
    }
    function wrapTextContent(s2) {
      const ns = useNamespace("only-child");
      return createVNode("span", {
        "class": ns.e("content")
      }, [s2]);
    }
    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 __default__$1u = /* @__PURE__ */ defineComponent({
      name: "ElPopperTrigger",
      inheritAttrs: false
    });
    const _sfc_main$2c = /* @__PURE__ */ defineComponent({
      ...__default__$1u,
      props: popperTriggerProps,
      setup(__props, { expose }) {
        const props = __props;
        const { role, triggerRef: triggerRef2 } = inject(POPPER_INJECTION_KEY, void 0);
        useForwardRef(triggerRef2);
        const ariaControls = computed(() => {
          return ariaHaspopup.value ? props.id : void 0;
        });
        const ariaDescribedby = computed(() => {
          if (role && role.value === "tooltip") {
            return props.open && props.id ? props.id : void 0;
          }
          return void 0;
        });
        const ariaHaspopup = computed(() => {
          if (role && role.value !== "tooltip") {
            return role.value;
          }
          return void 0;
        });
        const ariaExpanded = computed(() => {
          return ariaHaspopup.value ? `${props.open}` : void 0;
        });
        let virtualTriggerAriaStopWatch = void 0;
        onMounted(() => {
          watch(() => props.virtualRef, (virtualEl) => {
            if (virtualEl) {
              triggerRef2.value = unrefElement(virtualEl);
            }
          }, {
            immediate: true
          });
          watch(triggerRef2, (el, prevEl) => {
            virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
            virtualTriggerAriaStopWatch = void 0;
            if (isElement$1(el)) {
              [
                "onMouseenter",
                "onMouseleave",
                "onClick",
                "onKeydown",
                "onFocus",
                "onBlur",
                "onContextmenu"
              ].forEach((eventName) => {
                var _a2;
                const handler = props[eventName];
                if (handler) {
                  el.addEventListener(eventName.slice(2).toLowerCase(), handler);
                  (_a2 = prevEl == null ? void 0 : prevEl.removeEventListener) == null ? void 0 : _a2.call(prevEl, eventName.slice(2).toLowerCase(), handler);
                }
              });
              virtualTriggerAriaStopWatch = 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$1(prevEl)) {
              [
                "aria-controls",
                "aria-describedby",
                "aria-haspopup",
                "aria-expanded"
              ].forEach((key) => prevEl.removeAttribute(key));
            }
          }, {
            immediate: true
          });
        });
        onBeforeUnmount(() => {
          virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
          virtualTriggerAriaStopWatch = void 0;
        });
        expose({
          triggerRef: triggerRef2
        });
        return (_ctx, _cache) => {
          return !_ctx.virtualTriggering ? (openBlock(), createBlock(unref(OnlyChild), mergeProps({ key: 0 }, _ctx.$attrs, {
            "aria-controls": unref(ariaControls),
            "aria-describedby": unref(ariaDescribedby),
            "aria-expanded": unref(ariaExpanded),
            "aria-haspopup": unref(ariaHaspopup)
          }), {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 16, ["aria-controls", "aria-describedby", "aria-expanded", "aria-haspopup"])) : createCommentVNode("v-if", true);
        };
      }
    });
    var ElPopperTrigger = /* @__PURE__ */ _export_sfc$1(_sfc_main$2c, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/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 = ref();
    const lastUserFocusTimestamp = ref(0);
    const lastAutomatedFocusTimestamp = 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 && element.focus) {
        const prevFocusedElement = document.activeElement;
        element.focus({ 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 remove2 = (layer) => {
        var _a2, _b;
        stack = removeFromStack(stack, layer);
        (_b = (_a2 = stack[0]) == null ? void 0 : _a2.resume) == null ? void 0 : _b.call(_a2);
      };
      return {
        push,
        remove: remove2
      };
    };
    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 = () => {
      onMounted(() => {
        if (focusReasonUserCount === 0) {
          document.addEventListener("mousedown", notifyFocusReasonPointer);
          document.addEventListener("touchstart", notifyFocusReasonPointer);
          document.addEventListener("keydown", notifyFocusReasonKeydown);
        }
        focusReasonUserCount++;
      });
      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$2b = /* @__PURE__ */ 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: emit2 }) {
        const forwardRef = ref();
        let lastFocusBeforeTrapped;
        let lastFocusAfterTrapped;
        const { focusReason: focusReason2 } = useFocusReason();
        useEscapeKeydown((event) => {
          if (props.trapped && !focusLayer.paused) {
            emit2("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 { key, altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
          const { loop } = props;
          const isTabbing = key === 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: focusReason2.value
                });
                emit2("focusout-prevented", focusoutPreventedEvent);
                if (!focusoutPreventedEvent.defaultPrevented) {
                  e.preventDefault();
                }
              }
            } else {
              if (!shiftKey && currentFocusingEl === last) {
                const focusoutPreventedEvent = createFocusOutPreventedEvent({
                  focusReason: focusReason2.value
                });
                emit2("focusout-prevented", focusoutPreventedEvent);
                if (!focusoutPreventedEvent.defaultPrevented) {
                  e.preventDefault();
                  if (loop)
                    tryFocus(first, true);
                }
              } else if (shiftKey && [first, container].includes(currentFocusingEl)) {
                const focusoutPreventedEvent = createFocusOutPreventedEvent({
                  focusReason: focusReason2.value
                });
                emit2("focusout-prevented", focusoutPreventedEvent);
                if (!focusoutPreventedEvent.defaultPrevented) {
                  e.preventDefault();
                  if (loop)
                    tryFocus(last, true);
                }
              }
            }
          }
        };
        provide(FOCUS_TRAP_INJECTION_KEY, {
          focusTrapRef: forwardRef,
          onKeydown
        });
        watch(() => props.focusTrapEl, (focusTrapEl) => {
          if (focusTrapEl) {
            forwardRef.value = focusTrapEl;
          }
        }, { immediate: true });
        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) => {
          emit2(ON_TRAP_FOCUS_EVT, e);
        };
        const releaseOnFocus = (e) => emit2(ON_RELEASE_FOCUS_EVT, e);
        const onFocusIn = (e) => {
          const trapContainer = 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)
            emit2("focusin", e);
          if (focusLayer.paused)
            return;
          if (props.trapped) {
            if (isFocusedInTrap) {
              lastFocusAfterTrapped = target;
            } else {
              tryFocus(lastFocusAfterTrapped, true);
            }
          }
        };
        const onFocusOut = (e) => {
          const trapContainer = 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: focusReason2.value
                  });
                  emit2("focusout-prevented", focusoutPreventedEvent);
                  if (!focusoutPreventedEvent.defaultPrevented) {
                    tryFocus(lastFocusAfterTrapped, true);
                  }
                }
              }, 0);
            }
          } else {
            const target = e.target;
            const isFocusedInTrap = target && trapContainer.contains(target);
            if (!isFocusedInTrap)
              emit2("focusout", e);
          }
        };
        async function startTrap() {
          await nextTick();
          const trapContainer = 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) {
                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 = unref(forwardRef);
          if (trapContainer) {
            trapContainer.removeEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
            const releasedEvent = new CustomEvent(FOCUS_AFTER_RELEASED, {
              ...FOCUS_AFTER_TRAPPED_OPTS,
              detail: {
                focusReason: focusReason2.value
              }
            });
            trapContainer.addEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
            trapContainer.dispatchEvent(releasedEvent);
            if (!releasedEvent.defaultPrevented && (focusReason2.value == "keyboard" || !isFocusCausedByUserEvent() || trapContainer.contains(document.activeElement))) {
              tryFocus(lastFocusBeforeTrapped != null ? lastFocusBeforeTrapped : document.body);
            }
            trapContainer.removeEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
            focusableStack.remove(focusLayer);
          }
        }
        onMounted(() => {
          if (props.trapped) {
            startTrap();
          }
          watch(() => props.trapped, (trapped) => {
            if (trapped) {
              startTrap();
            } else {
              stopTrap();
            }
          });
        });
        onBeforeUnmount(() => {
          if (props.trapped) {
            stopTrap();
          }
        });
        return {
          onKeydown
        };
      }
    });
    function _sfc_render$v(_ctx, _cache, $props, $setup, $data, $options) {
      return renderSlot(_ctx.$slots, "default", { handleKeydown: _ctx.onKeydown });
    }
    var ElFocusTrap = /* @__PURE__ */ _export_sfc$1(_sfc_main$2b, [["render", _sfc_render$v], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/focus-trap/src/focus-trap.vue"]]);
    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,
      id: String,
      style: {
        type: definePropType([String, Array, Object])
      },
      className: {
        type: definePropType([String, Array, Object])
      },
      effect: {
        type: String,
        default: "dark"
      },
      visible: Boolean,
      enterable: {
        type: Boolean,
        default: true
      },
      pure: Boolean,
      focusOnShow: {
        type: Boolean,
        default: false
      },
      trapping: {
        type: Boolean,
        default: false
      },
      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
      },
      ariaLabel: {
        type: String,
        default: void 0
      },
      virtualTriggering: Boolean,
      zIndex: Number
    });
    const popperContentEmits = {
      mouseenter: (evt) => evt instanceof MouseEvent,
      mouseleave: (evt) => evt instanceof MouseEvent,
      focus: () => true,
      blur: () => true,
      close: () => true
    };
    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: offset2, gpuAcceleration, fallbackPlacements } = options;
      return [
        {
          name: "offset",
          options: {
            offset: [0, offset2 != null ? offset2 : 12]
          }
        },
        {
          name: "preventOverflow",
          options: {
            padding: {
              top: 2,
              bottom: 2,
              left: 5,
              right: 5
            }
          }
        },
        {
          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: triggerRef2, role } = inject(POPPER_INJECTION_KEY, void 0);
      const arrowRef = ref();
      const arrowOffset = ref();
      const eventListenerModifier = computed(() => {
        return {
          name: "eventListeners",
          enabled: !!props.visible
        };
      });
      const arrowModifier = computed(() => {
        var _a2;
        const arrowEl = unref(arrowRef);
        const offset2 = (_a2 = unref(arrowOffset)) != null ? _a2 : DEFAULT_ARROW_OFFSET;
        return {
          name: "arrow",
          enabled: !isUndefined$1(arrowEl),
          options: {
            element: arrowEl,
            padding: offset2
          }
        };
      });
      const options = computed(() => {
        return {
          onFirstUpdate: () => {
            update();
          },
          ...buildPopperOptions(props, [
            unref(arrowModifier),
            unref(eventListenerModifier)
          ])
        };
      });
      const computedReference = computed(() => unwrapMeasurableEl(props.referenceEl) || unref(triggerRef2));
      const { attributes: attributes2, state, styles, update, forceUpdate, instanceRef } = usePopper(computedReference, contentRef, options);
      watch(instanceRef, (instance) => popperInstanceRef.value = instance);
      onMounted(() => {
        watch(() => {
          var _a2;
          return (_a2 = unref(computedReference)) == null ? void 0 : _a2.getBoundingClientRect();
        }, () => {
          update();
        });
      });
      return {
        attributes: attributes2,
        arrowRef,
        contentRef,
        instanceRef,
        state,
        styles,
        role,
        forceUpdate,
        update
      };
    };
    const usePopperContentDOM = (props, {
      attributes: attributes2,
      styles,
      role
    }) => {
      const { nextZIndex } = useZIndex();
      const ns = useNamespace("popper");
      const contentAttrs = computed(() => unref(attributes2).popper);
      const contentZIndex = ref(isNumber(props.zIndex) ? props.zIndex : nextZIndex());
      const contentClass = computed(() => [
        ns.b(),
        ns.is("pure", props.pure),
        ns.is(props.effect),
        props.popperClass
      ]);
      const contentStyle = computed(() => {
        return [
          { zIndex: unref(contentZIndex) },
          unref(styles).popper,
          props.popperStyle || {}
        ];
      });
      const ariaModal = computed(() => role.value === "dialog" ? "false" : void 0);
      const arrowStyle = computed(() => unref(styles).arrow || {});
      const updateZIndex = () => {
        contentZIndex.value = isNumber(props.zIndex) ? props.zIndex : nextZIndex();
      };
      return {
        ariaModal,
        arrowStyle,
        contentAttrs,
        contentClass,
        contentStyle,
        contentZIndex,
        updateZIndex
      };
    };
    const usePopperContentFocusTrap = (props, emit2) => {
      const trapped = ref(false);
      const focusStartRef = ref();
      const onFocusAfterTrapped = () => {
        emit2("focus");
      };
      const onFocusAfterReleased = (event) => {
        var _a2;
        if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) !== "pointer") {
          focusStartRef.value = "first";
          emit2("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;
        emit2("close");
      };
      return {
        focusStartRef,
        trapped,
        onFocusAfterReleased,
        onFocusAfterTrapped,
        onFocusInTrap,
        onFocusoutPrevented,
        onReleaseRequested
      };
    };
    const __default__$1t = /* @__PURE__ */ defineComponent({
      name: "ElPopperContent"
    });
    const _sfc_main$2a = /* @__PURE__ */ defineComponent({
      ...__default__$1t,
      props: popperContentProps,
      emits: popperContentEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const {
          focusStartRef,
          trapped,
          onFocusAfterReleased,
          onFocusAfterTrapped,
          onFocusInTrap,
          onFocusoutPrevented,
          onReleaseRequested
        } = usePopperContentFocusTrap(props, emit2);
        const { attributes: attributes2, arrowRef, contentRef, styles, instanceRef, role, update } = usePopperContent(props);
        const {
          ariaModal,
          arrowStyle,
          contentAttrs,
          contentClass,
          contentStyle,
          updateZIndex
        } = usePopperContentDOM(props, {
          styles,
          attributes: attributes2,
          role
        });
        const formItemContext = inject(formItemContextKey, void 0);
        const arrowOffset = ref();
        provide(POPPER_CONTENT_INJECTION_KEY, {
          arrowStyle,
          arrowRef,
          arrowOffset
        });
        if (formItemContext && (formItemContext.addInputId || formItemContext.removeInputId)) {
          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;
          }
        };
        onMounted(() => {
          watch(() => props.triggerTargetEl, (triggerTargetEl, prevTriggerTargetEl) => {
            triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
            triggerTargetAriaStopWatch = void 0;
            const el = unref(triggerTargetEl || contentRef.value);
            const prevEl = unref(prevTriggerTargetEl || contentRef.value);
            if (isElement$1(el)) {
              triggerTargetAriaStopWatch = 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$1(prevEl)) {
              ["role", "aria-label", "aria-modal", "id"].forEach((key) => {
                prevEl.removeAttribute(key);
              });
            }
          }, { immediate: true });
          watch(() => props.visible, togglePopperAlive, { immediate: true });
        });
        onBeforeUnmount(() => {
          triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
          triggerTargetAriaStopWatch = void 0;
        });
        expose({
          popperContentRef: contentRef,
          popperInstanceRef: instanceRef,
          updatePopper,
          contentStyle
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", mergeProps({
            ref_key: "contentRef",
            ref: contentRef
          }, unref(contentAttrs), {
            style: unref(contentStyle),
            class: unref(contentClass),
            tabindex: "-1",
            onMouseenter: _cache[0] || (_cache[0] = (e) => _ctx.$emit("mouseenter", e)),
            onMouseleave: _cache[1] || (_cache[1] = (e) => _ctx.$emit("mouseleave", e))
          }), [
            createVNode(unref(ElFocusTrap), {
              trapped: unref(trapped),
              "trap-on-focus-in": true,
              "focus-trap-el": unref(contentRef),
              "focus-start-el": unref(focusStartRef),
              onFocusAfterTrapped: unref(onFocusAfterTrapped),
              onFocusAfterReleased: unref(onFocusAfterReleased),
              onFocusin: unref(onFocusInTrap),
              onFocusoutPrevented: unref(onFocusoutPrevented),
              onReleaseRequested: unref(onReleaseRequested)
            }, {
              default: withCtx(() => [
                renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
          ], 16);
        };
      }
    });
    var ElPopperContent = /* @__PURE__ */ _export_sfc$1(_sfc_main$2a, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/content.vue"]]);
    const ElPopper = withInstall(Popper);
    const TOOLTIP_INJECTION_KEY = Symbol("elTooltip");
    const useTooltipContentProps = buildProps({
      ...useDelayedToggleProps,
      ...popperContentProps,
      appendTo: {
        type: definePropType([String, Object])
      },
      content: {
        type: String,
        default: ""
      },
      rawContent: {
        type: Boolean,
        default: false
      },
      persistent: Boolean,
      ariaLabel: String,
      visible: {
        type: definePropType(Boolean),
        default: null
      },
      transition: String,
      teleported: {
        type: Boolean,
        default: true
      },
      disabled: Boolean
    });
    const useTooltipTriggerProps = buildProps({
      ...popperTriggerProps,
      disabled: Boolean,
      trigger: {
        type: definePropType([String, Array]),
        default: "hover"
      },
      triggerKeys: {
        type: definePropType(Array),
        default: () => [EVENT_CODE.enter, EVENT_CODE.space]
      }
    });
    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 = (trigger2, type2) => {
      if (isArray$3(trigger2)) {
        return trigger2.includes(type2);
      }
      return trigger2 === type2;
    };
    const whenTrigger = (trigger2, type2, handler) => {
      return (e) => {
        isTriggerType(unref(trigger2), type2) && handler(e);
      };
    };
    const __default__$1s = /* @__PURE__ */ defineComponent({
      name: "ElTooltipTrigger"
    });
    const _sfc_main$29 = /* @__PURE__ */ defineComponent({
      ...__default__$1s,
      props: useTooltipTriggerProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("tooltip");
        const { controlled, id, open, onOpen, onClose, onToggle } = inject(TOOLTIP_INJECTION_KEY, void 0);
        const triggerRef2 = ref(null);
        const stopWhenControlledOrDisabled = () => {
          if (unref(controlled) || props.disabled) {
            return true;
          }
        };
        const trigger2 = toRef(props, "trigger");
        const onMouseenter = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger2, "hover", onOpen));
        const onMouseleave = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger2, "hover", onClose));
        const onClick = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger2, "click", (e) => {
          if (e.button === 0) {
            onToggle(e);
          }
        }));
        const onFocus = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger2, "focus", onOpen));
        const onBlur = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger2, "focus", onClose));
        const onContextMenu = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger2, "contextmenu", (e) => {
          e.preventDefault();
          onToggle(e);
        }));
        const onKeydown = composeEventHandlers(stopWhenControlledOrDisabled, (e) => {
          const { code } = e;
          if (props.triggerKeys.includes(code)) {
            e.preventDefault();
            onToggle(e);
          }
        });
        expose({
          triggerRef: triggerRef2
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElPopperTrigger), {
            id: unref(id),
            "virtual-ref": _ctx.virtualRef,
            open: unref(open),
            "virtual-triggering": _ctx.virtualTriggering,
            class: normalizeClass(unref(ns).e("trigger")),
            onBlur: unref(onBlur),
            onClick: unref(onClick),
            onContextmenu: unref(onContextMenu),
            onFocus: unref(onFocus),
            onMouseenter: unref(onMouseenter),
            onMouseleave: unref(onMouseleave),
            onKeydown: unref(onKeydown)
          }, {
            default: withCtx(() => [
              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$1(_sfc_main$29, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip/src/trigger.vue"]]);
    const __default__$1r = /* @__PURE__ */ defineComponent({
      name: "ElTooltipContent",
      inheritAttrs: false
    });
    const _sfc_main$28 = /* @__PURE__ */ defineComponent({
      ...__default__$1r,
      props: useTooltipContentProps,
      setup(__props, { expose }) {
        const props = __props;
        const { selector } = usePopperContainerId();
        const ns = useNamespace("tooltip");
        const contentRef = ref(null);
        const destroyed = ref(false);
        const {
          controlled,
          id,
          open,
          trigger: trigger2,
          onClose,
          onOpen,
          onShow,
          onHide,
          onBeforeShow,
          onBeforeHide
        } = inject(TOOLTIP_INJECTION_KEY, void 0);
        const transitionClass = computed(() => {
          return props.transition || `${ns.namespace.value}-fade-in-linear`;
        });
        const persistentRef = computed(() => {
          return props.persistent;
        });
        onBeforeUnmount(() => {
          destroyed.value = true;
        });
        const shouldRender = computed(() => {
          return unref(persistentRef) ? true : unref(open);
        });
        const shouldShow = computed(() => {
          return props.disabled ? false : unref(open);
        });
        const appendTo = computed(() => {
          return props.appendTo || selector.value;
        });
        const contentStyle = computed(() => {
          var _a2;
          return (_a2 = props.style) != null ? _a2 : {};
        });
        const ariaHidden = computed(() => !unref(open));
        const onTransitionLeave = () => {
          onHide();
        };
        const stopWhenControlled = () => {
          if (unref(controlled))
            return true;
        };
        const onContentEnter = composeEventHandlers(stopWhenControlled, () => {
          if (props.enterable && unref(trigger2) === "hover") {
            onOpen();
          }
        });
        const onContentLeave = composeEventHandlers(stopWhenControlled, () => {
          if (unref(trigger2) === "hover") {
            onClose();
          }
        });
        const onBeforeEnter = () => {
          var _a2, _b;
          (_b = (_a2 = contentRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
          onBeforeShow == null ? void 0 : onBeforeShow();
        };
        const onBeforeLeave = () => {
          onBeforeHide == null ? void 0 : onBeforeHide();
        };
        const onAfterShow = () => {
          onShow();
          stopHandle = onClickOutside(computed(() => {
            var _a2;
            return (_a2 = contentRef.value) == null ? void 0 : _a2.popperContentRef;
          }), () => {
            if (unref(controlled))
              return;
            const $trigger = unref(trigger2);
            if ($trigger !== "hover") {
              onClose();
            }
          });
        };
        const onBlur = () => {
          if (!props.virtualTriggering) {
            onClose();
          }
        };
        let stopHandle;
        watch(() => unref(open), (val) => {
          if (!val) {
            stopHandle == null ? void 0 : stopHandle();
          }
        }, {
          flush: "post"
        });
        watch(() => props.content, () => {
          var _a2, _b;
          (_b = (_a2 = contentRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
        });
        expose({
          contentRef
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Teleport, {
            disabled: !_ctx.teleported,
            to: unref(appendTo)
          }, [
            createVNode(Transition, {
              name: unref(transitionClass),
              onAfterLeave: onTransitionLeave,
              onBeforeEnter,
              onAfterEnter: onAfterShow,
              onBeforeLeave
            }, {
              default: withCtx(() => [
                unref(shouldRender) ? withDirectives((openBlock(), createBlock(unref(ElPopperContent), mergeProps({
                  key: 0,
                  id: unref(id),
                  ref_key: "contentRef",
                  ref: contentRef
                }, _ctx.$attrs, {
                  "aria-label": _ctx.ariaLabel,
                  "aria-hidden": unref(ariaHidden),
                  "boundaries-padding": _ctx.boundariesPadding,
                  "fallback-placements": _ctx.fallbackPlacements,
                  "gpu-acceleration": _ctx.gpuAcceleration,
                  offset: _ctx.offset,
                  placement: _ctx.placement,
                  "popper-options": _ctx.popperOptions,
                  strategy: _ctx.strategy,
                  effect: _ctx.effect,
                  enterable: _ctx.enterable,
                  pure: _ctx.pure,
                  "popper-class": _ctx.popperClass,
                  "popper-style": [_ctx.popperStyle, unref(contentStyle)],
                  "reference-el": _ctx.referenceEl,
                  "trigger-target-el": _ctx.triggerTargetEl,
                  visible: unref(shouldShow),
                  "z-index": _ctx.zIndex,
                  onMouseenter: unref(onContentEnter),
                  onMouseleave: unref(onContentLeave),
                  onBlur,
                  onClose: unref(onClose)
                }), {
                  default: withCtx(() => [
                    !destroyed.value ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("v-if", true)
                  ]),
                  _: 3
                }, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "onMouseenter", "onMouseleave", "onClose"])), [
                  [vShow, unref(shouldShow)]
                ]) : createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["name"])
          ], 8, ["disabled", "to"]);
        };
      }
    });
    var ElTooltipContent = /* @__PURE__ */ _export_sfc$1(_sfc_main$28, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip/src/content.vue"]]);
    const _hoisted_1$13 = ["innerHTML"];
    const _hoisted_2$H = { key: 1 };
    const __default__$1q = /* @__PURE__ */ defineComponent({
      name: "ElTooltip"
    });
    const _sfc_main$27 = /* @__PURE__ */ defineComponent({
      ...__default__$1q,
      props: useTooltipProps,
      emits: tooltipEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        usePopperContainer();
        const id = useId();
        const popperRef = ref();
        const contentRef = ref();
        const updatePopper = () => {
          var _a2;
          const popperComponent = unref(popperRef);
          if (popperComponent) {
            (_a2 = popperComponent.popperInstanceRef) == null ? void 0 : _a2.update();
          }
        };
        const open = ref(false);
        const toggleReason = ref();
        const { show, hide, hasUpdateHandler } = useTooltipModelToggle({
          indicator: open,
          toggleReason
        });
        const { onOpen, onClose } = useDelayedToggle({
          showAfter: toRef(props, "showAfter"),
          hideAfter: toRef(props, "hideAfter"),
          autoClose: toRef(props, "autoClose"),
          open: show,
          close: hide
        });
        const controlled = computed(() => isBoolean(props.visible) && !hasUpdateHandler.value);
        provide(TOOLTIP_INJECTION_KEY, {
          controlled,
          id,
          open: readonly(open),
          trigger: toRef(props, "trigger"),
          onOpen: (event) => {
            onOpen(event);
          },
          onClose: (event) => {
            onClose(event);
          },
          onToggle: (event) => {
            if (unref(open)) {
              onClose(event);
            } else {
              onOpen(event);
            }
          },
          onShow: () => {
            emit2("show", toggleReason.value);
          },
          onHide: () => {
            emit2("hide", toggleReason.value);
          },
          onBeforeShow: () => {
            emit2("before-show", toggleReason.value);
          },
          onBeforeHide: () => {
            emit2("before-hide", toggleReason.value);
          },
          updatePopper
        });
        watch(() => props.disabled, (disabled) => {
          if (disabled && open.value) {
            open.value = false;
          }
        });
        const isFocusInsideContent = (event) => {
          var _a2, _b;
          const popperContent = (_b = (_a2 = contentRef.value) == null ? void 0 : _a2.contentRef) == null ? void 0 : _b.popperContentRef;
          const activeElement = (event == null ? void 0 : event.relatedTarget) || document.activeElement;
          return popperContent && popperContent.contains(activeElement);
        };
        onDeactivated(() => open.value && hide());
        expose({
          popperRef,
          contentRef,
          isFocusInsideContent,
          updatePopper,
          onOpen,
          onClose,
          hide
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElPopper), {
            ref_key: "popperRef",
            ref: popperRef,
            role: _ctx.role
          }, {
            default: withCtx(() => [
              createVNode(ElTooltipTrigger, {
                disabled: _ctx.disabled,
                trigger: _ctx.trigger,
                "trigger-keys": _ctx.triggerKeys,
                "virtual-ref": _ctx.virtualRef,
                "virtual-triggering": _ctx.virtualTriggering
              }, {
                default: withCtx(() => [
                  _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
              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": _ctx.popperClass,
                "popper-style": _ctx.popperStyle,
                placement: _ctx.placement,
                "popper-options": _ctx.popperOptions,
                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
              }, {
                default: withCtx(() => [
                  renderSlot(_ctx.$slots, "content", {}, () => [
                    _ctx.rawContent ? (openBlock(), createElementBlock("span", {
                      key: 0,
                      innerHTML: _ctx.content
                    }, null, 8, _hoisted_1$13)) : (openBlock(), createElementBlock("span", _hoisted_2$H, toDisplayString(_ctx.content), 1))
                  ]),
                  _ctx.showArrow ? (openBlock(), createBlock(unref(ElPopperArrow), {
                    key: 0,
                    "arrow-offset": _ctx.arrowOffset
                  }, null, 8, ["arrow-offset"])) : 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", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to"])
            ]),
            _: 3
          }, 8, ["role"]);
        };
      }
    });
    var Tooltip = /* @__PURE__ */ _export_sfc$1(_sfc_main$27, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip/src/tooltip.vue"]]);
    const ElTooltip = withInstall(Tooltip);
    const autocompleteProps = buildProps({
      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: {
        type: String,
        default: ""
      },
      triggerOnFocus: {
        type: Boolean,
        default: true
      },
      selectWhenUnmatched: {
        type: Boolean,
        default: false
      },
      hideLoading: {
        type: Boolean,
        default: false
      },
      label: {
        type: String
      },
      teleported: useTooltipContentProps.teleported,
      highlightFirstItem: {
        type: Boolean,
        default: false
      },
      fitInputWidth: {
        type: Boolean,
        default: false
      },
      clearable: {
        type: Boolean,
        default: false
      },
      disabled: {
        type: Boolean,
        default: false
      },
      name: String
    });
    const autocompleteEmits = {
      [UPDATE_MODEL_EVENT]: (value) => isString$1(value),
      [INPUT_EVENT]: (value) => isString$1(value),
      [CHANGE_EVENT]: (value) => isString$1(value),
      focus: (evt) => evt instanceof FocusEvent,
      blur: (evt) => evt instanceof FocusEvent,
      clear: () => true,
      select: (item) => isObject$1(item)
    };
    const _hoisted_1$12 = ["aria-expanded", "aria-owns"];
    const _hoisted_2$G = { key: 0 };
    const _hoisted_3$j = ["id", "aria-selected", "onClick"];
    const COMPONENT_NAME$i = "ElAutocomplete";
    const __default__$1p = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$i,
      inheritAttrs: false
    });
    const _sfc_main$26 = /* @__PURE__ */ defineComponent({
      ...__default__$1p,
      props: autocompleteProps,
      emits: autocompleteEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const attrs = useAttrs();
        const rawAttrs = useAttrs$1();
        const disabled = useFormDisabled();
        const ns = useNamespace("autocomplete");
        const inputRef = ref();
        const regionRef = ref();
        const popperRef = ref();
        const listboxRef = ref();
        let readonly2 = false;
        let ignoreFocusEvent = false;
        const suggestions = ref([]);
        const highlightedIndex = ref(-1);
        const dropdownWidth = ref("");
        const activated = ref(false);
        const suggestionDisabled = ref(false);
        const loading = ref(false);
        const listboxId = computed(() => ns.b(String(generateId())));
        const styles = computed(() => rawAttrs.style);
        const suggestionVisible = computed(() => {
          const isValidData = suggestions.value.length > 0;
          return (isValidData || loading.value) && activated.value;
        });
        const suggestionLoading = computed(() => !props.hideLoading && loading.value);
        const refInput = 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$3(suggestionList)) {
              suggestions.value = suggestionList;
              highlightedIndex.value = props.highlightFirstItem ? 0 : -1;
            } else {
              throwError(COMPONENT_NAME$i, "autocomplete suggestions must be an array");
            }
          };
          loading.value = true;
          if (isArray$3(props.fetchSuggestions)) {
            cb(props.fetchSuggestions);
          } else {
            const result = await props.fetchSuggestions(queryString, cb);
            if (isArray$3(result))
              cb(result);
          }
        };
        const debouncedGetData = debounce(getData, props.debounce);
        const handleInput = (value) => {
          const valuePresented = !!value;
          emit2(INPUT_EVENT, value);
          emit2(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 _a2;
          if (disabled.value)
            return;
          if (((_a2 = event.target) == null ? void 0 : _a2.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
            activated.value = true;
          }
        };
        const handleChange = (value) => {
          emit2(CHANGE_EVENT, value);
        };
        const handleFocus = (evt) => {
          if (!ignoreFocusEvent) {
            activated.value = true;
            emit2("focus", evt);
            if (props.triggerOnFocus && !readonly2) {
              debouncedGetData(String(props.modelValue));
            }
          } else {
            ignoreFocusEvent = false;
          }
        };
        const handleBlur = (evt) => {
          setTimeout(() => {
            var _a2;
            if ((_a2 = popperRef.value) == null ? void 0 : _a2.isFocusInsideContent()) {
              ignoreFocusEvent = true;
              return;
            }
            activated.value && close2();
            emit2("blur", evt);
          });
        };
        const handleClear = () => {
          activated.value = false;
          emit2(UPDATE_MODEL_EVENT, "");
          emit2("clear");
        };
        const handleKeyEnter = async () => {
          if (suggestionVisible.value && highlightedIndex.value >= 0 && highlightedIndex.value < suggestions.value.length) {
            handleSelect(suggestions.value[highlightedIndex.value]);
          } else if (props.selectWhenUnmatched) {
            emit2("select", { value: props.modelValue });
            suggestions.value = [];
            highlightedIndex.value = -1;
          }
        };
        const handleKeyEscape = (evt) => {
          if (suggestionVisible.value) {
            evt.preventDefault();
            evt.stopPropagation();
            close2();
          }
        };
        const close2 = () => {
          activated.value = false;
        };
        const focus = () => {
          var _a2;
          (_a2 = inputRef.value) == null ? void 0 : _a2.focus();
        };
        const blur = () => {
          var _a2;
          (_a2 = inputRef.value) == null ? void 0 : _a2.blur();
        };
        const handleSelect = async (item) => {
          emit2(INPUT_EVENT, item[props.valueKey]);
          emit2(UPDATE_MODEL_EVENT, item[props.valueKey]);
          emit2("select", item);
          suggestions.value = [];
          highlightedIndex.value = -1;
        };
        const highlight = (index2) => {
          if (!suggestionVisible.value || loading.value)
            return;
          if (index2 < 0) {
            highlightedIndex.value = -1;
            return;
          }
          if (index2 >= suggestions.value.length) {
            index2 = suggestions.value.length - 1;
          }
          const suggestion = regionRef.value.querySelector(`.${ns.be("suggestion", "wrap")}`);
          const suggestionList = suggestion.querySelectorAll(`.${ns.be("suggestion", "list")} li`);
          const highlightItem = suggestionList[index2];
          const scrollTop = suggestion.scrollTop;
          const { offsetTop, scrollHeight } = highlightItem;
          if (offsetTop + scrollHeight > scrollTop + suggestion.clientHeight) {
            suggestion.scrollTop += scrollHeight;
          }
          if (offsetTop < scrollTop) {
            suggestion.scrollTop -= scrollHeight;
          }
          highlightedIndex.value = index2;
          inputRef.value.ref.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
        };
        onClickOutside(listboxRef, () => {
          suggestionVisible.value && close2();
        });
        onMounted(() => {
          inputRef.value.ref.setAttribute("role", "textbox");
          inputRef.value.ref.setAttribute("aria-autocomplete", "list");
          inputRef.value.ref.setAttribute("aria-controls", "id");
          inputRef.value.ref.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
          readonly2 = inputRef.value.ref.hasAttribute("readonly");
        });
        expose({
          highlightedIndex,
          activated,
          loading,
          inputRef,
          popperRef,
          suggestions,
          handleSelect,
          handleKeyEnter,
          focus,
          blur,
          close: close2,
          highlight
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElTooltip), {
            ref_key: "popperRef",
            ref: popperRef,
            visible: unref(suggestionVisible),
            placement: _ctx.placement,
            "fallback-placements": ["bottom-start", "top-start"],
            "popper-class": [unref(ns).e("popper"), _ctx.popperClass],
            teleported: _ctx.teleported,
            "gpu-acceleration": false,
            pure: "",
            "manual-mode": "",
            effect: "light",
            trigger: "click",
            transition: `${unref(ns).namespace.value}-zoom-in-top`,
            persistent: "",
            role: "listbox",
            onBeforeShow: onSuggestionShow,
            onHide
          }, {
            content: withCtx(() => [
              createBaseVNode("div", {
                ref_key: "regionRef",
                ref: regionRef,
                class: normalizeClass([unref(ns).b("suggestion"), unref(ns).is("loading", unref(suggestionLoading))]),
                style: normalizeStyle({
                  [_ctx.fitInputWidth ? "width" : "minWidth"]: dropdownWidth.value,
                  outline: "none"
                }),
                role: "region"
              }, [
                createVNode(unref(ElScrollbar), {
                  id: unref(listboxId),
                  tag: "ul",
                  "wrap-class": unref(ns).be("suggestion", "wrap"),
                  "view-class": unref(ns).be("suggestion", "list"),
                  role: "listbox"
                }, {
                  default: withCtx(() => [
                    unref(suggestionLoading) ? (openBlock(), createElementBlock("li", _hoisted_2$G, [
                      createVNode(unref(ElIcon), {
                        class: normalizeClass(unref(ns).is("loading"))
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(loading_default))
                        ]),
                        _: 1
                      }, 8, ["class"])
                    ])) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(suggestions.value, (item, index2) => {
                      return openBlock(), createElementBlock("li", {
                        id: `${unref(listboxId)}-item-${index2}`,
                        key: index2,
                        class: normalizeClass({ highlighted: highlightedIndex.value === index2 }),
                        role: "option",
                        "aria-selected": highlightedIndex.value === index2,
                        onClick: ($event) => handleSelect(item)
                      }, [
                        renderSlot(_ctx.$slots, "default", { item }, () => [
                          createTextVNode(toDisplayString(item[_ctx.valueKey]), 1)
                        ])
                      ], 10, _hoisted_3$j);
                    }), 128))
                  ]),
                  _: 3
                }, 8, ["id", "wrap-class", "view-class"])
              ], 6)
            ]),
            default: withCtx(() => [
              createBaseVNode("div", {
                ref_key: "listboxRef",
                ref: listboxRef,
                class: normalizeClass([unref(ns).b(), _ctx.$attrs.class]),
                style: normalizeStyle(unref(styles)),
                role: "combobox",
                "aria-haspopup": "listbox",
                "aria-expanded": unref(suggestionVisible),
                "aria-owns": unref(listboxId)
              }, [
                createVNode(unref(ElInput), mergeProps({
                  ref_key: "inputRef",
                  ref: inputRef
                }, unref(attrs), {
                  clearable: _ctx.clearable,
                  disabled: unref(disabled),
                  name: _ctx.name,
                  "model-value": _ctx.modelValue,
                  onInput: handleInput,
                  onChange: handleChange,
                  onFocus: handleFocus,
                  onBlur: handleBlur,
                  onClear: handleClear,
                  onKeydown: [
                    _cache[0] || (_cache[0] = withKeys(withModifiers(($event) => highlight(highlightedIndex.value - 1), ["prevent"]), ["up"])),
                    _cache[1] || (_cache[1] = withKeys(withModifiers(($event) => highlight(highlightedIndex.value + 1), ["prevent"]), ["down"])),
                    withKeys(handleKeyEnter, ["enter"]),
                    withKeys(close2, ["tab"]),
                    withKeys(handleKeyEscape, ["esc"])
                  ],
                  onMousedown: handleMouseDown
                }), createSlots({ _: 2 }, [
                  _ctx.$slots.prepend ? {
                    name: "prepend",
                    fn: withCtx(() => [
                      renderSlot(_ctx.$slots, "prepend")
                    ])
                  } : void 0,
                  _ctx.$slots.append ? {
                    name: "append",
                    fn: withCtx(() => [
                      renderSlot(_ctx.$slots, "append")
                    ])
                  } : void 0,
                  _ctx.$slots.prefix ? {
                    name: "prefix",
                    fn: withCtx(() => [
                      renderSlot(_ctx.$slots, "prefix")
                    ])
                  } : void 0,
                  _ctx.$slots.suffix ? {
                    name: "suffix",
                    fn: withCtx(() => [
                      renderSlot(_ctx.$slots, "suffix")
                    ])
                  } : void 0
                ]), 1040, ["clearable", "disabled", "name", "model-value", "onKeydown"])
              ], 14, _hoisted_1$12)
            ]),
            _: 3
          }, 8, ["visible", "placement", "popper-class", "teleported", "transition"]);
        };
      }
    });
    var Autocomplete = /* @__PURE__ */ _export_sfc$1(_sfc_main$26, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/autocomplete/src/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 _hoisted_1$11 = ["src", "alt", "srcset"];
    const __default__$1o = /* @__PURE__ */ defineComponent({
      name: "ElAvatar"
    });
    const _sfc_main$25 = /* @__PURE__ */ defineComponent({
      ...__default__$1o,
      props: avatarProps,
      emits: avatarEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("avatar");
        const hasLoadError = ref(false);
        const avatarClass = computed(() => {
          const { size: size2, icon, shape } = props;
          const classList = [ns.b()];
          if (isString$1(size2))
            classList.push(ns.m(size2));
          if (icon)
            classList.push(ns.m("icon"));
          if (shape)
            classList.push(ns.m(shape));
          return classList;
        });
        const sizeStyle = computed(() => {
          const { size: size2 } = props;
          return isNumber(size2) ? ns.cssVarBlock({
            size: addUnit(size2) || ""
          }) : void 0;
        });
        const fitStyle = computed(() => ({
          objectFit: props.fit
        }));
        watch(() => props.src, () => hasLoadError.value = false);
        function handleError2(e) {
          hasLoadError.value = true;
          emit2("error", e);
        }
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("span", {
            class: normalizeClass(unref(avatarClass)),
            style: normalizeStyle(unref(sizeStyle))
          }, [
            (_ctx.src || _ctx.srcSet) && !hasLoadError.value ? (openBlock(), createElementBlock("img", {
              key: 0,
              src: _ctx.src,
              alt: _ctx.alt,
              srcset: _ctx.srcSet,
              style: normalizeStyle(unref(fitStyle)),
              onError: handleError2
            }, null, 44, _hoisted_1$11)) : _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
              default: withCtx(() => [
                (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
              ]),
              _: 1
            })) : renderSlot(_ctx.$slots, "default", { key: 2 })
          ], 6);
        };
      }
    });
    var Avatar = /* @__PURE__ */ _export_sfc$1(_sfc_main$25, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/avatar/src/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, emit2, componentName2) => {
      const el = shallowRef();
      const container = shallowRef();
      const visible = ref(false);
      const handleScroll2 = () => {
        if (el.value)
          visible.value = el.value.scrollTop >= props.visibilityHeight;
      };
      const handleClick = (event) => {
        var _a2;
        (_a2 = el.value) == null ? void 0 : _a2.scrollTo({ top: 0, behavior: "smooth" });
        emit2("click", event);
      };
      const handleScrollThrottled = useThrottleFn(handleScroll2, 300, true);
      useEventListener(container, "scroll", handleScrollThrottled);
      onMounted(() => {
        var _a2;
        container.value = document;
        el.value = document.documentElement;
        if (props.target) {
          el.value = (_a2 = document.querySelector(props.target)) != null ? _a2 : void 0;
          if (!el.value) {
            throwError(componentName2, `target does not exist: ${props.target}`);
          }
          container.value = el.value;
        }
        handleScroll2();
      });
      return {
        visible,
        handleClick
      };
    };
    const COMPONENT_NAME$h = "ElBacktop";
    const __default__$1n = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$h
    });
    const _sfc_main$24 = /* @__PURE__ */ defineComponent({
      ...__default__$1n,
      props: backtopProps,
      emits: backtopEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("backtop");
        const { handleClick, visible } = useBackTop(props, emit2, COMPONENT_NAME$h);
        const backTopStyle = computed(() => ({
          right: `${props.right}px`,
          bottom: `${props.bottom}px`
        }));
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Transition, {
            name: `${unref(ns).namespace.value}-fade-in`
          }, {
            default: withCtx(() => [
              unref(visible) ? (openBlock(), createElementBlock("div", {
                key: 0,
                style: normalizeStyle(unref(backTopStyle)),
                class: normalizeClass(unref(ns).b()),
                onClick: _cache[0] || (_cache[0] = withModifiers((...args) => unref(handleClick) && unref(handleClick)(...args), ["stop"]))
              }, [
                renderSlot(_ctx.$slots, "default", {}, () => [
                  createVNode(unref(ElIcon), {
                    class: normalizeClass(unref(ns).e("icon"))
                  }, {
                    default: withCtx(() => [
                      createVNode(unref(caret_top_default))
                    ]),
                    _: 1
                  }, 8, ["class"])
                ])
              ], 6)) : createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["name"]);
        };
      }
    });
    var Backtop = /* @__PURE__ */ _export_sfc$1(_sfc_main$24, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/backtop/src/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"
      }
    });
    const _hoisted_1$10 = ["textContent"];
    const __default__$1m = /* @__PURE__ */ defineComponent({
      name: "ElBadge"
    });
    const _sfc_main$23 = /* @__PURE__ */ defineComponent({
      ...__default__$1m,
      props: badgeProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("badge");
        const content = computed(() => {
          if (props.isDot)
            return "";
          if (isNumber(props.value) && isNumber(props.max)) {
            return props.max < props.value ? `${props.max}+` : `${props.value}`;
          }
          return `${props.value}`;
        });
        expose({
          content
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(ns).b())
          }, [
            renderSlot(_ctx.$slots, "default"),
            createVNode(Transition, {
              name: `${unref(ns).namespace.value}-zoom-in-center`,
              persisted: ""
            }, {
              default: withCtx(() => [
                withDirectives(createBaseVNode("sup", {
                  class: normalizeClass([
                    unref(ns).e("content"),
                    unref(ns).em("content", _ctx.type),
                    unref(ns).is("fixed", !!_ctx.$slots.default),
                    unref(ns).is("dot", _ctx.isDot)
                  ]),
                  textContent: toDisplayString(unref(content))
                }, null, 10, _hoisted_1$10), [
                  [vShow, !_ctx.hidden && (unref(content) || _ctx.isDot)]
                ])
              ]),
              _: 1
            }, 8, ["name"])
          ], 2);
        };
      }
    });
    var Badge = /* @__PURE__ */ _export_sfc$1(_sfc_main$23, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/badge/src/badge.vue"]]);
    const ElBadge = withInstall(Badge);
    const breadcrumbKey = Symbol("breadcrumbKey");
    const breadcrumbProps = buildProps({
      separator: {
        type: String,
        default: "/"
      },
      separatorIcon: {
        type: iconPropType
      }
    });
    const __default__$1l = /* @__PURE__ */ defineComponent({
      name: "ElBreadcrumb"
    });
    const _sfc_main$22 = /* @__PURE__ */ defineComponent({
      ...__default__$1l,
      props: breadcrumbProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("breadcrumb");
        const breadcrumb = ref();
        provide(breadcrumbKey, props);
        onMounted(() => {
          const items = breadcrumb.value.querySelectorAll(`.${ns.e("item")}`);
          if (items.length) {
            items[items.length - 1].setAttribute("aria-current", "page");
          }
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "breadcrumb",
            ref: breadcrumb,
            class: normalizeClass(unref(ns).b()),
            "aria-label": "Breadcrumb",
            role: "navigation"
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Breadcrumb = /* @__PURE__ */ _export_sfc$1(_sfc_main$22, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/breadcrumb/src/breadcrumb.vue"]]);
    const breadcrumbItemProps = buildProps({
      to: {
        type: definePropType([String, Object]),
        default: ""
      },
      replace: {
        type: Boolean,
        default: false
      }
    });
    const __default__$1k = /* @__PURE__ */ defineComponent({
      name: "ElBreadcrumbItem"
    });
    const _sfc_main$21 = /* @__PURE__ */ defineComponent({
      ...__default__$1k,
      props: breadcrumbItemProps,
      setup(__props) {
        const props = __props;
        const instance = getCurrentInstance();
        const breadcrumbContext = inject(breadcrumbKey, void 0);
        const ns = useNamespace("breadcrumb");
        const router2 = instance.appContext.config.globalProperties.$router;
        const link = ref();
        const onClick = () => {
          if (!props.to || !router2)
            return;
          props.replace ? router2.replace(props.to) : router2.push(props.to);
        };
        return (_ctx, _cache) => {
          var _a2, _b;
          return openBlock(), createElementBlock("span", {
            class: normalizeClass(unref(ns).e("item"))
          }, [
            createBaseVNode("span", {
              ref_key: "link",
              ref: link,
              class: normalizeClass([unref(ns).e("inner"), unref(ns).is("link", !!_ctx.to)]),
              role: "link",
              onClick
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2),
            ((_a2 = unref(breadcrumbContext)) == null ? void 0 : _a2.separatorIcon) ? (openBlock(), createBlock(unref(ElIcon), {
              key: 0,
              class: normalizeClass(unref(ns).e("separator"))
            }, {
              default: withCtx(() => [
                (openBlock(), createBlock(resolveDynamicComponent(unref(breadcrumbContext).separatorIcon)))
              ]),
              _: 1
            }, 8, ["class"])) : (openBlock(), createElementBlock("span", {
              key: 1,
              class: normalizeClass(unref(ns).e("separator")),
              role: "presentation"
            }, toDisplayString((_b = unref(breadcrumbContext)) == null ? void 0 : _b.separator), 3))
          ], 2);
        };
      }
    });
    var BreadcrumbItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$21, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/breadcrumb/src/breadcrumb-item.vue"]]);
    const ElBreadcrumb = withInstall(Breadcrumb, {
      BreadcrumbItem
    });
    const ElBreadcrumbItem = withNoopInstall(BreadcrumbItem);
    const buttonGroupContextKey = Symbol("buttonGroupContextKey");
    const useButton = (props, emit2) => {
      useDeprecated({
        from: "type.text",
        replacement: "link",
        version: "3.0.0",
        scope: "props",
        ref: "https://element-plus.org/en-US/component/button.html#button-attributes"
      }, computed(() => props.type === "text"));
      const buttonGroupContext = inject(buttonGroupContextKey, void 0);
      const globalConfig2 = useGlobalConfig("button");
      const { form } = useFormItem();
      const _size = useFormSize(computed(() => buttonGroupContext == null ? void 0 : buttonGroupContext.size));
      const _disabled = useFormDisabled();
      const _ref = ref();
      const slots = useSlots();
      const _type = computed(() => props.type || (buttonGroupContext == null ? void 0 : buttonGroupContext.type) || "");
      const autoInsertSpace = computed(() => {
        var _a2, _b, _c;
        return (_c = (_b = props.autoInsertSpace) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.autoInsertSpace) != null ? _c : false;
      });
      const _props = 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 = computed(() => {
        var _a2;
        const defaultSlot = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
        if (autoInsertSpace.value && (defaultSlot == null ? void 0 : defaultSlot.length) === 1) {
          const slot = defaultSlot[0];
          if ((slot == null ? void 0 : slot.type) === Text$1) {
            const text = slot.children;
            return /^\p{Unified_Ideograph}{2}$/u.test(text.trim());
          }
        }
        return false;
      });
      const handleClick = (evt) => {
        if (props.nativeType === "reset") {
          form == null ? void 0 : form.resetFields();
        }
        emit2("click", evt);
      };
      return {
        _disabled,
        _size,
        _type,
        _ref,
        _props,
        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: Boolean,
      text: Boolean,
      link: Boolean,
      bg: Boolean,
      autofocus: Boolean,
      round: Boolean,
      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$1(n, max2) {
      if (isOnePointZero$1(n)) {
        n = "100%";
      }
      var isPercent = isPercentage$1(n);
      n = max2 === 360 ? n : Math.min(max2, Math.max(0, parseFloat(n)));
      if (isPercent) {
        n = parseInt(String(n * max2), 10) / 100;
      }
      if (Math.abs(n - max2) < 1e-6) {
        return 1;
      }
      if (max2 === 360) {
        n = (n < 0 ? n % max2 + max2 : n % max2) / parseFloat(String(max2));
      } else {
        n = n % max2 / parseFloat(String(max2));
      }
      return n;
    }
    function clamp01(val) {
      return Math.min(1, Math.max(0, val));
    }
    function isOnePointZero$1(n) {
      return typeof n === "string" && n.indexOf(".") !== -1 && parseFloat(n) === 1;
    }
    function isPercentage$1(n) {
      return typeof n === "string" && n.indexOf("%") !== -1;
    }
    function boundAlpha(a2) {
      a2 = parseFloat(a2);
      if (isNaN(a2) || a2 < 0 || a2 > 1) {
        a2 = 1;
      }
      return a2;
    }
    function convertToPercentage(n) {
      if (n <= 1) {
        return "".concat(Number(n) * 100, "%");
      }
      return n;
    }
    function pad2(c2) {
      return c2.length === 1 ? "0" + c2 : String(c2);
    }
    function rgbToRgb(r, g, b2) {
      return {
        r: bound01$1(r, 255) * 255,
        g: bound01$1(g, 255) * 255,
        b: bound01$1(b2, 255) * 255
      };
    }
    function rgbToHsl(r, g, b2) {
      r = bound01$1(r, 255);
      g = bound01$1(g, 255);
      b2 = bound01$1(b2, 255);
      var max2 = Math.max(r, g, b2);
      var min2 = Math.min(r, g, b2);
      var h2 = 0;
      var s2 = 0;
      var l2 = (max2 + min2) / 2;
      if (max2 === min2) {
        s2 = 0;
        h2 = 0;
      } else {
        var d2 = max2 - min2;
        s2 = l2 > 0.5 ? d2 / (2 - max2 - min2) : d2 / (max2 + min2);
        switch (max2) {
          case r:
            h2 = (g - b2) / d2 + (g < b2 ? 6 : 0);
            break;
          case g:
            h2 = (b2 - r) / d2 + 2;
            break;
          case b2:
            h2 = (r - g) / d2 + 4;
            break;
        }
        h2 /= 6;
      }
      return { h: h2, s: s2, l: l2 };
    }
    function hue2rgb(p2, q2, t) {
      if (t < 0) {
        t += 1;
      }
      if (t > 1) {
        t -= 1;
      }
      if (t < 1 / 6) {
        return p2 + (q2 - p2) * (6 * t);
      }
      if (t < 1 / 2) {
        return q2;
      }
      if (t < 2 / 3) {
        return p2 + (q2 - p2) * (2 / 3 - t) * 6;
      }
      return p2;
    }
    function hslToRgb(h2, s2, l2) {
      var r;
      var g;
      var b2;
      h2 = bound01$1(h2, 360);
      s2 = bound01$1(s2, 100);
      l2 = bound01$1(l2, 100);
      if (s2 === 0) {
        g = l2;
        b2 = l2;
        r = l2;
      } else {
        var q2 = l2 < 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
        var p2 = 2 * l2 - q2;
        r = hue2rgb(p2, q2, h2 + 1 / 3);
        g = hue2rgb(p2, q2, h2);
        b2 = hue2rgb(p2, q2, h2 - 1 / 3);
      }
      return { r: r * 255, g: g * 255, b: b2 * 255 };
    }
    function rgbToHsv(r, g, b2) {
      r = bound01$1(r, 255);
      g = bound01$1(g, 255);
      b2 = bound01$1(b2, 255);
      var max2 = Math.max(r, g, b2);
      var min2 = Math.min(r, g, b2);
      var h2 = 0;
      var v2 = max2;
      var d2 = max2 - min2;
      var s2 = max2 === 0 ? 0 : d2 / max2;
      if (max2 === min2) {
        h2 = 0;
      } else {
        switch (max2) {
          case r:
            h2 = (g - b2) / d2 + (g < b2 ? 6 : 0);
            break;
          case g:
            h2 = (b2 - r) / d2 + 2;
            break;
          case b2:
            h2 = (r - g) / d2 + 4;
            break;
        }
        h2 /= 6;
      }
      return { h: h2, s: s2, v: v2 };
    }
    function hsvToRgb(h2, s2, v2) {
      h2 = bound01$1(h2, 360) * 6;
      s2 = bound01$1(s2, 100);
      v2 = bound01$1(v2, 100);
      var i = Math.floor(h2);
      var f2 = h2 - i;
      var p2 = v2 * (1 - s2);
      var q2 = v2 * (1 - f2 * s2);
      var t = v2 * (1 - (1 - f2) * s2);
      var mod = i % 6;
      var r = [v2, q2, p2, p2, t, v2][mod];
      var g = [t, v2, v2, q2, p2, p2][mod];
      var b2 = [p2, p2, t, v2, v2, q2][mod];
      return { r: r * 255, g: g * 255, b: b2 * 255 };
    }
    function rgbToHex(r, g, b2, allow3Char) {
      var hex = [
        pad2(Math.round(r).toString(16)),
        pad2(Math.round(g).toString(16)),
        pad2(Math.round(b2).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, b2, a2, allow4Char) {
      var hex = [
        pad2(Math.round(r).toString(16)),
        pad2(Math.round(g).toString(16)),
        pad2(Math.round(b2).toString(16)),
        pad2(convertDecimalToHex(a2))
      ];
      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(d2) {
      return Math.round(parseFloat(d2) * 255).toString(16);
    }
    function convertHexToDecimal(h2) {
      return parseIntFromHex(h2) / 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 a2 = 1;
      var s2 = null;
      var v2 = null;
      var l2 = null;
      var ok = false;
      var format2 = 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;
          format2 = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
        } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
          s2 = convertToPercentage(color.s);
          v2 = convertToPercentage(color.v);
          rgb = hsvToRgb(color.h, s2, v2);
          ok = true;
          format2 = "hsv";
        } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
          s2 = convertToPercentage(color.s);
          l2 = convertToPercentage(color.l);
          rgb = hslToRgb(color.h, s2, l2);
          ok = true;
          format2 = "hsl";
        }
        if (Object.prototype.hasOwnProperty.call(color, "a")) {
          a2 = color.a;
        }
      }
      a2 = boundAlpha(a2);
      return {
        ok,
        format: color.format || format2,
        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: a2
      };
    }
    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 = (
      /** @class */
      function() {
        function TinyColor2(color, opts) {
          if (color === void 0) {
            color = "";
          }
          if (opts === void 0) {
            opts = {};
          }
          var _a2;
          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 = (_a2 = opts.format) !== null && _a2 !== void 0 ? _a2 : 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 R2;
          var G2;
          var B2;
          var RsRGB = rgb.r / 255;
          var GsRGB = rgb.g / 255;
          var BsRGB = rgb.b / 255;
          if (RsRGB <= 0.03928) {
            R2 = RsRGB / 12.92;
          } else {
            R2 = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
          }
          if (GsRGB <= 0.03928) {
            G2 = GsRGB / 12.92;
          } else {
            G2 = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
          }
          if (BsRGB <= 0.03928) {
            B2 = BsRGB / 12.92;
          } else {
            B2 = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
          }
          return 0.2126 * R2 + 0.7152 * G2 + 0.0722 * B2;
        };
        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 s2 = this.toHsl().s;
          return s2 === 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 h2 = Math.round(hsv.h * 360);
          var s2 = Math.round(hsv.s * 100);
          var v2 = Math.round(hsv.v * 100);
          return this.a === 1 ? "hsv(".concat(h2, ", ").concat(s2, "%, ").concat(v2, "%)") : "hsva(".concat(h2, ", ").concat(s2, "%, ").concat(v2, "%, ").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 h2 = Math.round(hsl.h * 360);
          var s2 = Math.round(hsl.s * 100);
          var l2 = Math.round(hsl.l * 100);
          return this.a === 1 ? "hsl(".concat(h2, ", ").concat(s2, "%, ").concat(l2, "%)") : "hsla(".concat(h2, ", ").concat(s2, "%, ").concat(l2, "%, ").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 b2 = Math.round(this.b);
          return this.a === 1 ? "rgb(".concat(r, ", ").concat(g, ", ").concat(b2, ")") : "rgba(".concat(r, ", ").concat(g, ", ").concat(b2, ", ").concat(this.roundA, ")");
        };
        TinyColor2.prototype.toPercentageRgb = function() {
          var fmt = function(x2) {
            return "".concat(Math.round(bound01$1(x2, 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(x2) {
            return Math.round(bound01$1(x2, 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, _a2 = Object.entries(names); _i < _a2.length; _i++) {
            var _b = _a2[_i], key = _b[0], value = _b[1];
            if (hex === value) {
              return key;
            }
          }
          return false;
        };
        TinyColor2.prototype.toString = function(format2) {
          var formatSet = Boolean(format2);
          format2 = format2 !== null && format2 !== void 0 ? format2 : this.format;
          var formattedString = false;
          var hasAlpha = this.a < 1 && this.a >= 0;
          var needsAlphaFormat = !formatSet && hasAlpha && (format2.startsWith("hex") || format2 === "name");
          if (needsAlphaFormat) {
            if (format2 === "name" && this.a === 0) {
              return this.toName();
            }
            return this.toRgbString();
          }
          if (format2 === "rgb") {
            formattedString = this.toRgbString();
          }
          if (format2 === "prgb") {
            formattedString = this.toPercentageRgbString();
          }
          if (format2 === "hex" || format2 === "hex6") {
            formattedString = this.toHexString();
          }
          if (format2 === "hex3") {
            formattedString = this.toHexString(true);
          }
          if (format2 === "hex4") {
            formattedString = this.toHex8String(true);
          }
          if (format2 === "hex8") {
            formattedString = this.toHex8String();
          }
          if (format2 === "name") {
            formattedString = this.toName();
          }
          if (format2 === "hsl") {
            formattedString = this.toHslString();
          }
          if (format2 === "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 p2 = amount / 100;
          var rgba = {
            r: (rgb2.r - rgb1.r) * p2 + rgb1.r,
            g: (rgb2.g - rgb1.g) * p2 + rgb1.g,
            b: (rgb2.b - rgb1.b) * p2 + rgb1.b,
            a: (rgb2.a - rgb1.a) * p2 + 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 h2 = hsv.h;
          var s2 = hsv.s;
          var v2 = hsv.v;
          var res = [];
          var modification = 1 / results;
          while (results--) {
            res.push(new TinyColor2({ h: h2, s: s2, v: v2 }));
            v2 = (v2 + modification) % 1;
          }
          return res;
        };
        TinyColor2.prototype.splitcomplement = function() {
          var hsl = this.toHsl();
          var h2 = hsl.h;
          return [
            this,
            new TinyColor2({ h: (h2 + 72) % 360, s: hsl.s, l: hsl.l }),
            new TinyColor2({ h: (h2 + 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 h2 = hsl.h;
          var result = [this];
          var increment = 360 / n;
          for (var i = 1; i < n; i++) {
            result.push(new TinyColor2({ h: (h2 + 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 computed(() => {
        let styles = {};
        const buttonColor = props.color;
        if (buttonColor) {
          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__$1j = /* @__PURE__ */ defineComponent({
      name: "ElButton"
    });
    const _sfc_main$20 = /* @__PURE__ */ defineComponent({
      ...__default__$1j,
      props: buttonProps,
      emits: buttonEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const buttonStyle = useButtonCustomStyle(props);
        const ns = useNamespace("button");
        const { _ref, _size, _type, _disabled, _props, shouldAddSpace, handleClick } = useButton(props, emit2);
        expose({
          ref: _ref,
          size: _size,
          type: _type,
          disabled: _disabled,
          shouldAddSpace
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), mergeProps({
            ref_key: "_ref",
            ref: _ref
          }, unref(_props), {
            class: [
              unref(ns).b(),
              unref(ns).m(unref(_type)),
              unref(ns).m(unref(_size)),
              unref(ns).is("disabled", unref(_disabled)),
              unref(ns).is("loading", _ctx.loading),
              unref(ns).is("plain", _ctx.plain),
              unref(ns).is("round", _ctx.round),
              unref(ns).is("circle", _ctx.circle),
              unref(ns).is("text", _ctx.text),
              unref(ns).is("link", _ctx.link),
              unref(ns).is("has-bg", _ctx.bg)
            ],
            style: unref(buttonStyle),
            onClick: unref(handleClick)
          }), {
            default: withCtx(() => [
              _ctx.loading ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                _ctx.$slots.loading ? renderSlot(_ctx.$slots, "loading", { key: 0 }) : (openBlock(), createBlock(unref(ElIcon), {
                  key: 1,
                  class: normalizeClass(unref(ns).is("loading"))
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.loadingIcon)))
                  ]),
                  _: 1
                }, 8, ["class"]))
              ], 64)) : _ctx.icon || _ctx.$slots.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
                default: withCtx(() => [
                  _ctx.icon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon), { key: 0 })) : renderSlot(_ctx.$slots, "icon", { key: 1 })
                ]),
                _: 3
              })) : createCommentVNode("v-if", true),
              _ctx.$slots.default ? (openBlock(), createElementBlock("span", {
                key: 2,
                class: normalizeClass({ [unref(ns).em("text", "expand")]: unref(shouldAddSpace) })
              }, [
                renderSlot(_ctx.$slots, "default")
              ], 2)) : createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 16, ["class", "style", "onClick"]);
        };
      }
    });
    var Button = /* @__PURE__ */ _export_sfc$1(_sfc_main$20, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/button/src/button.vue"]]);
    const buttonGroupProps = {
      size: buttonProps.size,
      type: buttonProps.type
    };
    const __default__$1i = /* @__PURE__ */ defineComponent({
      name: "ElButtonGroup"
    });
    const _sfc_main$1$ = /* @__PURE__ */ defineComponent({
      ...__default__$1i,
      props: buttonGroupProps,
      setup(__props) {
        const props = __props;
        provide(buttonGroupContextKey, reactive({
          size: toRef(props, "size"),
          type: toRef(props, "type")
        }));
        const ns = useNamespace("button");
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(`${unref(ns).b("group")}`)
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var ButtonGroup = /* @__PURE__ */ _export_sfc$1(_sfc_main$1$, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/button/src/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 : {};
    function getDefaultExportFromCjs(x2) {
      return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
    }
    var dayjs_min = { exports: {} };
    (function(module2, exports2) {
      !function(t, e) {
        module2.exports = e();
      }(commonjsGlobal, function() {
        var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s2 = "minute", u2 = "hour", a2 = "day", o2 = "week", c2 = "month", f2 = "quarter", h2 = "year", d2 = "date", l2 = "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, M2 = { 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]) + "]";
        } }, m2 = function(t2, e2, n2) {
          var r2 = String(t2);
          return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
        }, v2 = { s: m2, z: function(t2) {
          var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
          return (e2 <= 0 ? "+" : "-") + m2(r2, 2, "0") + ":" + m2(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, c2), s3 = n2 - i2 < 0, u3 = e2.clone().add(r2 + (s3 ? -1 : 1), c2);
          return +(-(r2 + (n2 - i2) / (s3 ? i2 - u3 : u3 - i2)) || 0);
        }, a: function(t2) {
          return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
        }, p: function(t2) {
          return { M: c2, y: h2, w: o2, d: a2, D: d2, h: u2, m: s2, s: i, ms: r, Q: f2 }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
        }, u: function(t2) {
          return void 0 === t2;
        } }, g = "en", D2 = {};
        D2[g] = M2;
        var p2 = "$isDayjsObject", S2 = function(t2) {
          return t2 instanceof _2 || !(!t2 || !t2[p2]);
        }, w2 = function t2(e2, n2, r2) {
          var i2;
          if (!e2)
            return g;
          if ("string" == typeof e2) {
            var s3 = e2.toLowerCase();
            D2[s3] && (i2 = s3), n2 && (D2[s3] = n2, i2 = s3);
            var u3 = e2.split("-");
            if (!i2 && u3.length > 1)
              return t2(u3[0]);
          } else {
            var a3 = e2.name;
            D2[a3] = e2, i2 = a3;
          }
          return !r2 && i2 && (g = i2), i2 || !r2 && g;
        }, O2 = function(t2, e2) {
          if (S2(t2))
            return t2.clone();
          var n2 = "object" == typeof e2 ? e2 : {};
          return n2.date = t2, n2.args = arguments, new _2(n2);
        }, b2 = v2;
        b2.l = w2, b2.i = S2, b2.w = function(t2, e2) {
          return O2(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
        };
        var _2 = function() {
          function M3(t2) {
            this.$L = w2(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p2] = true;
          }
          var m3 = M3.prototype;
          return m3.parse = function(t2) {
            this.$d = function(t3) {
              var e2 = t3.date, n2 = t3.utc;
              if (null === e2)
                return /* @__PURE__ */ new Date(NaN);
              if (b2.u(e2))
                return /* @__PURE__ */ new Date();
              if (e2 instanceof Date)
                return new Date(e2);
              if ("string" == typeof e2 && !/Z$/i.test(e2)) {
                var r2 = e2.match($);
                if (r2) {
                  var i2 = r2[2] - 1 || 0, s3 = (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, s3)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s3);
                }
              }
              return new Date(e2);
            }(t2), this.init();
          }, m3.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();
          }, m3.$utils = function() {
            return b2;
          }, m3.isValid = function() {
            return !(this.$d.toString() === l2);
          }, m3.isSame = function(t2, e2) {
            var n2 = O2(t2);
            return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
          }, m3.isAfter = function(t2, e2) {
            return O2(t2) < this.startOf(e2);
          }, m3.isBefore = function(t2, e2) {
            return this.endOf(e2) < O2(t2);
          }, m3.$g = function(t2, e2, n2) {
            return b2.u(t2) ? this[e2] : this.set(n2, t2);
          }, m3.unix = function() {
            return Math.floor(this.valueOf() / 1e3);
          }, m3.valueOf = function() {
            return this.$d.getTime();
          }, m3.startOf = function(t2, e2) {
            var n2 = this, r2 = !!b2.u(e2) || e2, f3 = b2.p(t2), l3 = function(t3, e3) {
              var i2 = b2.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
              return r2 ? i2 : i2.endOf(a2);
            }, $2 = function(t3, e3) {
              return b2.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
            }, y2 = this.$W, M4 = this.$M, m4 = this.$D, v3 = "set" + (this.$u ? "UTC" : "");
            switch (f3) {
              case h2:
                return r2 ? l3(1, 0) : l3(31, 11);
              case c2:
                return r2 ? l3(1, M4) : l3(0, M4 + 1);
              case o2:
                var g2 = this.$locale().weekStart || 0, D3 = (y2 < g2 ? y2 + 7 : y2) - g2;
                return l3(r2 ? m4 - D3 : m4 + (6 - D3), M4);
              case a2:
              case d2:
                return $2(v3 + "Hours", 0);
              case u2:
                return $2(v3 + "Minutes", 1);
              case s2:
                return $2(v3 + "Seconds", 2);
              case i:
                return $2(v3 + "Milliseconds", 3);
              default:
                return this.clone();
            }
          }, m3.endOf = function(t2) {
            return this.startOf(t2, false);
          }, m3.$set = function(t2, e2) {
            var n2, o3 = b2.p(t2), f3 = "set" + (this.$u ? "UTC" : ""), l3 = (n2 = {}, n2[a2] = f3 + "Date", n2[d2] = f3 + "Date", n2[c2] = f3 + "Month", n2[h2] = f3 + "FullYear", n2[u2] = f3 + "Hours", n2[s2] = f3 + "Minutes", n2[i] = f3 + "Seconds", n2[r] = f3 + "Milliseconds", n2)[o3], $2 = o3 === a2 ? this.$D + (e2 - this.$W) : e2;
            if (o3 === c2 || o3 === h2) {
              var y2 = this.clone().set(d2, 1);
              y2.$d[l3]($2), y2.init(), this.$d = y2.set(d2, Math.min(this.$D, y2.daysInMonth())).$d;
            } else
              l3 && this.$d[l3]($2);
            return this.init(), this;
          }, m3.set = function(t2, e2) {
            return this.clone().$set(t2, e2);
          }, m3.get = function(t2) {
            return this[b2.p(t2)]();
          }, m3.add = function(r2, f3) {
            var d3, l3 = this;
            r2 = Number(r2);
            var $2 = b2.p(f3), y2 = function(t2) {
              var e2 = O2(l3);
              return b2.w(e2.date(e2.date() + Math.round(t2 * r2)), l3);
            };
            if ($2 === c2)
              return this.set(c2, this.$M + r2);
            if ($2 === h2)
              return this.set(h2, this.$y + r2);
            if ($2 === a2)
              return y2(1);
            if ($2 === o2)
              return y2(7);
            var M4 = (d3 = {}, d3[s2] = e, d3[u2] = n, d3[i] = t, d3)[$2] || 1, m4 = this.$d.getTime() + r2 * M4;
            return b2.w(m4, this);
          }, m3.subtract = function(t2, e2) {
            return this.add(-1 * t2, e2);
          }, m3.format = function(t2) {
            var e2 = this, n2 = this.$locale();
            if (!this.isValid())
              return n2.invalidDate || l2;
            var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b2.z(this), s3 = this.$H, u3 = this.$m, a3 = this.$M, o3 = n2.weekdays, c3 = n2.months, f3 = n2.meridiem, h3 = function(t3, n3, i3, s4) {
              return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s4);
            }, d3 = function(t3) {
              return b2.s(s3 % 12 || 12, t3, "0");
            }, $2 = f3 || 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 b2.s(e2.$y, 4, "0");
                  case "M":
                    return a3 + 1;
                  case "MM":
                    return b2.s(a3 + 1, 2, "0");
                  case "MMM":
                    return h3(n2.monthsShort, a3, c3, 3);
                  case "MMMM":
                    return h3(c3, a3);
                  case "D":
                    return e2.$D;
                  case "DD":
                    return b2.s(e2.$D, 2, "0");
                  case "d":
                    return String(e2.$W);
                  case "dd":
                    return h3(n2.weekdaysMin, e2.$W, o3, 2);
                  case "ddd":
                    return h3(n2.weekdaysShort, e2.$W, o3, 3);
                  case "dddd":
                    return o3[e2.$W];
                  case "H":
                    return String(s3);
                  case "HH":
                    return b2.s(s3, 2, "0");
                  case "h":
                    return d3(1);
                  case "hh":
                    return d3(2);
                  case "a":
                    return $2(s3, u3, true);
                  case "A":
                    return $2(s3, u3, false);
                  case "m":
                    return String(u3);
                  case "mm":
                    return b2.s(u3, 2, "0");
                  case "s":
                    return String(e2.$s);
                  case "ss":
                    return b2.s(e2.$s, 2, "0");
                  case "SSS":
                    return b2.s(e2.$ms, 3, "0");
                  case "Z":
                    return i2;
                }
                return null;
              }(t3) || i2.replace(":", "");
            });
          }, m3.utcOffset = function() {
            return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
          }, m3.diff = function(r2, d3, l3) {
            var $2, y2 = this, M4 = b2.p(d3), m4 = O2(r2), v3 = (m4.utcOffset() - this.utcOffset()) * e, g2 = this - m4, D3 = function() {
              return b2.m(y2, m4);
            };
            switch (M4) {
              case h2:
                $2 = D3() / 12;
                break;
              case c2:
                $2 = D3();
                break;
              case f2:
                $2 = D3() / 3;
                break;
              case o2:
                $2 = (g2 - v3) / 6048e5;
                break;
              case a2:
                $2 = (g2 - v3) / 864e5;
                break;
              case u2:
                $2 = g2 / n;
                break;
              case s2:
                $2 = g2 / e;
                break;
              case i:
                $2 = g2 / t;
                break;
              default:
                $2 = g2;
            }
            return l3 ? $2 : b2.a($2);
          }, m3.daysInMonth = function() {
            return this.endOf(c2).$D;
          }, m3.$locale = function() {
            return D2[this.$L];
          }, m3.locale = function(t2, e2) {
            if (!t2)
              return this.$L;
            var n2 = this.clone(), r2 = w2(t2, e2, true);
            return r2 && (n2.$L = r2), n2;
          }, m3.clone = function() {
            return b2.w(this.$d, this);
          }, m3.toDate = function() {
            return new Date(this.valueOf());
          }, m3.toJSON = function() {
            return this.isValid() ? this.toISOString() : null;
          }, m3.toISOString = function() {
            return this.$d.toISOString();
          }, m3.toString = function() {
            return this.$d.toUTCString();
          }, M3;
        }(), k = _2.prototype;
        return O2.prototype = k, [["$ms", r], ["$s", i], ["$m", s2], ["$H", u2], ["$W", a2], ["$M", c2], ["$y", h2], ["$D", d2]].forEach(function(t2) {
          k[t2[1]] = function(e2) {
            return this.$g(e2, t2[0], t2[1]);
          };
        }), O2.extend = function(t2, e2) {
          return t2.$i || (t2(e2, _2, O2), t2.$i = true), O2;
        }, O2.locale = w2, O2.isDayjs = S2, O2.unix = function(t2) {
          return O2(1e3 * t2);
        }, O2.en = D2[g], O2.Ls = D2, O2.p = {}, O2;
      });
    })(dayjs_min);
    var dayjs_minExports = dayjs_min.exports;
    const dayjs = /* @__PURE__ */ getDefaultExportFromCjs(dayjs_minExports);
    var customParseFormat$1 = { exports: {} };
    (function(module2, exports2) {
      !function(e, t) {
        module2.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|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d\d/, r = /\d\d?/, i = /\d*[^-_:/,()\s\d]+/, o2 = {}, s2 = function(e2) {
          return (e2 = +e2) + (e2 > 68 ? 1900 : 2e3);
        };
        var a2 = function(e2) {
          return function(t2) {
            this[e2] = +t2;
          };
        }, f2 = [/[+-]\d\d:?(\d\d)?|Z/, function(e2) {
          (this.zone || (this.zone = {})).offset = function(e3) {
            if (!e3)
              return 0;
            if ("Z" === e3)
              return 0;
            var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
            return 0 === n2 ? 0 : "+" === t2[0] ? -n2 : n2;
          }(e2);
        }], h2 = function(e2) {
          var t2 = o2[e2];
          return t2 && (t2.indexOf ? t2 : t2.s.concat(t2.f));
        }, u2 = function(e2, t2) {
          var n2, r2 = o2.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;
        }, d2 = { A: [i, function(e2) {
          this.afternoon = u2(e2, false);
        }], a: [i, function(e2) {
          this.afternoon = u2(e2, true);
        }], S: [/\d/, function(e2) {
          this.milliseconds = 100 * +e2;
        }], SS: [n, function(e2) {
          this.milliseconds = 10 * +e2;
        }], SSS: [/\d{3}/, function(e2) {
          this.milliseconds = +e2;
        }], s: [r, a2("seconds")], ss: [r, a2("seconds")], m: [r, a2("minutes")], mm: [r, a2("minutes")], H: [r, a2("hours")], h: [r, a2("hours")], HH: [r, a2("hours")], hh: [r, a2("hours")], D: [r, a2("day")], DD: [n, a2("day")], Do: [i, function(e2) {
          var t2 = o2.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);
        }], M: [r, a2("month")], MM: [n, a2("month")], MMM: [i, function(e2) {
          var t2 = h2("months"), n2 = (h2("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: [i, function(e2) {
          var t2 = h2("months").indexOf(e2) + 1;
          if (t2 < 1)
            throw new Error();
          this.month = t2 % 12 || t2;
        }], Y: [/[+-]?\d+/, a2("year")], YY: [n, function(e2) {
          this.year = s2(e2);
        }], YYYY: [/\d{4}/, a2("year")], Z: f2, ZZ: f2 };
        function c2(n2) {
          var r2, i2;
          r2 = n2, i2 = o2 && o2.formats;
          for (var s3 = (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), a3 = s3.length, f3 = 0; f3 < a3; f3 += 1) {
            var h3 = s3[f3], u3 = d2[h3], c3 = u3 && u3[0], l2 = u3 && u3[1];
            s3[f3] = l2 ? { regex: c3, parser: l2 } : h3.replace(/^\[|\]$/g, "");
          }
          return function(e2) {
            for (var t2 = {}, n3 = 0, r3 = 0; n3 < a3; n3 += 1) {
              var i3 = s3[n3];
              if ("string" == typeof i3)
                r3 += i3.length;
              else {
                var o3 = i3.regex, f4 = i3.parser, h4 = e2.slice(r3), u4 = o3.exec(h4)[0];
                f4.call(t2, u4), e2 = e2.replace(u4, "");
              }
            }
            return function(e3) {
              var t3 = e3.afternoon;
              if (void 0 !== t3) {
                var n4 = e3.hours;
                t3 ? n4 < 12 && (e3.hours += 12) : 12 === n4 && (e3.hours = 0), delete e3.afternoon;
              }
            }(t2), t2;
          };
        }
        return function(e2, t2, n2) {
          n2.p.customParseFormat = true, e2 && e2.parseTwoDigitYear && (s2 = e2.parseTwoDigitYear);
          var r2 = t2.prototype, i2 = r2.parse;
          r2.parse = function(e3) {
            var t3 = e3.date, r3 = e3.utc, s3 = e3.args;
            this.$u = r3;
            var a3 = s3[1];
            if ("string" == typeof a3) {
              var f3 = true === s3[2], h3 = true === s3[3], u3 = f3 || h3, d3 = s3[2];
              h3 && (d3 = s3[2]), o2 = this.$locale(), !f3 && d3 && (o2 = n2.Ls[d3]), this.$d = function(e4, t4, n3) {
                try {
                  if (["x", "X"].indexOf(t4) > -1)
                    return new Date(("X" === t4 ? 1e3 : 1) * e4);
                  var r4 = c2(t4)(e4), i3 = r4.year, o3 = r4.month, s4 = r4.day, a4 = r4.hours, f4 = r4.minutes, h4 = r4.seconds, u4 = r4.milliseconds, d4 = r4.zone, l3 = /* @__PURE__ */ new Date(), m3 = s4 || (i3 || o3 ? 1 : l3.getDate()), M3 = i3 || l3.getFullYear(), Y2 = 0;
                  i3 && !o3 || (Y2 = o3 > 0 ? o3 - 1 : l3.getMonth());
                  var p2 = a4 || 0, v2 = f4 || 0, D2 = h4 || 0, g = u4 || 0;
                  return d4 ? new Date(Date.UTC(M3, Y2, m3, p2, v2, D2, g + 60 * d4.offset * 1e3)) : n3 ? new Date(Date.UTC(M3, Y2, m3, p2, v2, D2, g)) : new Date(M3, Y2, m3, p2, v2, D2, g);
                } catch (e5) {
                  return /* @__PURE__ */ new Date("");
                }
              }(t3, a3, r3), this.init(), d3 && true !== d3 && (this.$L = this.locale(d3).$L), u3 && t3 != this.format(a3) && (this.$d = /* @__PURE__ */ new Date("")), o2 = {};
            } else if (a3 instanceof Array)
              for (var l2 = a3.length, m2 = 1; m2 <= l2; m2 += 1) {
                s3[1] = a3[m2 - 1];
                var M2 = n2.apply(this, s3);
                if (M2.isValid()) {
                  this.$d = M2.$d, this.$L = M2.$L, this.init();
                  break;
                }
                m2 === l2 && (this.$d = /* @__PURE__ */ new Date(""));
              }
            else
              i2.call(this, e3);
          };
        };
      });
    })(customParseFormat$1);
    var customParseFormatExports = customParseFormat$1.exports;
    const customParseFormat = /* @__PURE__ */ getDefaultExportFromCjs(customParseFormatExports);
    const timeUnits$1 = ["hours", "minutes", "seconds"];
    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",
      month: "YYYY-MM",
      datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,
      monthrange: "YYYY-MM",
      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 = (format2) => {
      return format2.replace(/\W?m{1,2}|\W?ZZ/g, "").replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, "").trim();
    };
    const extractTimeFormat = (format2) => {
      return format2.replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, "").trim();
    };
    const dateEquals = function(a2, b2) {
      const aIsDate = isDate(a2);
      const bIsDate = isDate(b2);
      if (aIsDate && bIsDate) {
        return a2.getTime() === b2.getTime();
      }
      if (!aIsDate && !bIsDate) {
        return a2 === b2;
      }
      return false;
    };
    const valueEquals = function(a2, b2) {
      const aIsArray = isArray$3(a2);
      const bIsArray = isArray$3(b2);
      if (aIsArray && bIsArray) {
        if (a2.length !== b2.length) {
          return false;
        }
        return a2.every((item, index2) => dateEquals(item, b2[index2]));
      }
      if (!aIsArray && !bIsArray) {
        return dateEquals(a2, b2);
      }
      return false;
    };
    const parseDate = function(date2, format2, lang) {
      const day = isEmpty(format2) || format2 === "x" ? dayjs(date2).locale(lang) : dayjs(date2, format2).locale(lang);
      return day.isValid() ? day : void 0;
    };
    const formatter = function(date2, format2, lang) {
      if (isEmpty(format2))
        return date2;
      if (format2 === "x")
        return +date2;
      return dayjs(date2).locale(lang).format(format2);
    };
    const makeList = (total2, method2) => {
      var _a2;
      const arr = [];
      const disabledArr = method2 == null ? void 0 : method2();
      for (let i = 0; i < total2; i++) {
        arr.push((_a2 = disabledArr == null ? void 0 : disabledArr.includes(i)) != null ? _a2 : false);
      }
      return arr;
    };
    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({
      id: {
        type: definePropType([Array, String])
      },
      name: {
        type: definePropType([Array, String]),
        default: ""
      },
      popperClass: {
        type: String,
        default: ""
      },
      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,
      label: {
        type: String,
        default: void 0
      },
      tabindex: {
        type: definePropType([String, Number]),
        default: 0
      },
      validateEvent: {
        type: Boolean,
        default: true
      },
      unlinkPanels: Boolean
    });
    const _hoisted_1$$ = ["id", "name", "placeholder", "value", "disabled", "readonly"];
    const _hoisted_2$F = ["id", "name", "placeholder", "value", "disabled", "readonly"];
    const __default__$1h = /* @__PURE__ */ defineComponent({
      name: "Picker"
    });
    const _sfc_main$1_ = /* @__PURE__ */ defineComponent({
      ...__default__$1h,
      props: timePickerDefaultProps,
      emits: [
        "update:modelValue",
        "change",
        "focus",
        "blur",
        "calendar-change",
        "panel-change",
        "visible-change",
        "keydown"
      ],
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const attrs = useAttrs$1();
        const { lang } = useLocale();
        const nsDate = useNamespace("date");
        const nsInput = useNamespace("input");
        const nsRange = useNamespace("range");
        const { form, formItem } = useFormItem();
        const elPopperOptions = inject("ElPopperOptions", {});
        const refPopper = ref();
        const inputRef = ref();
        const pickerVisible = ref(false);
        const pickerActualVisible = ref(false);
        const valueOnOpen = ref(null);
        let hasJustTabExitedInput = false;
        let ignoreFocusEvent = false;
        const rangeInputKls = 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 = computed(() => [
          nsInput.e("icon"),
          nsRange.e("close-icon"),
          !showClose.value ? nsRange.e("close-icon--hidden") : ""
        ]);
        watch(pickerVisible, (val) => {
          if (!val) {
            userInput.value = null;
            nextTick(() => {
              emitChange(props.modelValue);
            });
          } else {
            nextTick(() => {
              if (val) {
                valueOnOpen.value = props.modelValue;
              }
            });
          }
        });
        const emitChange = (val, isClear) => {
          if (isClear || !valueEquals(val, valueOnOpen.value)) {
            emit2("change", val);
            props.validateEvent && (formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn()));
          }
        };
        const emitInput = (input) => {
          if (!valueEquals(props.modelValue, input)) {
            let formatted;
            if (isArray$3(input)) {
              formatted = input.map((item) => formatter(item, props.valueFormat, lang.value));
            } else if (input) {
              formatted = formatter(input, props.valueFormat, lang.value);
            }
            emit2("update:modelValue", input ? formatted : input, lang.value);
          }
        };
        const emitKeydown = (e) => {
          emit2("keydown", e);
        };
        const refInput = computed(() => {
          if (inputRef.value) {
            const _r = isRangeInput.value ? inputRef.value : inputRef.value.$el;
            return Array.from(_r.querySelectorAll("input"));
          }
          return [];
        });
        const setSelectionRange = (start, end2, pos) => {
          const _inputs = refInput.value;
          if (!_inputs.length)
            return;
          if (!pos || pos === "min") {
            _inputs[0].setSelectionRange(start, end2);
            _inputs[0].focus();
          } else if (pos === "max") {
            _inputs[1].setSelectionRange(start, end2);
            _inputs[1].focus();
          }
        };
        const focusOnInputBox = () => {
          focus(true, true);
          nextTick(() => {
            ignoreFocusEvent = false;
          });
        };
        const onPick = (date2 = "", visible = false) => {
          if (!visible) {
            ignoreFocusEvent = true;
          }
          pickerVisible.value = visible;
          let result;
          if (isArray$3(date2)) {
            result = date2.map((_2) => _2.toDate());
          } else {
            result = date2 ? date2.toDate() : date2;
          }
          userInput.value = null;
          emitInput(result);
        };
        const onBeforeShow = () => {
          pickerActualVisible.value = true;
        };
        const onShow = () => {
          emit2("visible-change", true);
        };
        const onKeydownPopperContent = (event) => {
          if ((event == null ? void 0 : event.key) === EVENT_CODE.esc) {
            focus(true, true);
          }
        };
        const onHide = () => {
          pickerActualVisible.value = false;
          pickerVisible.value = false;
          ignoreFocusEvent = false;
          emit2("visible-change", false);
        };
        const handleOpen = () => {
          pickerVisible.value = true;
        };
        const handleClose = () => {
          pickerVisible.value = false;
        };
        const focus = (focusStartInput = true, isIgnoreFocusEvent = false) => {
          ignoreFocusEvent = isIgnoreFocusEvent;
          const [leftInput, rightInput] = unref(refInput);
          let input = leftInput;
          if (!focusStartInput && isRangeInput.value) {
            input = rightInput;
          }
          if (input) {
            input.focus();
          }
        };
        const handleFocusInput = (e) => {
          if (props.readonly || pickerDisabled.value || pickerVisible.value || ignoreFocusEvent) {
            return;
          }
          pickerVisible.value = true;
          emit2("focus", e);
        };
        let currentHandleBlurDeferCallback = void 0;
        const handleBlurInput = (e) => {
          const handleBlurDefer = async () => {
            setTimeout(() => {
              var _a2;
              if (currentHandleBlurDeferCallback === handleBlurDefer) {
                if (!(((_a2 = refPopper.value) == null ? void 0 : _a2.isFocusInsideContent()) && !hasJustTabExitedInput) && refInput.value.filter((input) => {
                  return input.contains(document.activeElement);
                }).length === 0) {
                  handleChange();
                  pickerVisible.value = false;
                  emit2("blur", e);
                  props.validateEvent && (formItem == null ? void 0 : formItem.validate("blur").catch((err) => debugWarn()));
                }
                hasJustTabExitedInput = false;
              }
            }, 0);
          };
          currentHandleBlurDeferCallback = handleBlurDefer;
          handleBlurDefer();
        };
        const pickerDisabled = computed(() => {
          return props.disabled || (form == null ? void 0 : form.disabled);
        });
        const parsedValue2 = computed(() => {
          let dayOrDays;
          if (valueIsEmpty.value) {
            if (pickerOptions.value.getDefaultValue) {
              dayOrDays = pickerOptions.value.getDefaultValue();
            }
          } else {
            if (isArray$3(props.modelValue)) {
              dayOrDays = props.modelValue.map((d2) => parseDate(d2, props.valueFormat, lang.value));
            } else {
              dayOrDays = parseDate(props.modelValue, props.valueFormat, lang.value);
            }
          }
          if (pickerOptions.value.getRangeAvailableTime) {
            const availableResult = pickerOptions.value.getRangeAvailableTime(dayOrDays);
            if (!isEqual$1(availableResult, dayOrDays)) {
              dayOrDays = availableResult;
              emitInput(isArray$3(dayOrDays) ? dayOrDays.map((_2) => _2.toDate()) : dayOrDays.toDate());
            }
          }
          if (isArray$3(dayOrDays) && dayOrDays.some((day) => !day)) {
            dayOrDays = [];
          }
          return dayOrDays;
        });
        const displayValue = computed(() => {
          if (!pickerOptions.value.panelReady)
            return "";
          const formattedValue = formatDayjsToString(parsedValue2.value);
          if (isArray$3(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 ? formattedValue.join(", ") : formattedValue;
          }
          return "";
        });
        const isTimeLikePicker = computed(() => props.type.includes("time"));
        const isTimePicker = computed(() => props.type.startsWith("time"));
        const isDatesPicker = computed(() => props.type === "dates");
        const triggerIcon = computed(() => props.prefixIcon || (isTimeLikePicker.value ? clock_default : calendar_default));
        const showClose = ref(false);
        const onClearIconClick = (event) => {
          if (props.readonly || pickerDisabled.value)
            return;
          if (showClose.value) {
            event.stopPropagation();
            focusOnInputBox();
            emitInput(null);
            emitChange(null, true);
            showClose.value = false;
            pickerVisible.value = false;
            pickerOptions.value.handleClear && pickerOptions.value.handleClear();
          }
        };
        const valueIsEmpty = computed(() => {
          const { modelValue } = props;
          return !modelValue || isArray$3(modelValue) && !modelValue.filter(Boolean).length;
        });
        const onMouseDownInput = async (event) => {
          var _a2;
          if (props.readonly || pickerDisabled.value)
            return;
          if (((_a2 = event.target) == null ? void 0 : _a2.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
            pickerVisible.value = true;
          }
        };
        const onMouseEnter = () => {
          if (props.readonly || pickerDisabled.value)
            return;
          if (!valueIsEmpty.value && props.clearable) {
            showClose.value = true;
          }
        };
        const onMouseLeave = () => {
          showClose.value = false;
        };
        const onTouchStartInput = (event) => {
          var _a2;
          if (props.readonly || pickerDisabled.value)
            return;
          if (((_a2 = event.touches[0].target) == null ? void 0 : _a2.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
            pickerVisible.value = true;
          }
        };
        const isRangeInput = computed(() => {
          return props.type.includes("range");
        });
        const pickerSize = useFormSize();
        const popperEl = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = unref(refPopper)) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
        });
        const actualInputRef = computed(() => {
          var _a2;
          if (unref(isRangeInput)) {
            return unref(inputRef);
          }
          return (_a2 = unref(inputRef)) == null ? void 0 : _a2.$el;
        });
        onClickOutside(actualInputRef, (e) => {
          const unrefedPopperEl = unref(popperEl);
          const inputEl = unref(actualInputRef);
          if (unrefedPopperEl && (e.target === unrefedPopperEl || e.composedPath().includes(unrefedPopperEl)) || e.target === inputEl || e.composedPath().includes(inputEl))
            return;
          pickerVisible.value = false;
        });
        const userInput = ref(null);
        const handleChange = () => {
          if (userInput.value) {
            const value = parseUserInputToDayjs(displayValue.value);
            if (value) {
              if (isValidValue2(value)) {
                emitInput(isArray$3(value) ? value.map((_2) => _2.toDate()) : value.toDate());
                userInput.value = null;
              }
            }
          }
          if (userInput.value === "") {
            emitInput(null);
            emitChange(null);
            userInput.value = null;
          }
        };
        const parseUserInputToDayjs = (value) => {
          if (!value)
            return null;
          return pickerOptions.value.parseUserInput(value);
        };
        const formatDayjsToString = (value) => {
          if (!value)
            return null;
          return pickerOptions.value.formatToString(value);
        };
        const isValidValue2 = (value) => {
          return pickerOptions.value.isValidValue(value);
        };
        const handleKeydownInput = async (event) => {
          if (props.readonly || pickerDisabled.value)
            return;
          const { code } = 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 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 (userInput.value === null || userInput.value === "" || isValidValue2(parseUserInputToDayjs(displayValue.value))) {
              handleChange();
              pickerVisible.value = false;
            }
            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 _a2;
          const values = userInput.value;
          const value = parseUserInputToDayjs(values && values[0]);
          const parsedVal = unref(parsedValue2);
          if (value && value.isValid()) {
            userInput.value = [
              formatDayjsToString(value),
              ((_a2 = displayValue.value) == null ? void 0 : _a2[1]) || null
            ];
            const newValue = [value, parsedVal && (parsedVal[1] || null)];
            if (isValidValue2(newValue)) {
              emitInput(newValue);
              userInput.value = null;
            }
          }
        };
        const handleEndChange = () => {
          var _a2;
          const values = unref(userInput);
          const value = parseUserInputToDayjs(values && values[1]);
          const parsedVal = unref(parsedValue2);
          if (value && value.isValid()) {
            userInput.value = [
              ((_a2 = unref(displayValue)) == null ? void 0 : _a2[0]) || null,
              formatDayjsToString(value)
            ];
            const newValue = [parsedVal && parsedVal[0], value];
            if (isValidValue2(newValue)) {
              emitInput(newValue);
              userInput.value = null;
            }
          }
        };
        const pickerOptions = ref({});
        const onSetPickerOption = (e) => {
          pickerOptions.value[e[0]] = e[1];
          pickerOptions.value.panelReady = true;
        };
        const onCalendarChange = (e) => {
          emit2("calendar-change", e);
        };
        const onPanelChange = (value, mode, view) => {
          emit2("panel-change", value, mode, view);
        };
        provide("EP_PICKER_BASE", {
          props
        });
        expose({
          focus,
          handleFocusInput,
          handleBlurInput,
          handleOpen,
          handleClose,
          onPick
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElTooltip), mergeProps({
            ref_key: "refPopper",
            ref: refPopper,
            visible: pickerVisible.value,
            effect: "light",
            pure: "",
            trigger: "click"
          }, _ctx.$attrs, {
            role: "dialog",
            teleported: "",
            transition: `${unref(nsDate).namespace.value}-zoom-in-top`,
            "popper-class": [`${unref(nsDate).namespace.value}-picker__popper`, _ctx.popperClass],
            "popper-options": unref(elPopperOptions),
            "fallback-placements": ["bottom", "top", "right", "left"],
            "gpu-acceleration": false,
            "stop-popper-mouse-event": false,
            "hide-after": 0,
            persistent: "",
            onBeforeShow,
            onShow,
            onHide
          }), {
            default: withCtx(() => [
              !unref(isRangeInput) ? (openBlock(), createBlock(unref(ElInput), {
                key: 0,
                id: _ctx.id,
                ref_key: "inputRef",
                ref: inputRef,
                "container-role": "combobox",
                "model-value": unref(displayValue),
                name: _ctx.name,
                size: unref(pickerSize),
                disabled: unref(pickerDisabled),
                placeholder: _ctx.placeholder,
                class: normalizeClass([unref(nsDate).b("editor"), unref(nsDate).bm("editor", _ctx.type), _ctx.$attrs.class]),
                style: normalizeStyle(_ctx.$attrs.style),
                readonly: !_ctx.editable || _ctx.readonly || unref(isDatesPicker) || _ctx.type === "week",
                label: _ctx.label,
                tabindex: _ctx.tabindex,
                "validate-event": false,
                onInput: onUserInput,
                onFocus: handleFocusInput,
                onBlur: handleBlurInput,
                onKeydown: handleKeydownInput,
                onChange: handleChange,
                onMousedown: onMouseDownInput,
                onMouseenter: onMouseEnter,
                onMouseleave: onMouseLeave,
                onTouchstart: onTouchStartInput,
                onClick: _cache[0] || (_cache[0] = withModifiers(() => {
                }, ["stop"]))
              }, {
                prefix: withCtx(() => [
                  unref(triggerIcon) ? (openBlock(), createBlock(unref(ElIcon), {
                    key: 0,
                    class: normalizeClass(unref(nsInput).e("icon")),
                    onMousedown: withModifiers(onMouseDownInput, ["prevent"]),
                    onTouchstart: onTouchStartInput
                  }, {
                    default: withCtx(() => [
                      (openBlock(), createBlock(resolveDynamicComponent(unref(triggerIcon))))
                    ]),
                    _: 1
                  }, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true)
                ]),
                suffix: withCtx(() => [
                  showClose.value && _ctx.clearIcon ? (openBlock(), createBlock(unref(ElIcon), {
                    key: 0,
                    class: normalizeClass(`${unref(nsInput).e("icon")} clear-icon`),
                    onClick: withModifiers(onClearIconClick, ["stop"])
                  }, {
                    default: withCtx(() => [
                      (openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
                ]),
                _: 1
              }, 8, ["id", "model-value", "name", "size", "disabled", "placeholder", "class", "style", "readonly", "label", "tabindex", "onKeydown"])) : (openBlock(), createElementBlock("div", {
                key: 1,
                ref_key: "inputRef",
                ref: inputRef,
                class: normalizeClass(unref(rangeInputKls)),
                style: normalizeStyle(_ctx.$attrs.style),
                onClick: handleFocusInput,
                onMouseenter: onMouseEnter,
                onMouseleave: onMouseLeave,
                onTouchstart: onTouchStartInput,
                onKeydown: handleKeydownInput
              }, [
                unref(triggerIcon) ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 0,
                  class: normalizeClass([unref(nsInput).e("icon"), unref(nsRange).e("icon")]),
                  onMousedown: withModifiers(onMouseDownInput, ["prevent"]),
                  onTouchstart: onTouchStartInput
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(unref(triggerIcon))))
                  ]),
                  _: 1
                }, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true),
                createBaseVNode("input", {
                  id: _ctx.id && _ctx.id[0],
                  autocomplete: "off",
                  name: _ctx.name && _ctx.name[0],
                  placeholder: _ctx.startPlaceholder,
                  value: unref(displayValue) && unref(displayValue)[0],
                  disabled: unref(pickerDisabled),
                  readonly: !_ctx.editable || _ctx.readonly,
                  class: normalizeClass(unref(nsRange).b("input")),
                  onMousedown: onMouseDownInput,
                  onInput: handleStartInput,
                  onChange: handleStartChange,
                  onFocus: handleFocusInput,
                  onBlur: handleBlurInput
                }, null, 42, _hoisted_1$$),
                renderSlot(_ctx.$slots, "range-separator", {}, () => [
                  createBaseVNode("span", {
                    class: normalizeClass(unref(nsRange).b("separator"))
                  }, toDisplayString(_ctx.rangeSeparator), 3)
                ]),
                createBaseVNode("input", {
                  id: _ctx.id && _ctx.id[1],
                  autocomplete: "off",
                  name: _ctx.name && _ctx.name[1],
                  placeholder: _ctx.endPlaceholder,
                  value: unref(displayValue) && unref(displayValue)[1],
                  disabled: unref(pickerDisabled),
                  readonly: !_ctx.editable || _ctx.readonly,
                  class: normalizeClass(unref(nsRange).b("input")),
                  onMousedown: onMouseDownInput,
                  onFocus: handleFocusInput,
                  onBlur: handleBlurInput,
                  onInput: handleEndInput,
                  onChange: handleEndChange
                }, null, 42, _hoisted_2$F),
                _ctx.clearIcon ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 1,
                  class: normalizeClass(unref(clearIconKls)),
                  onClick: onClearIconClick
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : createCommentVNode("v-if", true)
              ], 38))
            ]),
            content: withCtx(() => [
              renderSlot(_ctx.$slots, "default", {
                visible: pickerVisible.value,
                actualVisible: pickerActualVisible.value,
                parsedValue: unref(parsedValue2),
                format: _ctx.format,
                dateFormat: _ctx.dateFormat,
                timeFormat: _ctx.timeFormat,
                unlinkPanels: _ctx.unlinkPanels,
                type: _ctx.type,
                defaultValue: _ctx.defaultValue,
                onPick,
                onSelectRange: setSelectionRange,
                onSetPickerOption,
                onCalendarChange,
                onPanelChange,
                onKeydown: onKeydownPopperContent,
                onMousedown: _cache[1] || (_cache[1] = withModifiers(() => {
                }, ["stop"]))
              })
            ]),
            _: 3
          }, 16, ["visible", "transition", "popper-class", "popper-options"]);
        };
      }
    });
    var CommonPicker = /* @__PURE__ */ _export_sfc$1(_sfc_main$1_, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-picker/src/common/picker.vue"]]);
    const panelTimePickerProps = buildProps({
      ...timePanelSharedProps,
      datetimeRole: String,
      parsedValue: {
        type: definePropType(Object)
      }
    });
    const useTimePanel = ({
      getAvailableHours,
      getAvailableMinutes,
      getAvailableSeconds
    }) => {
      const getAvailableTime = (date2, role, first, compareDate) => {
        const availableTimeGetters = {
          hour: getAvailableHours,
          minute: getAvailableMinutes,
          second: getAvailableSeconds
        };
        let result = date2;
        ["hour", "minute", "second"].forEach((type2) => {
          if (availableTimeGetters[type2]) {
            let availableTimeSlots;
            const method2 = availableTimeGetters[type2];
            switch (type2) {
              case "minute": {
                availableTimeSlots = method2(result.hour(), role, compareDate);
                break;
              }
              case "second": {
                availableTimeSlots = method2(result.hour(), result.minute(), role, compareDate);
                break;
              }
              default: {
                availableTimeSlots = method2(role, compareDate);
                break;
              }
            }
            if ((availableTimeSlots == null ? void 0 : availableTimeSlots.length) && !availableTimeSlots.includes(result[type2]())) {
              const pos = first ? 0 : availableTimeSlots.length - 1;
              result = result[type2](availableTimeSlots[pos]);
            }
          }
        });
        return result;
      };
      const timePickerOptions = {};
      const onSetOption = ([key, val]) => {
        timePickerOptions[key] = val;
      };
      return {
        timePickerOptions,
        getAvailableTime,
        onSetOption
      };
    };
    const makeAvailableArr = (disabledList) => {
      const trueOrNumber = (isDisabled, index2) => isDisabled || index2;
      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 = ref(props.parsedValue);
      watch(() => props.visible, (val) => {
        if (!val) {
          oldValue.value = props.parsedValue;
        }
      });
      return oldValue;
    };
    const nodeList = /* @__PURE__ */ new Map();
    let startClick;
    if (isClient) {
      document.addEventListener("mousedown", (e) => startClick = e);
      document.addEventListener("mouseup", (e) => {
        for (const handlers of nodeList.values()) {
          for (const { documentHandler } of handlers) {
            documentHandler(e, startClick);
          }
        }
      });
    }
    function createDocumentHandler(el, binding) {
      let excludes = [];
      if (Array.isArray(binding.arg)) {
        excludes = binding.arg;
      } else if (isElement$1(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 vRepeatClick = {
      beforeMount(el, binding) {
        const value = binding.value;
        const { interval = REPEAT_INTERVAL, delay = REPEAT_DELAY } = isFunction$2(value) ? {} : value;
        let intervalId;
        let delayId;
        const handler = () => isFunction$2(value) ? value() : value.handler();
        const clear2 = () => {
          if (delayId) {
            clearTimeout(delayId);
            delayId = void 0;
          }
          if (intervalId) {
            clearInterval(intervalId);
            intervalId = void 0;
          }
        };
        el.addEventListener("mousedown", (evt) => {
          if (evt.button !== 0)
            return;
          clear2();
          handler();
          document.addEventListener("mouseup", () => clear2(), {
            once: true
          });
          delayId = setTimeout(() => {
            intervalId = setInterval(() => {
              handler();
            }, interval);
          }, delay);
        });
      }
    };
    const FOCUSABLE_CHILDREN = "_trap-focus-children";
    const FOCUS_STACK = [];
    const FOCUS_HANDLER = (e) => {
      if (FOCUS_STACK.length === 0)
        return;
      const focusableElement = FOCUS_STACK[FOCUS_STACK.length - 1][FOCUSABLE_CHILDREN];
      if (focusableElement.length > 0 && e.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) {
        nextTick(() => {
          el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements$1(el);
        });
      },
      unmounted() {
        FOCUS_STACK.shift();
        if (FOCUS_STACK.length === 0) {
          document.removeEventListener("keydown", FOCUS_HANDLER);
        }
      }
    };
    var v = false, o, f, s, u, d, N, l, p, m, w, D, x, E, M, F;
    function a() {
      if (!v) {
        v = true;
        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("_", ".")) : true;
          } else
            l = false;
          p = !!i[2], m = !!i[3];
        } else
          l = p = m = false;
      }
    }
    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("", "") !== true);
    function S(e, n) {
      if (!h.canUseDOM || n && !("addEventListener" in document))
        return false;
      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 mousewheel = function(element, callback) {
      if (element && element.addEventListener) {
        const fn2 = function(event) {
          const normalized = Y(event);
          callback && Reflect.apply(callback, this, [event, normalized]);
        };
        element.addEventListener("wheel", fn2, { passive: true });
      }
    };
    const Mousewheel = {
      beforeMount(el, binding) {
        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 _hoisted_1$_ = ["onClick"];
    const _hoisted_2$E = ["onMouseenter"];
    const _sfc_main$1Z = /* @__PURE__ */ defineComponent({
      __name: "basic-time-spinner",
      props: basicTimeSpinnerProps,
      emits: ["change", "select-range", "set-option"],
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("time");
        const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
        let isScrolling = false;
        const currentScrollbar = ref();
        const listHoursRef = ref();
        const listMinutesRef = ref();
        const listSecondsRef = ref();
        const listRefsMap = {
          hours: listHoursRef,
          minutes: listMinutesRef,
          seconds: listSecondsRef
        };
        const spinnerItems = computed(() => {
          return props.showSeconds ? timeUnits$1 : timeUnits$1.slice(0, 2);
        });
        const timePartials = computed(() => {
          const { spinnerDate } = props;
          const hours = spinnerDate.hour();
          const minutes = spinnerDate.minute();
          const seconds = spinnerDate.second();
          return { hours, minutes, seconds };
        });
        const timeList = computed(() => {
          const { hours, minutes } = unref(timePartials);
          return {
            hours: getHoursList(props.role),
            minutes: getMinutesList(hours, props.role),
            seconds: getSecondsList(hours, minutes, props.role)
          };
        });
        const arrowControlTimeList = computed(() => {
          const { hours, minutes, seconds } = unref(timePartials);
          return {
            hours: buildTimeList(hours, 23),
            minutes: buildTimeList(minutes, 59),
            seconds: buildTimeList(seconds, 59)
          };
        });
        const debouncedResetScroll = debounce((type2) => {
          isScrolling = false;
          adjustCurrentSpinner(type2);
        }, 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 = (type2) => {
          let range2;
          switch (type2) {
            case "hours":
              range2 = [0, 2];
              break;
            case "minutes":
              range2 = [3, 5];
              break;
            case "seconds":
              range2 = [6, 8];
              break;
          }
          const [left2, right2] = range2;
          emit2("select-range", left2, right2);
          currentScrollbar.value = type2;
        };
        const adjustCurrentSpinner = (type2) => {
          adjustSpinner(type2, unref(timePartials)[type2]);
        };
        const adjustSpinners = () => {
          adjustCurrentSpinner("hours");
          adjustCurrentSpinner("minutes");
          adjustCurrentSpinner("seconds");
        };
        const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
        const adjustSpinner = (type2, value) => {
          if (props.arrowControl)
            return;
          const scrollbar = unref(listRefsMap[type2]);
          if (scrollbar && scrollbar.$el) {
            getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type2));
          }
        };
        const typeItemHeight = (type2) => {
          const scrollbar = unref(listRefsMap[type2]);
          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 now2 = unref(timePartials)[label];
          const total2 = currentScrollbar.value === "hours" ? 24 : 60;
          const next = findNextUnDisabled(label, now2, step, total2);
          modifyDateField(label, next);
          adjustSpinner(label, next);
          nextTick(() => emitSelectRange(label));
        };
        const findNextUnDisabled = (type2, now2, step, total2) => {
          let next = (now2 + step + total2) % total2;
          const list = unref(timeList)[type2];
          while (list[next] && next !== now2) {
            next = (next + step + total2) % total2;
          }
          return next;
        };
        const modifyDateField = (type2, value) => {
          const list = unref(timeList)[type2];
          const isDisabled = list[value];
          if (isDisabled)
            return;
          const { hours, minutes, seconds } = unref(timePartials);
          let changeTo;
          switch (type2) {
            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;
          }
          emit2("change", changeTo);
        };
        const handleClick = (type2, { value, disabled }) => {
          if (!disabled) {
            modifyDateField(type2, value);
            emitSelectRange(type2);
            adjustSpinner(type2, value);
          }
        };
        const handleScroll2 = (type2) => {
          isScrolling = true;
          debouncedResetScroll(type2);
          const value = Math.min(Math.round((getScrollbarElement(unref(listRefsMap[type2]).$el).scrollTop - (scrollBarHeight(type2) * 0.5 - 10) / typeItemHeight(type2) + 3) / typeItemHeight(type2)), type2 === "hours" ? 23 : 59);
          modifyDateField(type2, value);
        };
        const scrollBarHeight = (type2) => {
          return unref(listRefsMap[type2]).$el.offsetHeight;
        };
        const bindScrollEvent = () => {
          const bindFunction = (type2) => {
            const scrollbar = unref(listRefsMap[type2]);
            if (scrollbar && scrollbar.$el) {
              getScrollbarElement(scrollbar.$el).onscroll = () => {
                handleScroll2(type2);
              };
            }
          };
          bindFunction("hours");
          bindFunction("minutes");
          bindFunction("seconds");
        };
        onMounted(() => {
          nextTick(() => {
            !props.arrowControl && bindScrollEvent();
            adjustSpinners();
            if (props.role === "start")
              emitSelectRange("hours");
          });
        });
        const setRef2 = (scrollbar, type2) => {
          listRefsMap[type2].value = scrollbar;
        };
        emit2("set-option", [`${props.role}_scrollDown`, scrollDown]);
        emit2("set-option", [`${props.role}_emitSelectRange`, emitSelectRange]);
        watch(() => props.spinnerDate, () => {
          if (isScrolling)
            return;
          adjustSpinners();
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }])
          }, [
            !_ctx.arrowControl ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(unref(spinnerItems), (item) => {
              return openBlock(), createBlock(unref(ElScrollbar), {
                key: item,
                ref_for: true,
                ref: (scrollbar) => setRef2(scrollbar, item),
                class: normalizeClass(unref(ns).be("spinner", "wrapper")),
                "wrap-style": "max-height: inherit;",
                "view-class": unref(ns).be("spinner", "list"),
                noresize: "",
                tag: "ul",
                onMouseenter: ($event) => emitSelectRange(item),
                onMousemove: ($event) => adjustCurrentSpinner(item)
              }, {
                default: withCtx(() => [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(timeList)[item], (disabled, key) => {
                    return openBlock(), createElementBlock("li", {
                      key,
                      class: normalizeClass([
                        unref(ns).be("spinner", "item"),
                        unref(ns).is("active", key === unref(timePartials)[item]),
                        unref(ns).is("disabled", disabled)
                      ]),
                      onClick: ($event) => handleClick(item, { value: key, disabled })
                    }, [
                      item === "hours" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                        createTextVNode(toDisplayString(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + toDisplayString(getAmPmFlag(key)), 1)
                      ], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
                        createTextVNode(toDisplayString(("0" + key).slice(-2)), 1)
                      ], 64))
                    ], 10, _hoisted_1$_);
                  }), 128))
                ]),
                _: 2
              }, 1032, ["class", "view-class", "onMouseenter", "onMousemove"]);
            }), 128)) : createCommentVNode("v-if", true),
            _ctx.arrowControl ? (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(unref(spinnerItems), (item) => {
              return openBlock(), createElementBlock("div", {
                key: item,
                class: normalizeClass([unref(ns).be("spinner", "wrapper"), unref(ns).is("arrow")]),
                onMouseenter: ($event) => emitSelectRange(item)
              }, [
                withDirectives((openBlock(), createBlock(unref(ElIcon), {
                  class: normalizeClass(["arrow-up", unref(ns).be("spinner", "arrow")])
                }, {
                  default: withCtx(() => [
                    createVNode(unref(arrow_up_default))
                  ]),
                  _: 1
                }, 8, ["class"])), [
                  [unref(vRepeatClick), onDecrement]
                ]),
                withDirectives((openBlock(), createBlock(unref(ElIcon), {
                  class: normalizeClass(["arrow-down", unref(ns).be("spinner", "arrow")])
                }, {
                  default: withCtx(() => [
                    createVNode(unref(arrow_down_default))
                  ]),
                  _: 1
                }, 8, ["class"])), [
                  [unref(vRepeatClick), onIncrement]
                ]),
                createBaseVNode("ul", {
                  class: normalizeClass(unref(ns).be("spinner", "list"))
                }, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(arrowControlTimeList)[item], (time, key) => {
                    return openBlock(), createElementBlock("li", {
                      key,
                      class: normalizeClass([
                        unref(ns).be("spinner", "item"),
                        unref(ns).is("active", time === unref(timePartials)[item]),
                        unref(ns).is("disabled", unref(timeList)[item][time])
                      ])
                    }, [
                      typeof time === "number" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                        item === "hours" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                          createTextVNode(toDisplayString(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + toDisplayString(getAmPmFlag(time)), 1)
                        ], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
                          createTextVNode(toDisplayString(("0" + time).slice(-2)), 1)
                        ], 64))
                      ], 64)) : createCommentVNode("v-if", true)
                    ], 2);
                  }), 128))
                ], 2)
              ], 42, _hoisted_2$E);
            }), 128)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var TimeSpinner = /* @__PURE__ */ _export_sfc$1(_sfc_main$1Z, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-picker/src/time-picker-com/basic-time-spinner.vue"]]);
    const _sfc_main$1Y = /* @__PURE__ */ defineComponent({
      __name: "panel-time-pick",
      props: panelTimePickerProps,
      emits: ["pick", "select-range", "set-picker-option"],
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const pickerBase = inject("EP_PICKER_BASE");
        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 = ref([0, 2]);
        const oldValue = useOldValue(props);
        const transitionName = computed(() => {
          return isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
        });
        const showSeconds = computed(() => {
          return props.format.includes("ss");
        });
        const amPmMode = computed(() => {
          if (props.format.includes("A"))
            return "A";
          if (props.format.includes("a"))
            return "a";
          return "";
        });
        const isValidValue2 = (_date) => {
          const parsedDate = dayjs(_date).locale(lang.value);
          const result = getRangeAvailableTime(parsedDate);
          return parsedDate.isSame(result);
        };
        const handleCancel = () => {
          emit2("pick", oldValue.value, false);
        };
        const handleConfirm = (visible = false, first = false) => {
          if (first)
            return;
          emit2("pick", props.parsedValue, visible);
        };
        const handleChange = (_date) => {
          if (!props.visible) {
            return;
          }
          const result = getRangeAvailableTime(_date).millisecond(0);
          emit2("pick", result, true);
        };
        const setSelectionRange = (start, end2) => {
          emit2("select-range", start, end2);
          selectionRange.value = [start, end2];
        };
        const changeSelectionRange = (step) => {
          const list = [0, 3].concat(showSeconds.value ? [6] : []);
          const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
          const index2 = list.indexOf(selectionRange.value[0]);
          const next = (index2 + step + list.length) % list.length;
          timePickerOptions["start_emitSelectRange"](mapping[next]);
        };
        const handleKeydown = (event) => {
          const code = event.code;
          const { left: left2, right: right2, up: up2, down: down2 } = EVENT_CODE;
          if ([left2, right2].includes(code)) {
            const step = code === left2 ? -1 : 1;
            changeSelectionRange(step);
            event.preventDefault();
            return;
          }
          if ([up2, down2].includes(code)) {
            const step = code === up2 ? -1 : 1;
            timePickerOptions["start_scrollDown"](step);
            event.preventDefault();
            return;
          }
        };
        const { timePickerOptions, onSetOption, getAvailableTime } = useTimePanel({
          getAvailableHours,
          getAvailableMinutes,
          getAvailableSeconds
        });
        const getRangeAvailableTime = (date2) => {
          return getAvailableTime(date2, props.datetimeRole || "", true);
        };
        const parseUserInput = (value) => {
          if (!value)
            return null;
          return dayjs(value, props.format).locale(lang.value);
        };
        const formatToString = (value) => {
          if (!value)
            return null;
          return value.format(props.format);
        };
        const getDefaultValue2 = () => {
          return dayjs(defaultValue).locale(lang.value);
        };
        emit2("set-picker-option", ["isValidValue", isValidValue2]);
        emit2("set-picker-option", ["formatToString", formatToString]);
        emit2("set-picker-option", ["parseUserInput", parseUserInput]);
        emit2("set-picker-option", ["handleKeydownInput", handleKeydown]);
        emit2("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
        emit2("set-picker-option", ["getDefaultValue", getDefaultValue2]);
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Transition, { name: unref(transitionName) }, {
            default: withCtx(() => [
              _ctx.actualVisible || _ctx.visible ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ns).b("panel"))
              }, [
                createBaseVNode("div", {
                  class: normalizeClass([unref(ns).be("panel", "content"), { "has-seconds": unref(showSeconds) }])
                }, [
                  createVNode(TimeSpinner, {
                    ref: "spinner",
                    role: _ctx.datetimeRole || "start",
                    "arrow-control": unref(arrowControl),
                    "show-seconds": unref(showSeconds),
                    "am-pm-mode": unref(amPmMode),
                    "spinner-date": _ctx.parsedValue,
                    "disabled-hours": unref(disabledHours),
                    "disabled-minutes": unref(disabledMinutes),
                    "disabled-seconds": unref(disabledSeconds),
                    onChange: handleChange,
                    onSetOption: unref(onSetOption),
                    onSelectRange: setSelectionRange
                  }, null, 8, ["role", "arrow-control", "show-seconds", "am-pm-mode", "spinner-date", "disabled-hours", "disabled-minutes", "disabled-seconds", "onSetOption"])
                ], 2),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).be("panel", "footer"))
                }, [
                  createBaseVNode("button", {
                    type: "button",
                    class: normalizeClass([unref(ns).be("panel", "btn"), "cancel"]),
                    onClick: handleCancel
                  }, toDisplayString(unref(t)("el.datepicker.cancel")), 3),
                  createBaseVNode("button", {
                    type: "button",
                    class: normalizeClass([unref(ns).be("panel", "btn"), "confirm"]),
                    onClick: _cache[0] || (_cache[0] = ($event) => handleConfirm())
                  }, toDisplayString(unref(t)("el.datepicker.confirm")), 3)
                ], 2)
              ], 2)) : createCommentVNode("v-if", true)
            ]),
            _: 1
          }, 8, ["name"]);
        };
      }
    });
    var TimePickPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1Y, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-picker/src/time-picker-com/panel-time-pick.vue"]]);
    const panelTimeRangeProps = buildProps({
      ...timePanelSharedProps,
      parsedValue: {
        type: definePropType(Array)
      }
    });
    const _hoisted_1$Z = ["disabled"];
    const _sfc_main$1X = /* @__PURE__ */ defineComponent({
      __name: "panel-time-range",
      props: panelTimeRangeProps,
      emits: ["pick", "select-range", "set-picker-option"],
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const makeSelectRange = (start, end2) => {
          const result = [];
          for (let i = start; i <= end2; i++) {
            result.push(i);
          }
          return result;
        };
        const { t, lang } = useLocale();
        const nsTime = useNamespace("time");
        const nsPicker = useNamespace("picker");
        const pickerBase = inject("EP_PICKER_BASE");
        const {
          arrowControl,
          disabledHours,
          disabledMinutes,
          disabledSeconds,
          defaultValue
        } = pickerBase.props;
        const startContainerKls = computed(() => [
          nsTime.be("range-picker", "body"),
          nsTime.be("panel", "content"),
          nsTime.is("arrow", arrowControl),
          showSeconds.value ? "has-seconds" : ""
        ]);
        const endContainerKls = computed(() => [
          nsTime.be("range-picker", "body"),
          nsTime.be("panel", "content"),
          nsTime.is("arrow", arrowControl),
          showSeconds.value ? "has-seconds" : ""
        ]);
        const startTime = computed(() => props.parsedValue[0]);
        const endTime = computed(() => props.parsedValue[1]);
        const oldValue = useOldValue(props);
        const handleCancel = () => {
          emit2("pick", oldValue.value, false);
        };
        const showSeconds = computed(() => {
          return props.format.includes("ss");
        });
        const amPmMode = computed(() => {
          if (props.format.includes("A"))
            return "A";
          if (props.format.includes("a"))
            return "a";
          return "";
        });
        const handleConfirm = (visible = false) => {
          emit2("pick", [startTime.value, endTime.value], visible);
        };
        const handleMinChange = (date2) => {
          handleChange(date2.millisecond(0), endTime.value);
        };
        const handleMaxChange = (date2) => {
          handleChange(startTime.value, date2.millisecond(0));
        };
        const isValidValue2 = (_date) => {
          const parsedDate = _date.map((_2) => dayjs(_2).locale(lang.value));
          const result = getRangeAvailableTime(parsedDate);
          return parsedDate[0].isSame(result[0]) && parsedDate[1].isSame(result[1]);
        };
        const handleChange = (start, end2) => {
          emit2("pick", [start, end2], true);
        };
        const btnConfirmDisabled = computed(() => {
          return startTime.value > endTime.value;
        });
        const selectionRange = ref([0, 2]);
        const setMinSelectionRange = (start, end2) => {
          emit2("select-range", start, end2, "min");
          selectionRange.value = [start, end2];
        };
        const offset2 = computed(() => showSeconds.value ? 11 : 8);
        const setMaxSelectionRange = (start, end2) => {
          emit2("select-range", start, end2, "max");
          const _offset = unref(offset2);
          selectionRange.value = [start + _offset, end2 + _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 index2 = list.indexOf(selectionRange.value[0]);
          const next = (index2 + 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 = event.code;
          const { left: left2, right: right2, up: up2, down: down2 } = EVENT_CODE;
          if ([left2, right2].includes(code)) {
            const step = code === left2 ? -1 : 1;
            changeSelectionRange(step);
            event.preventDefault();
            return;
          }
          if ([up2, down2].includes(code)) {
            const step = code === up2 ? -1 : 1;
            const role = selectionRange.value[0] < offset2.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$1(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$1(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$1(defaultDisable, nextDisable);
        };
        const getRangeAvailableTime = ([start, end2]) => {
          return [
            getAvailableTime(start, "start", true, end2),
            getAvailableTime(end2, "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$3(days)) {
            return days.map((d2) => dayjs(d2, props.format).locale(lang.value));
          }
          return dayjs(days, props.format).locale(lang.value);
        };
        const formatToString = (days) => {
          if (!days)
            return null;
          if (isArray$3(days)) {
            return days.map((d2) => d2.format(props.format));
          }
          return days.format(props.format);
        };
        const getDefaultValue2 = () => {
          if (isArray$3(defaultValue)) {
            return defaultValue.map((d2) => dayjs(d2).locale(lang.value));
          }
          const defaultDay = dayjs(defaultValue).locale(lang.value);
          return [defaultDay, defaultDay.add(60, "m")];
        };
        emit2("set-picker-option", ["formatToString", formatToString]);
        emit2("set-picker-option", ["parseUserInput", parseUserInput]);
        emit2("set-picker-option", ["isValidValue", isValidValue2]);
        emit2("set-picker-option", ["handleKeydownInput", handleKeydown]);
        emit2("set-picker-option", ["getDefaultValue", getDefaultValue2]);
        emit2("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
        return (_ctx, _cache) => {
          return _ctx.actualVisible ? (openBlock(), createElementBlock("div", {
            key: 0,
            class: normalizeClass([unref(nsTime).b("range-picker"), unref(nsPicker).b("panel")])
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(nsTime).be("range-picker", "content"))
            }, [
              createBaseVNode("div", {
                class: normalizeClass(unref(nsTime).be("range-picker", "cell"))
              }, [
                createBaseVNode("div", {
                  class: normalizeClass(unref(nsTime).be("range-picker", "header"))
                }, toDisplayString(unref(t)("el.datepicker.startTime")), 3),
                createBaseVNode("div", {
                  class: normalizeClass(unref(startContainerKls))
                }, [
                  createVNode(TimeSpinner, {
                    ref: "minSpinner",
                    role: "start",
                    "show-seconds": unref(showSeconds),
                    "am-pm-mode": unref(amPmMode),
                    "arrow-control": unref(arrowControl),
                    "spinner-date": unref(startTime),
                    "disabled-hours": disabledHours_,
                    "disabled-minutes": disabledMinutes_,
                    "disabled-seconds": disabledSeconds_,
                    onChange: handleMinChange,
                    onSetOption: unref(onSetOption),
                    onSelectRange: setMinSelectionRange
                  }, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
                ], 2)
              ], 2),
              createBaseVNode("div", {
                class: normalizeClass(unref(nsTime).be("range-picker", "cell"))
              }, [
                createBaseVNode("div", {
                  class: normalizeClass(unref(nsTime).be("range-picker", "header"))
                }, toDisplayString(unref(t)("el.datepicker.endTime")), 3),
                createBaseVNode("div", {
                  class: normalizeClass(unref(endContainerKls))
                }, [
                  createVNode(TimeSpinner, {
                    ref: "maxSpinner",
                    role: "end",
                    "show-seconds": unref(showSeconds),
                    "am-pm-mode": unref(amPmMode),
                    "arrow-control": unref(arrowControl),
                    "spinner-date": unref(endTime),
                    "disabled-hours": disabledHours_,
                    "disabled-minutes": disabledMinutes_,
                    "disabled-seconds": disabledSeconds_,
                    onChange: handleMaxChange,
                    onSetOption: unref(onSetOption),
                    onSelectRange: setMaxSelectionRange
                  }, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
                ], 2)
              ], 2)
            ], 2),
            createBaseVNode("div", {
              class: normalizeClass(unref(nsTime).be("panel", "footer"))
            }, [
              createBaseVNode("button", {
                type: "button",
                class: normalizeClass([unref(nsTime).be("panel", "btn"), "cancel"]),
                onClick: _cache[0] || (_cache[0] = ($event) => handleCancel())
              }, toDisplayString(unref(t)("el.datepicker.cancel")), 3),
              createBaseVNode("button", {
                type: "button",
                class: normalizeClass([unref(nsTime).be("panel", "btn"), "confirm"]),
                disabled: unref(btnConfirmDisabled),
                onClick: _cache[1] || (_cache[1] = ($event) => handleConfirm())
              }, toDisplayString(unref(t)("el.datepicker.confirm")), 11, _hoisted_1$Z)
            ], 2)
          ], 2)) : createCommentVNode("v-if", true);
        };
      }
    });
    var TimeRangePanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1X, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-picker/src/time-picker-com/panel-time-range.vue"]]);
    dayjs.extend(customParseFormat);
    var TimePicker = /* @__PURE__ */ defineComponent({
      name: "ElTimePicker",
      install: null,
      props: {
        ...timePickerDefaultProps,
        isRange: {
          type: Boolean,
          default: false
        }
      },
      emits: ["update:modelValue"],
      setup(props, ctx) {
        const commonPicker = ref();
        const [type2, Panel] = props.isRange ? ["timerange", TimeRangePanel] : ["time", TimePickPanel];
        const modelUpdater = (value) => ctx.emit("update:modelValue", value);
        provide("ElPopperOptions", props.popperOptions);
        ctx.expose({
          focus: (e) => {
            var _a2;
            (_a2 = commonPicker.value) == null ? void 0 : _a2.handleFocusInput(e);
          },
          blur: (e) => {
            var _a2;
            (_a2 = commonPicker.value) == null ? void 0 : _a2.handleBlurInput(e);
          },
          handleOpen: () => {
            var _a2;
            (_a2 = commonPicker.value) == null ? void 0 : _a2.handleOpen();
          },
          handleClose: () => {
            var _a2;
            (_a2 = commonPicker.value) == null ? void 0 : _a2.handleClose();
          }
        });
        return () => {
          var _a2;
          const format2 = (_a2 = props.format) != null ? _a2 : DEFAULT_FORMATS_TIME;
          return createVNode(CommonPicker, mergeProps(props, {
            "ref": commonPicker,
            "type": type2,
            "format": format2,
            "onUpdate:modelValue": modelUpdater
          }), {
            default: (props2) => createVNode(Panel, props2, null)
          });
        };
      }
    });
    const _TimePicker = TimePicker;
    _TimePicker.install = (app) => {
      app.component(_TimePicker.name, _TimePicker);
    };
    const ElTimePicker = _TimePicker;
    const getPrevMonthLastDays = (date2, count) => {
      const lastDay = date2.subtract(1, "month").endOf("month").date();
      return rangeArr(count).map((_2, index2) => lastDay - (count - index2 - 1));
    };
    const getMonthDays = (date2) => {
      const days = date2.daysInMonth();
      return rangeArr(days).map((_2, index2) => index2 + 1);
    };
    const toNestedArr = (days) => rangeArr(days.length / 7).map((index2) => {
      const start = index2 * 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(module2, exports2) {
      !function(n, e) {
        module2.exports = e();
      }(commonjsGlobal, function() {
        return function(n, e, t) {
          var r = e.prototype, o2 = function(n2) {
            return n2 && (n2.indexOf ? n2 : n2.s);
          }, u2 = function(n2, e2, t2, r2, u3) {
            var i2 = n2.name ? n2 : n2.$locale(), a3 = o2(i2[e2]), s3 = o2(i2[t2]), f2 = a3 || s3.map(function(n3) {
              return n3.slice(0, r2);
            });
            if (!u3)
              return f2;
            var d2 = i2.weekStart;
            return f2.map(function(n3, e3) {
              return f2[(e3 + (d2 || 0)) % 7];
            });
          }, i = function() {
            return t.Ls[t.locale()];
          }, a2 = 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()]);
          }, s2 = function() {
            var n2 = this;
            return { months: function(e2) {
              return e2 ? e2.format("MMMM") : u2(n2, "months");
            }, monthsShort: function(e2) {
              return e2 ? e2.format("MMM") : u2(n2, "monthsShort", "months", 3);
            }, firstDayOfWeek: function() {
              return n2.$locale().weekStart || 0;
            }, weekdays: function(e2) {
              return e2 ? e2.format("dddd") : u2(n2, "weekdays");
            }, weekdaysMin: function(e2) {
              return e2 ? e2.format("dd") : u2(n2, "weekdaysMin", "weekdays", 2);
            }, weekdaysShort: function(e2) {
              return e2 ? e2.format("ddd") : u2(n2, "weekdaysShort", "weekdays", 3);
            }, longDateFormat: function(e2) {
              return a2(n2.$locale(), e2);
            }, meridiem: this.$locale().meridiem, ordinal: this.$locale().ordinal };
          };
          r.localeData = function() {
            return s2.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 a2(n2, e2);
            }, meridiem: n2.meridiem, ordinal: n2.ordinal };
          }, t.months = function() {
            return u2(i(), "months");
          }, t.monthsShort = function() {
            return u2(i(), "monthsShort", "months", 3);
          }, t.weekdays = function(n2) {
            return u2(i(), "weekdays", null, null, n2);
          }, t.weekdaysShort = function(n2) {
            return u2(i(), "weekdaysShort", "weekdays", 3, n2);
          }, t.weekdaysMin = function(n2) {
            return u2(i(), "weekdaysMin", "weekdays", 2, n2);
          };
        };
      });
    })(localeData$1);
    var localeDataExports = localeData$1.exports;
    const localeData = /* @__PURE__ */ getDefaultExportFromCjs(localeDataExports);
    const useDateTable = (props, emit2) => {
      dayjs.extend(localeData);
      const firstDayOfWeek = dayjs.localeData().firstDayOfWeek();
      const { t, lang } = useLocale();
      const now2 = dayjs().locale(lang.value);
      const isInRange = computed(() => !!props.range && !!props.range.length);
      const rows = computed(() => {
        let days = [];
        if (isInRange.value) {
          const [start, end2] = props.range;
          const currentMonthRange = rangeArr(end2.date() - start.date() + 1).map((index2) => ({
            text: start.date() + index2,
            type: "current"
          }));
          let remaining = currentMonthRange.length % 7;
          remaining = remaining === 0 ? 0 : 7 - remaining;
          const nextMonthRange = rangeArr(remaining).map((_2, index2) => ({
            text: index2 + 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((_2, index2) => ({
            text: index2 + 1,
            type: "next"
          }));
          days = days.concat(nextMonthDays);
        }
        return toNestedArr(days);
      });
      const weekDays = computed(() => {
        const start = firstDayOfWeek;
        if (start === 0) {
          return WEEK_DAYS.map((_2) => t(`el.datepicker.weeks.${_2}`));
        } else {
          return WEEK_DAYS.slice(start).concat(WEEK_DAYS.slice(0, start)).map((_2) => t(`el.datepicker.weeks.${_2}`));
        }
      });
      const getFormattedDate = (day, type2) => {
        switch (type2) {
          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: type2 }) => {
        const date2 = getFormattedDate(text, type2);
        emit2("pick", date2);
      };
      const getSlotData = ({ text, type: type2 }) => {
        const day = getFormattedDate(text, type2);
        return {
          isSelected: day.isSame(props.selectedDay),
          type: `${type2}-month`,
          day: day.format("YYYY-MM-DD"),
          date: day.toDate()
        };
      };
      return {
        now: now2,
        isInRange,
        rows,
        weekDays,
        getFormattedDate,
        handlePickDay,
        getSlotData
      };
    };
    const _hoisted_1$Y = { key: 0 };
    const _hoisted_2$D = ["onClick"];
    const __default__$1g = /* @__PURE__ */ defineComponent({
      name: "DateTable"
    });
    const _sfc_main$1W = /* @__PURE__ */ defineComponent({
      ...__default__$1g,
      props: dateTableProps,
      emits: dateTableEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const {
          isInRange,
          now: now2,
          rows,
          weekDays,
          getFormattedDate,
          handlePickDay,
          getSlotData
        } = useDateTable(props, emit2);
        const nsTable = useNamespace("calendar-table");
        const nsDay = useNamespace("calendar-day");
        const getCellClass = ({ text, type: type2 }) => {
          const classes = [type2];
          if (type2 === "current") {
            const date2 = getFormattedDate(text, type2);
            if (date2.isSame(props.selectedDay, "day")) {
              classes.push(nsDay.is("selected"));
            }
            if (date2.isSame(now2, "day")) {
              classes.push(nsDay.is("today"));
            }
          }
          return classes;
        };
        expose({
          getFormattedDate
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("table", {
            class: normalizeClass([unref(nsTable).b(), unref(nsTable).is("range", unref(isInRange))]),
            cellspacing: "0",
            cellpadding: "0"
          }, [
            !_ctx.hideHeader ? (openBlock(), createElementBlock("thead", _hoisted_1$Y, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(weekDays), (day) => {
                return openBlock(), createElementBlock("th", { key: day }, toDisplayString(day), 1);
              }), 128))
            ])) : createCommentVNode("v-if", true),
            createBaseVNode("tbody", null, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, index2) => {
                return openBlock(), createElementBlock("tr", {
                  key: index2,
                  class: normalizeClass({
                    [unref(nsTable).e("row")]: true,
                    [unref(nsTable).em("row", "hide-border")]: index2 === 0 && _ctx.hideHeader
                  })
                }, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(row, (cell, key) => {
                    return openBlock(), createElementBlock("td", {
                      key,
                      class: normalizeClass(getCellClass(cell)),
                      onClick: ($event) => unref(handlePickDay)(cell)
                    }, [
                      createBaseVNode("div", {
                        class: normalizeClass(unref(nsDay).b())
                      }, [
                        renderSlot(_ctx.$slots, "date-cell", {
                          data: unref(getSlotData)(cell)
                        }, () => [
                          createBaseVNode("span", null, toDisplayString(cell.text), 1)
                        ])
                      ], 2)
                    ], 10, _hoisted_2$D);
                  }), 128))
                ], 2);
              }), 128))
            ])
          ], 2);
        };
      }
    });
    var DateTable$1 = /* @__PURE__ */ _export_sfc$1(_sfc_main$1W, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/calendar/src/date-table.vue"]]);
    const adjacentMonth = (start, end2) => {
      const firstMonthLastDay = start.endOf("month");
      const lastMonthFirstDay = end2.startOf("month");
      const isSameWeek = firstMonthLastDay.isSame(lastMonthFirstDay, "week");
      const lastMonthStartDay = isSameWeek ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
      return [
        [start, firstMonthLastDay],
        [lastMonthStartDay.startOf("week"), end2]
      ];
    };
    const threeConsecutiveMonth = (start, end2) => {
      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 = end2.startOf("month");
      const lastMonthStartDay = secondMonthLastDay.isSame(lastMonthFirstDay, "week") ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
      return [
        [start, firstMonthLastDay],
        [secondMonthStartDay.startOf("week"), secondMonthLastDay],
        [lastMonthStartDay.startOf("week"), end2]
      ];
    };
    const useCalendar = (props, emit2, componentName2) => {
      const slots = useSlots();
      const { lang } = useLocale();
      const selectedDay = ref();
      const now2 = dayjs().locale(lang.value);
      const realSelectedDay = computed({
        get() {
          if (!props.modelValue)
            return selectedDay.value;
          return date2.value;
        },
        set(val) {
          if (!val)
            return;
          selectedDay.value = val;
          const result = val.toDate();
          emit2(INPUT_EVENT, result);
          emit2(UPDATE_MODEL_EVENT, result);
        }
      });
      const validatedRange = computed(() => {
        if (!props.range)
          return [];
        const rangeArrDayjs = props.range.map((_2) => dayjs(_2).locale(lang.value));
        const [startDayjs, endDayjs] = rangeArrDayjs;
        if (startDayjs.isAfter(endDayjs)) {
          return [];
        }
        if (startDayjs.isSame(endDayjs, "month")) {
          return calculateValidatedDateRange(startDayjs, endDayjs);
        } else {
          if (startDayjs.add(1, "month").month() !== endDayjs.month()) {
            return [];
          }
          return calculateValidatedDateRange(startDayjs, endDayjs);
        }
      });
      const date2 = computed(() => {
        if (!props.modelValue) {
          return realSelectedDay.value || (validatedRange.value.length ? validatedRange.value[0][0] : now2);
        } else {
          return dayjs(props.modelValue).locale(lang.value);
        }
      });
      const prevMonthDayjs = computed(() => date2.value.subtract(1, "month").date(1));
      const nextMonthDayjs = computed(() => date2.value.add(1, "month").date(1));
      const prevYearDayjs = computed(() => date2.value.subtract(1, "year").date(1));
      const nextYearDayjs = computed(() => date2.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 {
          return [];
        }
      };
      const pickDay = (day) => {
        realSelectedDay.value = day;
      };
      const selectDate = (type2) => {
        const dateMap = {
          "prev-month": prevMonthDayjs.value,
          "next-month": nextMonthDayjs.value,
          "prev-year": prevYearDayjs.value,
          "next-year": nextYearDayjs.value,
          today: now2
        };
        const day = dateMap[type2];
        if (!day.isSame(date2.value, "day")) {
          pickDay(day);
        }
      };
      useDeprecated({
        from: '"dateCell"',
        replacement: '"date-cell"',
        scope: "ElCalendar",
        version: "2.3.0",
        ref: "https://element-plus.org/en-US/component/calendar.html#slots",
        type: "Slot"
      }, computed(() => !!slots.dateCell));
      return {
        calculateValidatedDateRange,
        date: date2,
        realSelectedDay,
        pickDay,
        selectDate,
        validatedRange
      };
    };
    const isValidRange$1 = (range2) => isArray$3(range2) && range2.length === 2 && range2.every((item) => isDate(item));
    const calendarProps = buildProps({
      modelValue: {
        type: Date
      },
      range: {
        type: definePropType(Array),
        validator: isValidRange$1
      }
    });
    const calendarEmits = {
      [UPDATE_MODEL_EVENT]: (value) => isDate(value),
      [INPUT_EVENT]: (value) => isDate(value)
    };
    const COMPONENT_NAME$g = "ElCalendar";
    const __default__$1f = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$g
    });
    const _sfc_main$1V = /* @__PURE__ */ defineComponent({
      ...__default__$1f,
      props: calendarProps,
      emits: calendarEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("calendar");
        const {
          calculateValidatedDateRange,
          date: date2,
          pickDay,
          realSelectedDay,
          selectDate,
          validatedRange
        } = useCalendar(props, emit2);
        const { t } = useLocale();
        const i18nDate = computed(() => {
          const pickedMonth = `el.datepicker.month${date2.value.format("M")}`;
          return `${date2.value.year()} ${t("el.datepicker.year")} ${t(pickedMonth)}`;
        });
        expose({
          selectedDay: realSelectedDay,
          pickDay,
          selectDate,
          calculateValidatedDateRange
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(ns).b())
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("header"))
            }, [
              renderSlot(_ctx.$slots, "header", { date: unref(i18nDate) }, () => [
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("title"))
                }, toDisplayString(unref(i18nDate)), 3),
                unref(validatedRange).length === 0 ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  class: normalizeClass(unref(ns).e("button-group"))
                }, [
                  createVNode(unref(ElButtonGroup$1), null, {
                    default: withCtx(() => [
                      createVNode(unref(ElButton), {
                        size: "small",
                        onClick: _cache[0] || (_cache[0] = ($event) => unref(selectDate)("prev-month"))
                      }, {
                        default: withCtx(() => [
                          createTextVNode(toDisplayString(unref(t)("el.datepicker.prevMonth")), 1)
                        ]),
                        _: 1
                      }),
                      createVNode(unref(ElButton), {
                        size: "small",
                        onClick: _cache[1] || (_cache[1] = ($event) => unref(selectDate)("today"))
                      }, {
                        default: withCtx(() => [
                          createTextVNode(toDisplayString(unref(t)("el.datepicker.today")), 1)
                        ]),
                        _: 1
                      }),
                      createVNode(unref(ElButton), {
                        size: "small",
                        onClick: _cache[2] || (_cache[2] = ($event) => unref(selectDate)("next-month"))
                      }, {
                        default: withCtx(() => [
                          createTextVNode(toDisplayString(unref(t)("el.datepicker.nextMonth")), 1)
                        ]),
                        _: 1
                      })
                    ]),
                    _: 1
                  })
                ], 2)) : createCommentVNode("v-if", true)
              ])
            ], 2),
            unref(validatedRange).length === 0 ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("body"))
            }, [
              createVNode(DateTable$1, {
                date: unref(date2),
                "selected-day": unref(realSelectedDay),
                onPick: unref(pickDay)
              }, createSlots({ _: 2 }, [
                _ctx.$slots["date-cell"] || _ctx.$slots.dateCell ? {
                  name: "date-cell",
                  fn: withCtx((data) => [
                    _ctx.$slots["date-cell"] ? renderSlot(_ctx.$slots, "date-cell", normalizeProps(mergeProps({ key: 0 }, data))) : renderSlot(_ctx.$slots, "dateCell", normalizeProps(mergeProps({ key: 1 }, data)))
                  ])
                } : void 0
              ]), 1032, ["date", "selected-day", "onPick"])
            ], 2)) : (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(unref(ns).e("body"))
            }, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(validatedRange), (range_, index2) => {
                return openBlock(), createBlock(DateTable$1, {
                  key: index2,
                  date: range_[0],
                  "selected-day": unref(realSelectedDay),
                  range: range_,
                  "hide-header": index2 !== 0,
                  onPick: unref(pickDay)
                }, createSlots({ _: 2 }, [
                  _ctx.$slots["date-cell"] || _ctx.$slots.dateCell ? {
                    name: "date-cell",
                    fn: withCtx((data) => [
                      _ctx.$slots["date-cell"] ? renderSlot(_ctx.$slots, "date-cell", normalizeProps(mergeProps({ key: 0 }, data))) : renderSlot(_ctx.$slots, "dateCell", normalizeProps(mergeProps({ key: 1 }, data)))
                    ])
                  } : void 0
                ]), 1032, ["date", "selected-day", "range", "hide-header", "onPick"]);
              }), 128))
            ], 2))
          ], 2);
        };
      }
    });
    var Calendar = /* @__PURE__ */ _export_sfc$1(_sfc_main$1V, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/calendar/src/calendar.vue"]]);
    const ElCalendar = withInstall(Calendar);
    const cardProps = buildProps({
      header: {
        type: String,
        default: ""
      },
      footer: {
        type: String,
        default: ""
      },
      bodyStyle: {
        type: definePropType([String, Object, Array]),
        default: ""
      },
      bodyClass: String,
      shadow: {
        type: String,
        values: ["always", "hover", "never"],
        default: "always"
      }
    });
    const __default__$1e = /* @__PURE__ */ defineComponent({
      name: "ElCard"
    });
    const _sfc_main$1U = /* @__PURE__ */ defineComponent({
      ...__default__$1e,
      props: cardProps,
      setup(__props) {
        const ns = useNamespace("card");
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).b(), unref(ns).is(`${_ctx.shadow}-shadow`)])
          }, [
            _ctx.$slots.header || _ctx.header ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("header"))
            }, [
              renderSlot(_ctx.$slots, "header", {}, () => [
                createTextVNode(toDisplayString(_ctx.header), 1)
              ])
            ], 2)) : createCommentVNode("v-if", true),
            createBaseVNode("div", {
              class: normalizeClass([unref(ns).e("body"), _ctx.bodyClass]),
              style: normalizeStyle(_ctx.bodyStyle)
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 6),
            _ctx.$slots.footer || _ctx.footer ? (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(unref(ns).e("footer"))
            }, [
              renderSlot(_ctx.$slots, "footer", {}, () => [
                createTextVNode(toDisplayString(_ctx.footer), 1)
              ])
            ], 2)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var Card = /* @__PURE__ */ _export_sfc$1(_sfc_main$1U, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/card/src/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: ""
      },
      loop: {
        type: Boolean,
        default: true
      },
      direction: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "horizontal"
      },
      pauseOnHover: {
        type: Boolean,
        default: true
      }
    });
    const carouselEmits = {
      change: (current, prev) => [current, prev].every(isNumber)
    };
    const carouselContextKey = Symbol("carouselContextKey");
    const THROTTLE_TIME = 300;
    const useCarousel = (props, emit2, componentName2) => {
      const {
        children: items,
        addChild: addItem,
        removeChild: removeItem
      } = useOrderedChildren(getCurrentInstance(), "ElCarouselItem");
      const slots = useSlots();
      const activeIndex = ref(-1);
      const timer = ref(null);
      const hover = ref(false);
      const root2 = ref();
      const containerHeight = ref(0);
      const isItemsTwoLength = ref(true);
      const arrowDisplay = computed(() => props.arrow !== "never" && !unref(isVertical));
      const hasLabel = computed(() => {
        return items.value.some((item) => item.props.label.toString().length > 0);
      });
      const isCardType = computed(() => props.type === "card");
      const isVertical = computed(() => props.direction === "vertical");
      const containerStyle = computed(() => {
        if (props.height !== "auto") {
          return {
            height: props.height
          };
        }
        return {
          height: `${containerHeight.value}px`,
          overflow: "hidden"
        };
      });
      const throttledArrowClick = throttle((index2) => {
        setActiveItem(index2);
      }, THROTTLE_TIME, { trailing: true });
      const throttledIndicatorHover = throttle((index2) => {
        handleIndicatorHover(index2);
      }, THROTTLE_TIME);
      const isTwoLengthShow = (index2) => {
        if (!isItemsTwoLength.value)
          return true;
        return activeIndex.value <= 1 ? index2 <= 1 : index2 > 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(index2) {
        if (isString$1(index2)) {
          const filteredItems = items.value.filter((item) => item.props.name === index2);
          if (filteredItems.length > 0) {
            index2 = items.value.indexOf(filteredItems[0]);
          }
        }
        index2 = Number(index2);
        if (Number.isNaN(index2) || index2 !== Math.floor(index2)) {
          return;
        }
        const itemCount = items.value.length;
        const oldIndex = activeIndex.value;
        if (index2 < 0) {
          activeIndex.value = props.loop ? itemCount - 1 : 0;
        } else if (index2 >= itemCount) {
          activeIndex.value = props.loop ? 0 : itemCount - 1;
        } else {
          activeIndex.value = index2;
        }
        if (oldIndex === activeIndex.value) {
          resetItemPosition(oldIndex);
        }
        resetTimer();
      }
      function resetItemPosition(oldIndex) {
        items.value.forEach((item, index2) => {
          item.translateItem(index2, activeIndex.value, oldIndex);
        });
      }
      function itemInStage(item, index2) {
        var _a2, _b, _c, _d;
        const _items = unref(items);
        const itemCount = _items.length;
        if (itemCount === 0 || !item.states.inStage)
          return false;
        const nextItemIndex = index2 + 1;
        const prevItemIndex = index2 - 1;
        const lastItemIndex = itemCount - 1;
        const isLastItemActive = _items[lastItemIndex].states.active;
        const isFirstItemActive = _items[0].states.active;
        const isNextItemActive = (_b = (_a2 = _items[nextItemIndex]) == null ? void 0 : _a2.states) == null ? void 0 : _b.active;
        const isPrevItemActive = (_d = (_c = _items[prevItemIndex]) == null ? void 0 : _c.states) == null ? void 0 : _d.active;
        if (index2 === lastItemIndex && isFirstItemActive || isNextItemActive) {
          return "left";
        } else if (index2 === 0 && isLastItemActive || isPrevItemActive) {
          return "right";
        }
        return false;
      }
      function handleMouseEnter() {
        hover.value = true;
        if (props.pauseOnHover) {
          pauseTimer();
        }
      }
      function handleMouseLeave() {
        hover.value = false;
        startTimer();
      }
      function handleButtonEnter(arrow2) {
        if (unref(isVertical))
          return;
        items.value.forEach((item, index2) => {
          if (arrow2 === itemInStage(item, index2)) {
            item.states.hover = true;
          }
        });
      }
      function handleButtonLeave() {
        if (unref(isVertical))
          return;
        items.value.forEach((item) => {
          item.states.hover = false;
        });
      }
      function handleIndicatorClick(index2) {
        activeIndex.value = index2;
      }
      function handleIndicatorHover(index2) {
        if (props.trigger === "hover" && index2 !== activeIndex.value) {
          activeIndex.value = index2;
        }
      }
      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 _a2;
        const defaultSlots = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
        if (!defaultSlots)
          return null;
        const flatSlots = flattedChildren(defaultSlots);
        const carouselItemsName = "ElCarouselItem";
        const normalizeSlots = flatSlots.filter((slot) => {
          return isVNode(slot) && slot.type.name === carouselItemsName;
        });
        if ((normalizeSlots == null ? void 0 : normalizeSlots.length) === 2 && props.loop && !isCardType.value) {
          isItemsTwoLength.value = true;
          return normalizeSlots;
        }
        isItemsTwoLength.value = false;
        return null;
      }
      watch(() => activeIndex.value, (current, prev2) => {
        resetItemPosition(prev2);
        if (isItemsTwoLength.value) {
          current = current % 2;
          prev2 = prev2 % 2;
        }
        if (prev2 > -1) {
          emit2("change", current, prev2);
        }
      });
      watch(() => props.autoplay, (autoplay) => {
        autoplay ? startTimer() : pauseTimer();
      });
      watch(() => props.loop, () => {
        setActiveItem(activeIndex.value);
      });
      watch(() => props.interval, () => {
        resetTimer();
      });
      const resizeObserver = shallowRef();
      onMounted(() => {
        watch(() => items.value, () => {
          if (items.value.length > 0)
            setActiveItem(props.initialIndex);
        }, {
          immediate: true
        });
        resizeObserver.value = useResizeObserver(root2.value, () => {
          resetItemPosition();
        });
        startTimer();
      });
      onBeforeUnmount(() => {
        pauseTimer();
        if (root2.value && resizeObserver.value)
          resizeObserver.value.stop();
      });
      provide(carouselContextKey, {
        root: root2,
        isCardType,
        isVertical,
        items,
        loop: props.loop,
        addItem,
        removeItem,
        setActiveItem,
        setContainerHeight
      });
      return {
        root: root2,
        activeIndex,
        arrowDisplay,
        hasLabel,
        hover,
        isCardType,
        items,
        isVertical,
        containerStyle,
        isItemsTwoLength,
        handleButtonEnter,
        handleButtonLeave,
        handleIndicatorClick,
        handleMouseEnter,
        handleMouseLeave,
        setActiveItem,
        prev,
        next,
        PlaceholderItem,
        isTwoLengthShow,
        throttledArrowClick,
        throttledIndicatorHover
      };
    };
    const _hoisted_1$X = ["onMouseenter", "onClick"];
    const _hoisted_2$C = { key: 0 };
    const COMPONENT_NAME$f = "ElCarousel";
    const __default__$1d = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$f
    });
    const _sfc_main$1T = /* @__PURE__ */ defineComponent({
      ...__default__$1d,
      props: carouselProps,
      emits: carouselEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const {
          root: root2,
          activeIndex,
          arrowDisplay,
          hasLabel,
          hover,
          isCardType,
          items,
          isVertical,
          containerStyle,
          handleButtonEnter,
          handleButtonLeave,
          handleIndicatorClick,
          handleMouseEnter,
          handleMouseLeave,
          setActiveItem,
          prev,
          next,
          PlaceholderItem,
          isTwoLengthShow,
          throttledArrowClick,
          throttledIndicatorHover
        } = useCarousel(props, emit2);
        const ns = useNamespace("carousel");
        const carouselClasses = computed(() => {
          const classes = [ns.b(), ns.m(props.direction)];
          if (unref(isCardType)) {
            classes.push(ns.m("card"));
          }
          return classes;
        });
        const indicatorsClasses = computed(() => {
          const classes = [ns.e("indicators"), ns.em("indicators", props.direction)];
          if (unref(hasLabel)) {
            classes.push(ns.em("indicators", "labels"));
          }
          if (props.indicatorPosition === "outside") {
            classes.push(ns.em("indicators", "outside"));
          }
          if (unref(isVertical)) {
            classes.push(ns.em("indicators", "right"));
          }
          return classes;
        });
        expose({
          setActiveItem,
          prev,
          next
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "root",
            ref: root2,
            class: normalizeClass(unref(carouselClasses)),
            onMouseenter: _cache[6] || (_cache[6] = withModifiers((...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args), ["stop"])),
            onMouseleave: _cache[7] || (_cache[7] = withModifiers((...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args), ["stop"]))
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("container")),
              style: normalizeStyle(unref(containerStyle))
            }, [
              unref(arrowDisplay) ? (openBlock(), createBlock(Transition, {
                key: 0,
                name: "carousel-arrow-left",
                persisted: ""
              }, {
                default: withCtx(() => [
                  withDirectives(createBaseVNode("button", {
                    type: "button",
                    class: normalizeClass([unref(ns).e("arrow"), unref(ns).em("arrow", "left")]),
                    onMouseenter: _cache[0] || (_cache[0] = ($event) => unref(handleButtonEnter)("left")),
                    onMouseleave: _cache[1] || (_cache[1] = (...args) => unref(handleButtonLeave) && unref(handleButtonLeave)(...args)),
                    onClick: _cache[2] || (_cache[2] = withModifiers(($event) => unref(throttledArrowClick)(unref(activeIndex) - 1), ["stop"]))
                  }, [
                    createVNode(unref(ElIcon), null, {
                      default: withCtx(() => [
                        createVNode(unref(arrow_left_default))
                      ]),
                      _: 1
                    })
                  ], 34), [
                    [
                      vShow,
                      (_ctx.arrow === "always" || unref(hover)) && (props.loop || unref(activeIndex) > 0)
                    ]
                  ])
                ]),
                _: 1
              })) : createCommentVNode("v-if", true),
              unref(arrowDisplay) ? (openBlock(), createBlock(Transition, {
                key: 1,
                name: "carousel-arrow-right",
                persisted: ""
              }, {
                default: withCtx(() => [
                  withDirectives(createBaseVNode("button", {
                    type: "button",
                    class: normalizeClass([unref(ns).e("arrow"), unref(ns).em("arrow", "right")]),
                    onMouseenter: _cache[3] || (_cache[3] = ($event) => unref(handleButtonEnter)("right")),
                    onMouseleave: _cache[4] || (_cache[4] = (...args) => unref(handleButtonLeave) && unref(handleButtonLeave)(...args)),
                    onClick: _cache[5] || (_cache[5] = withModifiers(($event) => unref(throttledArrowClick)(unref(activeIndex) + 1), ["stop"]))
                  }, [
                    createVNode(unref(ElIcon), null, {
                      default: withCtx(() => [
                        createVNode(unref(arrow_right_default))
                      ]),
                      _: 1
                    })
                  ], 34), [
                    [
                      vShow,
                      (_ctx.arrow === "always" || unref(hover)) && (props.loop || unref(activeIndex) < unref(items).length - 1)
                    ]
                  ])
                ]),
                _: 1
              })) : createCommentVNode("v-if", true),
              createVNode(unref(PlaceholderItem)),
              renderSlot(_ctx.$slots, "default")
            ], 6),
            _ctx.indicatorPosition !== "none" ? (openBlock(), createElementBlock("ul", {
              key: 0,
              class: normalizeClass(unref(indicatorsClasses))
            }, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(items), (item, index2) => {
                return withDirectives((openBlock(), createElementBlock("li", {
                  key: index2,
                  class: normalizeClass([
                    unref(ns).e("indicator"),
                    unref(ns).em("indicator", _ctx.direction),
                    unref(ns).is("active", index2 === unref(activeIndex))
                  ]),
                  onMouseenter: ($event) => unref(throttledIndicatorHover)(index2),
                  onClick: withModifiers(($event) => unref(handleIndicatorClick)(index2), ["stop"])
                }, [
                  createBaseVNode("button", {
                    class: normalizeClass(unref(ns).e("button"))
                  }, [
                    unref(hasLabel) ? (openBlock(), createElementBlock("span", _hoisted_2$C, toDisplayString(item.props.label), 1)) : createCommentVNode("v-if", true)
                  ], 2)
                ], 42, _hoisted_1$X)), [
                  [vShow, unref(isTwoLengthShow)(index2)]
                ]);
              }), 128))
            ], 2)) : createCommentVNode("v-if", true)
          ], 34);
        };
      }
    });
    var Carousel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1T, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/carousel/src/carousel.vue"]]);
    const carouselItemProps = buildProps({
      name: { type: String, default: "" },
      label: {
        type: [String, Number],
        default: ""
      }
    });
    const useCarouselItem = (props, componentName2) => {
      const carouselContext = inject(carouselContextKey);
      const instance = getCurrentInstance();
      const CARD_SCALE = 0.83;
      const carouselItemRef = ref();
      const hover = ref(false);
      const translate2 = ref(0);
      const scale = ref(1);
      const active = ref(false);
      const ready = ref(false);
      const inStage = ref(false);
      const animating = ref(false);
      const { isCardType, isVertical } = carouselContext;
      function processIndex(index2, activeIndex, length) {
        const lastItemIndex = length - 1;
        const prevItemIndex = activeIndex - 1;
        const nextItemIndex = activeIndex + 1;
        const halfItemIndex = length / 2;
        if (activeIndex === 0 && index2 === lastItemIndex) {
          return -1;
        } else if (activeIndex === lastItemIndex && index2 === 0) {
          return length;
        } else if (index2 < prevItemIndex && activeIndex - index2 >= halfItemIndex) {
          return length + 1;
        } else if (index2 > nextItemIndex && index2 - activeIndex >= halfItemIndex) {
          return -2;
        }
        return index2;
      }
      function calcCardTranslate(index2, activeIndex) {
        var _a2, _b;
        const parentWidth = unref(isVertical) ? ((_a2 = carouselContext.root.value) == null ? void 0 : _a2.offsetHeight) || 0 : ((_b = carouselContext.root.value) == null ? void 0 : _b.offsetWidth) || 0;
        if (inStage.value) {
          return parentWidth * ((2 - CARD_SCALE) * (index2 - activeIndex) + 1) / 4;
        } else if (index2 < activeIndex) {
          return -(1 + CARD_SCALE) * parentWidth / 4;
        } else {
          return (3 + CARD_SCALE) * parentWidth / 4;
        }
      }
      function calcTranslate(index2, activeIndex, isVertical2) {
        const rootEl = carouselContext.root.value;
        if (!rootEl)
          return 0;
        const distance = (isVertical2 ? rootEl.offsetHeight : rootEl.offsetWidth) || 0;
        return distance * (index2 - activeIndex);
      }
      const translateItem = (index2, activeIndex, oldIndex) => {
        var _a2;
        const _isCardType = unref(isCardType);
        const carouselItemLength = (_a2 = carouselContext.items.value.length) != null ? _a2 : Number.NaN;
        const isActive = index2 === activeIndex;
        if (!_isCardType && !isUndefined(oldIndex)) {
          animating.value = isActive || index2 === oldIndex;
        }
        if (!isActive && carouselItemLength > 2 && carouselContext.loop) {
          index2 = processIndex(index2, activeIndex, carouselItemLength);
        }
        const _isVertical = unref(isVertical);
        active.value = isActive;
        if (_isCardType) {
          inStage.value = Math.round(Math.abs(index2 - activeIndex)) <= 1;
          translate2.value = calcCardTranslate(index2, activeIndex);
          scale.value = unref(active) ? 1 : CARD_SCALE;
        } else {
          translate2.value = calcTranslate(index2, activeIndex, _isVertical);
        }
        ready.value = true;
        if (isActive && carouselItemRef.value) {
          carouselContext.setContainerHeight(carouselItemRef.value.offsetHeight);
        }
      };
      function handleItemClick() {
        if (carouselContext && unref(isCardType)) {
          const index2 = carouselContext.items.value.findIndex(({ uid: uid2 }) => uid2 === instance.uid);
          carouselContext.setActiveItem(index2);
        }
      }
      onMounted(() => {
        carouselContext.addItem({
          props,
          states: reactive({
            hover,
            translate: translate2,
            scale,
            active,
            ready,
            inStage,
            animating
          }),
          uid: instance.uid,
          translateItem
        });
      });
      onUnmounted(() => {
        carouselContext.removeItem(instance.uid);
      });
      return {
        carouselItemRef,
        active,
        animating,
        hover,
        inStage,
        isVertical,
        translate: translate2,
        isCardType,
        scale,
        ready,
        handleItemClick
      };
    };
    const __default__$1c = /* @__PURE__ */ defineComponent({
      name: "ElCarouselItem"
    });
    const _sfc_main$1S = /* @__PURE__ */ defineComponent({
      ...__default__$1c,
      props: carouselItemProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("carousel");
        const {
          carouselItemRef,
          active,
          animating,
          hover,
          inStage,
          isVertical,
          translate: translate2,
          isCardType,
          scale,
          ready,
          handleItemClick
        } = useCarouselItem(props);
        const itemStyle = computed(() => {
          const translateType = `translate${unref(isVertical) ? "Y" : "X"}`;
          const _translate = `${translateType}(${unref(translate2)}px)`;
          const _scale = `scale(${unref(scale)})`;
          const transform = [_translate, _scale].join(" ");
          return {
            transform
          };
        });
        return (_ctx, _cache) => {
          return withDirectives((openBlock(), createElementBlock("div", {
            ref_key: "carouselItemRef",
            ref: carouselItemRef,
            class: normalizeClass([
              unref(ns).e("item"),
              unref(ns).is("active", unref(active)),
              unref(ns).is("in-stage", unref(inStage)),
              unref(ns).is("hover", unref(hover)),
              unref(ns).is("animating", unref(animating)),
              {
                [unref(ns).em("item", "card")]: unref(isCardType),
                [unref(ns).em("item", "card-vertical")]: unref(isCardType) && unref(isVertical)
              }
            ]),
            style: normalizeStyle(unref(itemStyle)),
            onClick: _cache[0] || (_cache[0] = (...args) => unref(handleItemClick) && unref(handleItemClick)(...args))
          }, [
            unref(isCardType) ? withDirectives((openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("mask"))
            }, null, 2)), [
              [vShow, !unref(active)]
            ]) : createCommentVNode("v-if", true),
            renderSlot(_ctx.$slots, "default")
          ], 6)), [
            [vShow, unref(ready)]
          ]);
        };
      }
    });
    var CarouselItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$1S, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/carousel/src/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
      },
      indeterminate: Boolean,
      disabled: Boolean,
      checked: Boolean,
      name: {
        type: String,
        default: void 0
      },
      trueLabel: {
        type: [String, Number],
        default: void 0
      },
      falseLabel: {
        type: [String, Number],
        default: void 0
      },
      id: {
        type: String,
        default: void 0
      },
      controls: {
        type: String,
        default: void 0
      },
      border: Boolean,
      size: useSizeProp,
      tabindex: [String, Number],
      validateEvent: {
        type: Boolean,
        default: true
      }
    };
    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 = inject(checkboxGroupContextKey, void 0);
      const isLimitDisabled = computed(() => {
        var _a2, _b;
        const max2 = (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a2.value;
        const min2 = (_b = checkboxGroup == null ? void 0 : checkboxGroup.min) == null ? void 0 : _b.value;
        return !isUndefined(max2) && model.value.length >= max2 && !isChecked.value || !isUndefined(min2) && model.value.length <= min2 && isChecked.value;
      });
      const isDisabled = useFormDisabled(computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.disabled.value) || isLimitDisabled.value));
      return {
        isDisabled,
        isLimitDisabled
      };
    };
    const useCheckboxEvent = (props, {
      model,
      isLimitExceeded,
      hasOwnLabel,
      isDisabled,
      isLabeledByFormItem
    }) => {
      const checkboxGroup = inject(checkboxGroupContextKey, void 0);
      const { formItem } = useFormItem();
      const { emit: emit2 } = getCurrentInstance();
      function getLabeledValue(value) {
        var _a2, _b;
        return value === props.trueLabel || value === true ? (_a2 = props.trueLabel) != null ? _a2 : true : (_b = props.falseLabel) != null ? _b : false;
      }
      function emitChangeEvent(checked, e) {
        emit2("change", getLabeledValue(checked), e);
      }
      function handleChange(e) {
        if (isLimitExceeded.value)
          return;
        const target = e.target;
        emit2("change", 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.falseLabel].includes(model.value));
            await nextTick();
            emitChangeEvent(model.value, e);
          }
        }
      }
      const validateEvent = computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.validateEvent) || props.validateEvent);
      watch(() => props.modelValue, () => {
        if (validateEvent.value) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
        }
      });
      return {
        handleChange,
        onClickRoot
      };
    };
    const useCheckboxModel = (props) => {
      const selfModel = ref(false);
      const { emit: emit2 } = getCurrentInstance();
      const checkboxGroup = inject(checkboxGroupContextKey, void 0);
      const isGroup = computed(() => isUndefined(checkboxGroup) === false);
      const isLimitExceeded = ref(false);
      const model = computed({
        get() {
          var _a2, _b;
          return isGroup.value ? (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.modelValue) == null ? void 0 : _a2.value : (_b = props.modelValue) != null ? _b : selfModel.value;
        },
        set(val) {
          var _a2, _b;
          if (isGroup.value && isArray$3(val)) {
            isLimitExceeded.value = ((_a2 = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a2.value) !== void 0 && val.length > (checkboxGroup == null ? void 0 : checkboxGroup.max.value);
            isLimitExceeded.value === false && ((_b = checkboxGroup == null ? void 0 : checkboxGroup.changeEvent) == null ? void 0 : _b.call(checkboxGroup, val));
          } else {
            emit2(UPDATE_MODEL_EVENT, val);
            selfModel.value = val;
          }
        }
      });
      return {
        model,
        isGroup,
        isLimitExceeded
      };
    };
    const useCheckboxStatus = (props, slots, { model }) => {
      const checkboxGroup = inject(checkboxGroupContextKey, void 0);
      const isFocused = ref(false);
      const isChecked = computed(() => {
        const value = model.value;
        if (isBoolean(value)) {
          return value;
        } else if (isArray$3(value)) {
          if (isObject$1(props.label)) {
            return value.map(toRaw).some((o2) => isEqual$1(o2, props.label));
          } else {
            return value.map(toRaw).includes(props.label);
          }
        } else if (value !== null && value !== void 0) {
          return value === props.trueLabel;
        } else {
          return !!value;
        }
      });
      const checkboxButtonSize = useFormSize(computed(() => {
        var _a2;
        return (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a2.value;
      }), {
        prop: true
      });
      const checkboxSize = useFormSize(computed(() => {
        var _a2;
        return (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a2.value;
      }));
      const hasOwnLabel = computed(() => {
        return !!slots.default || !isNil(props.label);
      });
      return {
        checkboxButtonSize,
        isChecked,
        isFocused,
        checkboxSize,
        hasOwnLabel
      };
    };
    const setStoreValue = (props, { model }) => {
      function addToStore() {
        if (isArray$3(model.value) && !model.value.includes(props.label)) {
          model.value.push(props.label);
        } else {
          model.value = props.trueLabel || true;
        }
      }
      props.checked && addToStore();
    };
    const useCheckbox = (props, slots) => {
      const { formItem: elFormItem } = useFormItem();
      const { model, isGroup, isLimitExceeded } = useCheckboxModel(props);
      const {
        isFocused,
        isChecked,
        checkboxButtonSize,
        checkboxSize,
        hasOwnLabel
      } = 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
      });
      setStoreValue(props, { model });
      return {
        inputId,
        isLabeledByFormItem,
        isChecked,
        isDisabled,
        isFocused,
        checkboxButtonSize,
        checkboxSize,
        hasOwnLabel,
        model,
        handleChange,
        onClickRoot
      };
    };
    const _hoisted_1$W = ["id", "indeterminate", "name", "tabindex", "disabled", "true-value", "false-value"];
    const _hoisted_2$B = ["id", "indeterminate", "disabled", "value", "name", "tabindex"];
    const __default__$1b = /* @__PURE__ */ defineComponent({
      name: "ElCheckbox"
    });
    const _sfc_main$1R = /* @__PURE__ */ defineComponent({
      ...__default__$1b,
      props: checkboxProps,
      emits: checkboxEmits,
      setup(__props) {
        const props = __props;
        const slots = useSlots();
        const {
          inputId,
          isLabeledByFormItem,
          isChecked,
          isDisabled,
          isFocused,
          checkboxSize,
          hasOwnLabel,
          model,
          handleChange,
          onClickRoot
        } = useCheckbox(props, slots);
        const ns = useNamespace("checkbox");
        const compKls = 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 = 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 openBlock(), createBlock(resolveDynamicComponent(!unref(hasOwnLabel) && unref(isLabeledByFormItem) ? "span" : "label"), {
            class: normalizeClass(unref(compKls)),
            "aria-controls": _ctx.indeterminate ? _ctx.controls : null,
            onClick: unref(onClickRoot)
          }, {
            default: withCtx(() => [
              createBaseVNode("span", {
                class: normalizeClass(unref(spanKls))
              }, [
                _ctx.trueLabel || _ctx.falseLabel ? withDirectives((openBlock(), createElementBlock("input", {
                  key: 0,
                  id: unref(inputId),
                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(model) ? model.value = $event : null),
                  class: normalizeClass(unref(ns).e("original")),
                  type: "checkbox",
                  indeterminate: _ctx.indeterminate,
                  name: _ctx.name,
                  tabindex: _ctx.tabindex,
                  disabled: unref(isDisabled),
                  "true-value": _ctx.trueLabel,
                  "false-value": _ctx.falseLabel,
                  onChange: _cache[1] || (_cache[1] = (...args) => unref(handleChange) && unref(handleChange)(...args)),
                  onFocus: _cache[2] || (_cache[2] = ($event) => isFocused.value = true),
                  onBlur: _cache[3] || (_cache[3] = ($event) => isFocused.value = false),
                  onClick: _cache[4] || (_cache[4] = withModifiers(() => {
                  }, ["stop"]))
                }, null, 42, _hoisted_1$W)), [
                  [vModelCheckbox, unref(model)]
                ]) : withDirectives((openBlock(), createElementBlock("input", {
                  key: 1,
                  id: unref(inputId),
                  "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => isRef(model) ? model.value = $event : null),
                  class: normalizeClass(unref(ns).e("original")),
                  type: "checkbox",
                  indeterminate: _ctx.indeterminate,
                  disabled: unref(isDisabled),
                  value: _ctx.label,
                  name: _ctx.name,
                  tabindex: _ctx.tabindex,
                  onChange: _cache[6] || (_cache[6] = (...args) => unref(handleChange) && unref(handleChange)(...args)),
                  onFocus: _cache[7] || (_cache[7] = ($event) => isFocused.value = true),
                  onBlur: _cache[8] || (_cache[8] = ($event) => isFocused.value = false),
                  onClick: _cache[9] || (_cache[9] = withModifiers(() => {
                  }, ["stop"]))
                }, null, 42, _hoisted_2$B)), [
                  [vModelCheckbox, unref(model)]
                ]),
                createBaseVNode("span", {
                  class: normalizeClass(unref(ns).e("inner"))
                }, null, 2)
              ], 2),
              unref(hasOwnLabel) ? (openBlock(), createElementBlock("span", {
                key: 0,
                class: normalizeClass(unref(ns).e("label"))
              }, [
                renderSlot(_ctx.$slots, "default"),
                !_ctx.$slots.default ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                  createTextVNode(toDisplayString(_ctx.label), 1)
                ], 64)) : createCommentVNode("v-if", true)
              ], 2)) : createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["class", "aria-controls", "onClick"]);
        };
      }
    });
    var Checkbox = /* @__PURE__ */ _export_sfc$1(_sfc_main$1R, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/checkbox/src/checkbox.vue"]]);
    const _hoisted_1$V = ["name", "tabindex", "disabled", "true-value", "false-value"];
    const _hoisted_2$A = ["name", "tabindex", "disabled", "value"];
    const __default__$1a = /* @__PURE__ */ defineComponent({
      name: "ElCheckboxButton"
    });
    const _sfc_main$1Q = /* @__PURE__ */ defineComponent({
      ...__default__$1a,
      props: checkboxProps,
      emits: checkboxEmits,
      setup(__props) {
        const props = __props;
        const slots = useSlots();
        const {
          isFocused,
          isChecked,
          isDisabled,
          checkboxButtonSize,
          model,
          handleChange
        } = useCheckbox(props, slots);
        const checkboxGroup = inject(checkboxGroupContextKey, void 0);
        const ns = useNamespace("checkbox");
        const activeStyle = computed(() => {
          var _a2, _b, _c, _d;
          const fillValue = (_b = (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.fill) == null ? void 0 : _a2.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 = 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 openBlock(), createElementBlock("label", {
            class: normalizeClass(unref(labelKls))
          }, [
            _ctx.trueLabel || _ctx.falseLabel ? withDirectives((openBlock(), createElementBlock("input", {
              key: 0,
              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(model) ? model.value = $event : null),
              class: normalizeClass(unref(ns).be("button", "original")),
              type: "checkbox",
              name: _ctx.name,
              tabindex: _ctx.tabindex,
              disabled: unref(isDisabled),
              "true-value": _ctx.trueLabel,
              "false-value": _ctx.falseLabel,
              onChange: _cache[1] || (_cache[1] = (...args) => unref(handleChange) && unref(handleChange)(...args)),
              onFocus: _cache[2] || (_cache[2] = ($event) => isFocused.value = true),
              onBlur: _cache[3] || (_cache[3] = ($event) => isFocused.value = false),
              onClick: _cache[4] || (_cache[4] = withModifiers(() => {
              }, ["stop"]))
            }, null, 42, _hoisted_1$V)), [
              [vModelCheckbox, unref(model)]
            ]) : withDirectives((openBlock(), createElementBlock("input", {
              key: 1,
              "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => isRef(model) ? model.value = $event : null),
              class: normalizeClass(unref(ns).be("button", "original")),
              type: "checkbox",
              name: _ctx.name,
              tabindex: _ctx.tabindex,
              disabled: unref(isDisabled),
              value: _ctx.label,
              onChange: _cache[6] || (_cache[6] = (...args) => unref(handleChange) && unref(handleChange)(...args)),
              onFocus: _cache[7] || (_cache[7] = ($event) => isFocused.value = true),
              onBlur: _cache[8] || (_cache[8] = ($event) => isFocused.value = false),
              onClick: _cache[9] || (_cache[9] = withModifiers(() => {
              }, ["stop"]))
            }, null, 42, _hoisted_2$A)), [
              [vModelCheckbox, unref(model)]
            ]),
            _ctx.$slots.default || _ctx.label ? (openBlock(), createElementBlock("span", {
              key: 2,
              class: normalizeClass(unref(ns).be("button", "inner")),
              style: normalizeStyle(unref(isChecked) ? unref(activeStyle) : void 0)
            }, [
              renderSlot(_ctx.$slots, "default", {}, () => [
                createTextVNode(toDisplayString(_ctx.label), 1)
              ])
            ], 6)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var CheckboxButton = /* @__PURE__ */ _export_sfc$1(_sfc_main$1Q, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/checkbox/src/checkbox-button.vue"]]);
    const checkboxGroupProps = buildProps({
      modelValue: {
        type: definePropType(Array),
        default: () => []
      },
      disabled: Boolean,
      min: Number,
      max: Number,
      size: useSizeProp,
      label: String,
      fill: String,
      textColor: String,
      tag: {
        type: String,
        default: "div"
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const checkboxGroupEmits = {
      [UPDATE_MODEL_EVENT]: (val) => isArray$3(val),
      change: (val) => isArray$3(val)
    };
    const __default__$19 = /* @__PURE__ */ defineComponent({
      name: "ElCheckboxGroup"
    });
    const _sfc_main$1P = /* @__PURE__ */ defineComponent({
      ...__default__$19,
      props: checkboxGroupProps,
      emits: checkboxGroupEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("checkbox");
        const { formItem } = useFormItem();
        const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const changeEvent = async (value) => {
          emit2(UPDATE_MODEL_EVENT, value);
          await nextTick();
          emit2("change", value);
        };
        const modelValue = computed({
          get() {
            return props.modelValue;
          },
          set(val) {
            changeEvent(val);
          }
        });
        provide(checkboxGroupContextKey, {
          ...pick$1(toRefs(props), [
            "size",
            "min",
            "max",
            "disabled",
            "validateEvent",
            "fill",
            "textColor"
          ]),
          modelValue,
          changeEvent
        });
        watch(() => props.modelValue, () => {
          if (props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
        });
        return (_ctx, _cache) => {
          var _a2;
          return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
            id: unref(groupId),
            class: normalizeClass(unref(ns).b("group")),
            role: "group",
            "aria-label": !unref(isLabeledByFormItem) ? _ctx.label || "checkbox-group" : void 0,
            "aria-labelledby": unref(isLabeledByFormItem) ? (_a2 = unref(formItem)) == null ? void 0 : _a2.labelId : void 0
          }, {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["id", "class", "aria-label", "aria-labelledby"]);
        };
      }
    });
    var CheckboxGroup = /* @__PURE__ */ _export_sfc$1(_sfc_main$1P, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/checkbox/src/checkbox-group.vue"]]);
    const ElCheckbox = withInstall(Checkbox, {
      CheckboxButton,
      CheckboxGroup
    });
    const ElCheckboxButton = withNoopInstall(CheckboxButton);
    const ElCheckboxGroup$1 = withNoopInstall(CheckboxGroup);
    const radioPropsBase = buildProps({
      size: useSizeProp,
      disabled: Boolean,
      label: {
        type: [String, Number, Boolean],
        default: ""
      }
    });
    const radioProps = buildProps({
      ...radioPropsBase,
      modelValue: {
        type: [String, Number, Boolean],
        default: ""
      },
      name: {
        type: String,
        default: ""
      },
      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, emit2) => {
      const radioRef = ref();
      const radioGroup = inject(radioGroupKey, void 0);
      const isGroup = computed(() => !!radioGroup);
      const modelValue = computed({
        get() {
          return isGroup.value ? radioGroup.modelValue : props.modelValue;
        },
        set(val) {
          if (isGroup.value) {
            radioGroup.changeEvent(val);
          } else {
            emit2 && emit2(UPDATE_MODEL_EVENT, val);
          }
          radioRef.value.checked = props.modelValue === props.label;
        }
      });
      const size2 = useFormSize(computed(() => radioGroup == null ? void 0 : radioGroup.size));
      const disabled = useFormDisabled(computed(() => radioGroup == null ? void 0 : radioGroup.disabled));
      const focus = ref(false);
      const tabIndex = computed(() => {
        return disabled.value || isGroup.value && modelValue.value !== props.label ? -1 : 0;
      });
      return {
        radioRef,
        isGroup,
        radioGroup,
        focus,
        size: size2,
        disabled,
        tabIndex,
        modelValue
      };
    };
    const _hoisted_1$U = ["value", "name", "disabled"];
    const __default__$18 = /* @__PURE__ */ defineComponent({
      name: "ElRadio"
    });
    const _sfc_main$1O = /* @__PURE__ */ defineComponent({
      ...__default__$18,
      props: radioProps,
      emits: radioEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("radio");
        const { radioRef, radioGroup, focus, size: size2, disabled, modelValue } = useRadio(props, emit2);
        function handleChange() {
          nextTick(() => emit2("change", modelValue.value));
        }
        return (_ctx, _cache) => {
          var _a2;
          return openBlock(), createElementBlock("label", {
            class: normalizeClass([
              unref(ns).b(),
              unref(ns).is("disabled", unref(disabled)),
              unref(ns).is("focus", unref(focus)),
              unref(ns).is("bordered", _ctx.border),
              unref(ns).is("checked", unref(modelValue) === _ctx.label),
              unref(ns).m(unref(size2))
            ])
          }, [
            createBaseVNode("span", {
              class: normalizeClass([
                unref(ns).e("input"),
                unref(ns).is("disabled", unref(disabled)),
                unref(ns).is("checked", unref(modelValue) === _ctx.label)
              ])
            }, [
              withDirectives(createBaseVNode("input", {
                ref_key: "radioRef",
                ref: radioRef,
                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(modelValue) ? modelValue.value = $event : null),
                class: normalizeClass(unref(ns).e("original")),
                value: _ctx.label,
                name: _ctx.name || ((_a2 = unref(radioGroup)) == null ? void 0 : _a2.name),
                disabled: unref(disabled),
                type: "radio",
                onFocus: _cache[1] || (_cache[1] = ($event) => focus.value = true),
                onBlur: _cache[2] || (_cache[2] = ($event) => focus.value = false),
                onChange: handleChange,
                onClick: _cache[3] || (_cache[3] = withModifiers(() => {
                }, ["stop"]))
              }, null, 42, _hoisted_1$U), [
                [vModelRadio, unref(modelValue)]
              ]),
              createBaseVNode("span", {
                class: normalizeClass(unref(ns).e("inner"))
              }, null, 2)
            ], 2),
            createBaseVNode("span", {
              class: normalizeClass(unref(ns).e("label")),
              onKeydown: _cache[4] || (_cache[4] = withModifiers(() => {
              }, ["stop"]))
            }, [
              renderSlot(_ctx.$slots, "default", {}, () => [
                createTextVNode(toDisplayString(_ctx.label), 1)
              ])
            ], 34)
          ], 2);
        };
      }
    });
    var Radio = /* @__PURE__ */ _export_sfc$1(_sfc_main$1O, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/radio/src/radio.vue"]]);
    const radioButtonProps = buildProps({
      ...radioPropsBase,
      name: {
        type: String,
        default: ""
      }
    });
    const _hoisted_1$T = ["value", "name", "disabled"];
    const __default__$17 = /* @__PURE__ */ defineComponent({
      name: "ElRadioButton"
    });
    const _sfc_main$1N = /* @__PURE__ */ defineComponent({
      ...__default__$17,
      props: radioButtonProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("radio");
        const { radioRef, focus, size: size2, disabled, modelValue, radioGroup } = useRadio(props);
        const activeStyle = 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 _a2;
          return openBlock(), createElementBlock("label", {
            class: normalizeClass([
              unref(ns).b("button"),
              unref(ns).is("active", unref(modelValue) === _ctx.label),
              unref(ns).is("disabled", unref(disabled)),
              unref(ns).is("focus", unref(focus)),
              unref(ns).bm("button", unref(size2))
            ])
          }, [
            withDirectives(createBaseVNode("input", {
              ref_key: "radioRef",
              ref: radioRef,
              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(modelValue) ? modelValue.value = $event : null),
              class: normalizeClass(unref(ns).be("button", "original-radio")),
              value: _ctx.label,
              type: "radio",
              name: _ctx.name || ((_a2 = unref(radioGroup)) == null ? void 0 : _a2.name),
              disabled: unref(disabled),
              onFocus: _cache[1] || (_cache[1] = ($event) => focus.value = true),
              onBlur: _cache[2] || (_cache[2] = ($event) => focus.value = false),
              onClick: _cache[3] || (_cache[3] = withModifiers(() => {
              }, ["stop"]))
            }, null, 42, _hoisted_1$T), [
              [vModelRadio, unref(modelValue)]
            ]),
            createBaseVNode("span", {
              class: normalizeClass(unref(ns).be("button", "inner")),
              style: normalizeStyle(unref(modelValue) === _ctx.label ? unref(activeStyle) : {}),
              onKeydown: _cache[4] || (_cache[4] = withModifiers(() => {
              }, ["stop"]))
            }, [
              renderSlot(_ctx.$slots, "default", {}, () => [
                createTextVNode(toDisplayString(_ctx.label), 1)
              ])
            ], 38)
          ], 2);
        };
      }
    });
    var RadioButton = /* @__PURE__ */ _export_sfc$1(_sfc_main$1N, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/radio/src/radio-button.vue"]]);
    const radioGroupProps = buildProps({
      id: {
        type: String,
        default: void 0
      },
      size: useSizeProp,
      disabled: Boolean,
      modelValue: {
        type: [String, Number, Boolean],
        default: ""
      },
      fill: {
        type: String,
        default: ""
      },
      label: {
        type: String,
        default: void 0
      },
      textColor: {
        type: String,
        default: ""
      },
      name: {
        type: String,
        default: void 0
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const radioGroupEmits = radioEmits;
    const _hoisted_1$S = ["id", "aria-label", "aria-labelledby"];
    const __default__$16 = /* @__PURE__ */ defineComponent({
      name: "ElRadioGroup"
    });
    const _sfc_main$1M = /* @__PURE__ */ defineComponent({
      ...__default__$16,
      props: radioGroupProps,
      emits: radioGroupEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("radio");
        const radioId = useId();
        const radioGroupRef = ref();
        const { formItem } = useFormItem();
        const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const changeEvent = (value) => {
          emit2(UPDATE_MODEL_EVENT, value);
          nextTick(() => emit2("change", value));
        };
        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 = computed(() => {
          return props.name || radioId.value;
        });
        provide(radioGroupKey, reactive({
          ...toRefs(props),
          changeEvent,
          name
        }));
        watch(() => props.modelValue, () => {
          if (props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            id: unref(groupId),
            ref_key: "radioGroupRef",
            ref: radioGroupRef,
            class: normalizeClass(unref(ns).b("group")),
            role: "radiogroup",
            "aria-label": !unref(isLabeledByFormItem) ? _ctx.label || "radio-group" : void 0,
            "aria-labelledby": unref(isLabeledByFormItem) ? unref(formItem).labelId : void 0
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 10, _hoisted_1$S);
        };
      }
    });
    var RadioGroup = /* @__PURE__ */ _export_sfc$1(_sfc_main$1M, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/radio/src/radio-group.vue"]]);
    const ElRadio = withInstall(Radio, {
      RadioButton,
      RadioGroup
    });
    const ElRadioGroup = withNoopInstall(RadioGroup);
    const ElRadioButton = withNoopInstall(RadioButton);
    var NodeContent$1 = /* @__PURE__ */ defineComponent({
      name: "NodeContent",
      setup() {
        const ns = useNamespace("cascader-node");
        return {
          ns
        };
      },
      render() {
        const { ns } = this;
        const { node, panel } = this.$parent;
        const { data, label } = node;
        const { renderLabelFn } = panel;
        return h$1("span", { class: ns.e("label") }, renderLabelFn ? renderLabelFn({ node, data }) : label);
      }
    });
    const CASCADER_PANEL_INJECTION_KEY = Symbol();
    const _sfc_main$1L = /* @__PURE__ */ defineComponent({
      name: "ElCascaderNode",
      components: {
        ElCheckbox,
        ElRadio,
        NodeContent: NodeContent$1,
        ElIcon,
        Check: check_default,
        Loading: loading_default,
        ArrowRight: arrow_right_default
      },
      props: {
        node: {
          type: Object,
          required: true
        },
        menuId: String
      },
      emits: ["expand"],
      setup(props, { emit: emit2 }) {
        const panel = inject(CASCADER_PANEL_INJECTION_KEY);
        const ns = useNamespace("cascader-node");
        const isHoverMenu = computed(() => panel.isHoverMenu);
        const multiple = computed(() => panel.config.multiple);
        const checkStrictly = computed(() => panel.config.checkStrictly);
        const checkedNodeId = computed(() => {
          var _a2;
          return (_a2 = panel.checkedNodes[0]) == null ? void 0 : _a2.uid;
        });
        const isDisabled = computed(() => props.node.isDisabled);
        const isLeaf2 = computed(() => props.node.isLeaf);
        const expandable = computed(() => checkStrictly.value && !isLeaf2.value || !isDisabled.value);
        const inExpandingPath = computed(() => isInPath(panel.expandingNode));
        const inCheckedPath = computed(() => checkStrictly.value && panel.checkedNodes.some(isInPath));
        const isInPath = (node) => {
          var _a2;
          const { level, uid: uid2 } = props.node;
          return ((_a2 = node == null ? void 0 : node.pathNodes[level - 1]) == null ? void 0 : _a2.uid) === uid2;
        };
        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 (!isLeaf2.value)
              doExpand();
          });
        };
        const handleHoverExpand = (e) => {
          if (!isHoverMenu.value)
            return;
          handleExpand();
          !isLeaf2.value && emit2("expand", e);
        };
        const handleExpand = () => {
          const { node } = props;
          if (!expandable.value || node.loading)
            return;
          node.loaded ? doExpand() : doLoad();
        };
        const handleClick = () => {
          if (isHoverMenu.value && !isLeaf2.value)
            return;
          if (isLeaf2.value && !isDisabled.value && !checkStrictly.value && !multiple.value) {
            handleCheck(true);
          } else {
            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 {
          panel,
          isHoverMenu,
          multiple,
          checkStrictly,
          checkedNodeId,
          isDisabled,
          isLeaf: isLeaf2,
          expandable,
          inExpandingPath,
          inCheckedPath,
          ns,
          handleHoverExpand,
          handleExpand,
          handleClick,
          handleCheck,
          handleSelectCheck
        };
      }
    });
    const _hoisted_1$R = ["id", "aria-haspopup", "aria-owns", "aria-expanded", "tabindex"];
    const _hoisted_2$z = /* @__PURE__ */ createBaseVNode("span", null, null, -1);
    function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_checkbox = resolveComponent("el-checkbox");
      const _component_el_radio = resolveComponent("el-radio");
      const _component_check = resolveComponent("check");
      const _component_el_icon = resolveComponent("el-icon");
      const _component_node_content = resolveComponent("node-content");
      const _component_loading = resolveComponent("loading");
      const _component_arrow_right = resolveComponent("arrow-right");
      return openBlock(), createElementBlock("li", {
        id: `${_ctx.menuId}-${_ctx.node.uid}`,
        role: "menuitem",
        "aria-haspopup": !_ctx.isLeaf,
        "aria-owns": _ctx.isLeaf ? null : _ctx.menuId,
        "aria-expanded": _ctx.inExpandingPath,
        tabindex: _ctx.expandable ? -1 : void 0,
        class: normalizeClass([
          _ctx.ns.b(),
          _ctx.ns.is("selectable", _ctx.checkStrictly),
          _ctx.ns.is("active", _ctx.node.checked),
          _ctx.ns.is("disabled", !_ctx.expandable),
          _ctx.inExpandingPath && "in-active-path",
          _ctx.inCheckedPath && "in-checked-path"
        ]),
        onMouseenter: _cache[2] || (_cache[2] = (...args) => _ctx.handleHoverExpand && _ctx.handleHoverExpand(...args)),
        onFocus: _cache[3] || (_cache[3] = (...args) => _ctx.handleHoverExpand && _ctx.handleHoverExpand(...args)),
        onClick: _cache[4] || (_cache[4] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
      }, [
        createCommentVNode(" prefix "),
        _ctx.multiple ? (openBlock(), createBlock(_component_el_checkbox, {
          key: 0,
          "model-value": _ctx.node.checked,
          indeterminate: _ctx.node.indeterminate,
          disabled: _ctx.isDisabled,
          onClick: _cache[0] || (_cache[0] = withModifiers(() => {
          }, ["stop"])),
          "onUpdate:modelValue": _ctx.handleSelectCheck
        }, null, 8, ["model-value", "indeterminate", "disabled", "onUpdate:modelValue"])) : _ctx.checkStrictly ? (openBlock(), createBlock(_component_el_radio, {
          key: 1,
          "model-value": _ctx.checkedNodeId,
          label: _ctx.node.uid,
          disabled: _ctx.isDisabled,
          "onUpdate:modelValue": _ctx.handleSelectCheck,
          onClick: _cache[1] || (_cache[1] = withModifiers(() => {
          }, ["stop"]))
        }, {
          default: withCtx(() => [
            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      "),
            _hoisted_2$z
          ]),
          _: 1
        }, 8, ["model-value", "label", "disabled", "onUpdate:modelValue"])) : _ctx.isLeaf && _ctx.node.checked ? (openBlock(), createBlock(_component_el_icon, {
          key: 2,
          class: normalizeClass(_ctx.ns.e("prefix"))
        }, {
          default: withCtx(() => [
            createVNode(_component_check)
          ]),
          _: 1
        }, 8, ["class"])) : createCommentVNode("v-if", true),
        createCommentVNode(" content "),
        createVNode(_component_node_content),
        createCommentVNode(" postfix "),
        !_ctx.isLeaf ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [
          _ctx.node.loading ? (openBlock(), createBlock(_component_el_icon, {
            key: 0,
            class: normalizeClass([_ctx.ns.is("loading"), _ctx.ns.e("postfix")])
          }, {
            default: withCtx(() => [
              createVNode(_component_loading)
            ]),
            _: 1
          }, 8, ["class"])) : (openBlock(), createBlock(_component_el_icon, {
            key: 1,
            class: normalizeClass(["arrow-right", _ctx.ns.e("postfix")])
          }, {
            default: withCtx(() => [
              createVNode(_component_arrow_right)
            ]),
            _: 1
          }, 8, ["class"]))
        ], 64)) : createCommentVNode("v-if", true)
      ], 42, _hoisted_1$R);
    }
    var ElCascaderNode = /* @__PURE__ */ _export_sfc$1(_sfc_main$1L, [["render", _sfc_render$u], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/cascader-panel/src/node.vue"]]);
    const _sfc_main$1K = /* @__PURE__ */ defineComponent({
      name: "ElCascaderMenu",
      components: {
        Loading: loading_default,
        ElIcon,
        ElScrollbar,
        ElCascaderNode
      },
      props: {
        nodes: {
          type: Array,
          required: true
        },
        index: {
          type: Number,
          required: true
        }
      },
      setup(props) {
        const instance = getCurrentInstance();
        const ns = useNamespace("cascader-menu");
        const { t } = useLocale();
        const id = generateId();
        let activeNode = null;
        let hoverTimer = null;
        const panel = inject(CASCADER_PANEL_INJECTION_KEY);
        const hoverZone = ref(null);
        const isEmpty2 = computed(() => !props.nodes.length);
        const isLoading = computed(() => !panel.initialLoaded);
        const menuId = computed(() => `cascader-menu-${id}-${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: left2 } = el.getBoundingClientRect();
            const { offsetWidth, offsetHeight } = el;
            const startX = e.clientX - left2;
            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 = null;
        };
        const clearHoverZone = () => {
          if (!hoverZone.value)
            return;
          hoverZone.value.innerHTML = "";
          clearHoverTimer();
        };
        return {
          ns,
          panel,
          hoverZone,
          isEmpty: isEmpty2,
          isLoading,
          menuId,
          t,
          handleExpand,
          handleMouseMove,
          clearHoverZone
        };
      }
    });
    function _sfc_render$t(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_cascader_node = resolveComponent("el-cascader-node");
      const _component_loading = resolveComponent("loading");
      const _component_el_icon = resolveComponent("el-icon");
      const _component_el_scrollbar = resolveComponent("el-scrollbar");
      return openBlock(), createBlock(_component_el_scrollbar, {
        key: _ctx.menuId,
        tag: "ul",
        role: "menu",
        class: normalizeClass(_ctx.ns.b()),
        "wrap-class": _ctx.ns.e("wrap"),
        "view-class": [_ctx.ns.e("list"), _ctx.ns.is("empty", _ctx.isEmpty)],
        onMousemove: _ctx.handleMouseMove,
        onMouseleave: _ctx.clearHoverZone
      }, {
        default: withCtx(() => {
          var _a2;
          return [
            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.nodes, (node) => {
              return openBlock(), createBlock(_component_el_cascader_node, {
                key: node.uid,
                node,
                "menu-id": _ctx.menuId,
                onExpand: _ctx.handleExpand
              }, null, 8, ["node", "menu-id", "onExpand"]);
            }), 128)),
            _ctx.isLoading ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(_ctx.ns.e("empty-text"))
            }, [
              createVNode(_component_el_icon, {
                size: "14",
                class: normalizeClass(_ctx.ns.is("loading"))
              }, {
                default: withCtx(() => [
                  createVNode(_component_loading)
                ]),
                _: 1
              }, 8, ["class"]),
              createTextVNode(" " + toDisplayString(_ctx.t("el.cascader.loading")), 1)
            ], 2)) : _ctx.isEmpty ? (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(_ctx.ns.e("empty-text"))
            }, toDisplayString(_ctx.t("el.cascader.noData")), 3)) : ((_a2 = _ctx.panel) == null ? void 0 : _a2.isHoverMenu) ? (openBlock(), createElementBlock("svg", {
              key: 2,
              ref: "hoverZone",
              class: normalizeClass(_ctx.ns.e("hover-zone"))
            }, null, 2)) : createCommentVNode("v-if", true)
          ];
        }),
        _: 1
      }, 8, ["class", "wrap-class", "view-class", "onMousemove", "onMouseleave"]);
    }
    var ElCascaderMenu = /* @__PURE__ */ _export_sfc$1(_sfc_main$1K, [["render", _sfc_render$t], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/cascader-panel/src/menu.vue"]]);
    let uid = 0;
    const calculatePathNodes = (node) => {
      const nodes = [node];
      let { parent } = node;
      while (parent) {
        nodes.unshift(parent);
        parent = parent.parent;
      }
      return nodes;
    };
    let Node$2 = class Node2 {
      constructor(data, config, parent, root2 = false) {
        this.data = data;
        this.config = config;
        this.parent = parent;
        this.root = root2;
        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 = root2 ? 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 Node2(child, config, this));
        this.loaded = !config.lazy || this.isLeaf || !isEmpty(childrenData);
      }
      get isDisabled() {
        const { data, parent, config } = this;
        const { disabled, checkStrictly } = config;
        const isDisabled = isFunction$2(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 isLeaf2 = isFunction$2(leaf) ? leaf(data, this) : data[leaf];
        return isUndefined(isLeaf2) ? lazy && !loaded ? false : !(Array.isArray(childrenData) && childrenData.length) : !!isLeaf2;
      }
      get valueByOption() {
        return this.config.emitPath ? this.pathValues : this.value;
      }
      appendChild(childData) {
        const { childrenData, children } = this;
        const node = new Node2(childData, this.config, this);
        if (Array.isArray(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(event, ...args) {
        const handlerName = `onParent${capitalize(event)}`;
        this.children.forEach((child) => {
          if (child) {
            child.broadcast(event, ...args);
            child[handlerName] && child[handlerName](...args);
          }
        });
      }
      emit(event, ...args) {
        const { parent } = this;
        const handlerName = `onChild${capitalize(event)}`;
        if (parent) {
          parent[handlerName] && parent[handlerName](...args);
          parent.emit(event, ...args);
        }
      }
      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((c2, p2) => {
          const num = p2.checked ? 1 : p2.indeterminate ? 0.5 : 0;
          return c2 + 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("check", checked);
          this.setCheckState(checked);
          this.emit("check");
        }
      }
    };
    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$2(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$2(nodeData, this.config);
        if (!parentNode)
          this.nodes.push(node);
        this.allNodes.push(node);
        node.isLeaf && this.leafNodes.push(node);
      }
      appendNodes(nodeDataList, parentNode) {
        nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
      }
      getNodeByValue(value, leafOnly = false) {
        if (!value && value !== 0)
          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])
      },
      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
    };
    const useCascaderConfig = (props) => {
      return 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 index2 = newIds.indexOf(item.uid);
        if (index2 > -1) {
          acc.push(item);
          newNodesCopy.splice(index2, 1);
          newIds.splice(index2, 1);
        }
        return acc;
      }, []);
      res.push(...newNodesCopy);
      return res;
    };
    const _sfc_main$1J = /* @__PURE__ */ defineComponent({
      name: "ElCascaderPanel",
      components: {
        ElCascaderMenu
      },
      props: {
        ...CommonProps,
        border: {
          type: Boolean,
          default: true
        },
        renderLabel: Function
      },
      emits: [UPDATE_MODEL_EVENT, CHANGE_EVENT, "close", "expand-change"],
      setup(props, { emit: emit2, slots }) {
        let manualChecked = false;
        const ns = useNamespace("cascader");
        const config = useCascaderConfig(props);
        let store = null;
        const initialLoaded = ref(true);
        const menuList = ref([]);
        const checkedValue = ref(null);
        const menus = ref([]);
        const expandingNode = ref(null);
        const checkedNodes = ref([]);
        const isHoverMenu = computed(() => config.value.expandTrigger === "hover");
        const renderLabelFn = 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$2({}, cfg, void 0, true);
          node.loading = true;
          const resolve2 = (dataList) => {
            const _node = node;
            const parent = _node.root ? null : _node;
            dataList && (store == null ? void 0 : store.appendNodes(dataList, parent));
            _node.loading = false;
            _node.loaded = true;
            _node.childrenData = _node.childrenData || [];
            cb && cb(dataList);
          };
          cfg.lazyLoad(node, resolve2);
        };
        const expandNode = (node, silent) => {
          var _a2;
          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 (((_a2 = expandingNode.value) == null ? void 0 : _a2.uid) !== (newExpandingNode == null ? void 0 : newExpandingNode.uid)) {
            expandingNode.value = node;
            menus.value = newMenus;
            !silent && emit2("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 && emit2("close");
          !emitClose && !multiple && !checkStrictly && expandParentNode(node);
        };
        const expandParentNode = (node) => {
          if (!node)
            return;
          node = node.parent;
          expandParentNode(node);
          node && expandNode(node);
        };
        const getFlattedNodes = (leafOnly) => {
          return store == null ? void 0 : store.getFlattedNodes(leafOnly);
        };
        const getCheckedNodes = (leafOnly) => {
          var _a2;
          return (_a2 = getFlattedNodes(leafOnly)) == null ? void 0 : _a2.filter((node) => node.checked !== false);
        };
        const clearCheckedNodes = () => {
          checkedNodes.value.forEach((node) => node.doCheck(false));
          calculateCheckedValue();
          menus.value = menus.value.slice(0, 1);
          expandingNode.value = null;
          emit2("expand-change", []);
        };
        const calculateCheckedValue = () => {
          var _a2;
          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 : (_a2 = values[0]) != null ? _a2 : 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);
          }
        };
        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 = null;
          }
          oldNodes.forEach((node) => node.doCheck(false));
          if (props.props.multiple) {
            reactive(newNodes).forEach((node) => node.doCheck(true));
          } else {
            newNodes.forEach((node) => node.doCheck(true));
          }
          checkedNodes.value = newNodes;
          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")}`) || menuElement.querySelector(`.${ns.b("node")}.in-active-path`);
              scrollIntoView(container, activeNode);
            }
          });
        };
        const handleKeyDown = (e) => {
          const target = e.target;
          const { code } = 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:
              checkNode(target);
              break;
          }
        };
        provide(CASCADER_PANEL_INJECTION_KEY, reactive({
          config,
          expandingNode,
          checkedNodes,
          isHoverMenu,
          initialLoaded,
          renderLabelFn,
          lazyLoad,
          expandNode,
          handleCheckChange
        }));
        watch([config, () => props.options], initStore, {
          deep: true,
          immediate: true
        });
        watch(() => props.modelValue, () => {
          manualChecked = false;
          syncCheckedValue();
        }, {
          deep: true
        });
        watch(() => checkedValue.value, (val) => {
          if (!isEqual$1(val, props.modelValue)) {
            emit2(UPDATE_MODEL_EVENT, val);
            emit2(CHANGE_EVENT, val);
          }
        });
        onBeforeUpdate(() => menuList.value = []);
        onMounted(() => !isEmpty(props.modelValue) && syncCheckedValue());
        return {
          ns,
          menuList,
          menus,
          checkedNodes,
          handleKeyDown,
          handleCheckChange,
          getFlattedNodes,
          getCheckedNodes,
          clearCheckedNodes,
          calculateCheckedValue,
          scrollToExpandingNode
        };
      }
    });
    function _sfc_render$s(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_cascader_menu = resolveComponent("el-cascader-menu");
      return openBlock(), createElementBlock("div", {
        class: normalizeClass([_ctx.ns.b("panel"), _ctx.ns.is("bordered", _ctx.border)]),
        onKeydown: _cache[0] || (_cache[0] = (...args) => _ctx.handleKeyDown && _ctx.handleKeyDown(...args))
      }, [
        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.menus, (menu, index2) => {
          return openBlock(), createBlock(_component_el_cascader_menu, {
            key: index2,
            ref_for: true,
            ref: (item) => _ctx.menuList[index2] = item,
            index: index2,
            nodes: [...menu]
          }, null, 8, ["index", "nodes"]);
        }), 128))
      ], 34);
    }
    var CascaderPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1J, [["render", _sfc_render$s], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/cascader-panel/src/index.vue"]]);
    CascaderPanel.install = (app) => {
      app.component(CascaderPanel.name, CascaderPanel);
    };
    const _CascaderPanel = CascaderPanel;
    const ElCascaderPanel = _CascaderPanel;
    const tagProps = buildProps({
      type: {
        type: String,
        values: ["success", "info", "warning", "danger", ""],
        default: ""
      },
      closable: Boolean,
      disableTransitions: Boolean,
      hit: Boolean,
      color: {
        type: String,
        default: ""
      },
      size: {
        type: String,
        values: componentSizes,
        default: ""
      },
      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__$15 = /* @__PURE__ */ defineComponent({
      name: "ElTag"
    });
    const _sfc_main$1I = /* @__PURE__ */ defineComponent({
      ...__default__$15,
      props: tagProps,
      emits: tagEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const tagSize = useFormSize();
        const ns = useNamespace("tag");
        const containerKls = computed(() => {
          const { type: type2, hit, effect, closable, round: round2 } = props;
          return [
            ns.b(),
            ns.is("closable", closable),
            ns.m(type2),
            ns.m(tagSize.value),
            ns.m(effect),
            ns.is("hit", hit),
            ns.is("round", round2)
          ];
        });
        const handleClose = (event) => {
          emit2("close", event);
        };
        const handleClick = (event) => {
          emit2("click", event);
        };
        return (_ctx, _cache) => {
          return _ctx.disableTransitions ? (openBlock(), createElementBlock("span", {
            key: 0,
            class: normalizeClass(unref(containerKls)),
            style: normalizeStyle({ backgroundColor: _ctx.color }),
            onClick: handleClick
          }, [
            createBaseVNode("span", {
              class: normalizeClass(unref(ns).e("content"))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2),
            _ctx.closable ? (openBlock(), createBlock(unref(ElIcon), {
              key: 0,
              class: normalizeClass(unref(ns).e("close")),
              onClick: withModifiers(handleClose, ["stop"])
            }, {
              default: withCtx(() => [
                createVNode(unref(close_default))
              ]),
              _: 1
            }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
          ], 6)) : (openBlock(), createBlock(Transition, {
            key: 1,
            name: `${unref(ns).namespace.value}-zoom-in-center`,
            appear: ""
          }, {
            default: withCtx(() => [
              createBaseVNode("span", {
                class: normalizeClass(unref(containerKls)),
                style: normalizeStyle({ backgroundColor: _ctx.color }),
                onClick: handleClick
              }, [
                createBaseVNode("span", {
                  class: normalizeClass(unref(ns).e("content"))
                }, [
                  renderSlot(_ctx.$slots, "default")
                ], 2),
                _ctx.closable ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 0,
                  class: normalizeClass(unref(ns).e("close")),
                  onClick: withModifiers(handleClose, ["stop"])
                }, {
                  default: withCtx(() => [
                    createVNode(unref(close_default))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
              ], 6)
            ]),
            _: 3
          }, 8, ["name"]));
        };
      }
    });
    var Tag = /* @__PURE__ */ _export_sfc$1(_sfc_main$1I, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tag/src/tag.vue"]]);
    const ElTag = withInstall(Tag);
    const cascaderProps = buildProps({
      ...CommonProps,
      size: useSizeProp,
      placeholder: String,
      disabled: Boolean,
      clearable: Boolean,
      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: {
        type: Boolean,
        default: false
      },
      debounce: {
        type: Number,
        default: 300
      },
      beforeFilter: {
        type: definePropType(Function),
        default: () => true
      },
      popperClass: {
        type: String,
        default: ""
      },
      teleported: useTooltipContentProps.teleported,
      tagType: { ...tagProps.type, default: "info" },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const cascaderEmits = {
      [UPDATE_MODEL_EVENT]: (val) => !!val || val === null,
      [CHANGE_EVENT]: (val) => !!val || val === null,
      focus: (evt) => evt instanceof FocusEvent,
      blur: (evt) => evt instanceof FocusEvent,
      visibleChange: (val) => isBoolean(val),
      expandChange: (val) => !!val,
      removeTag: (val) => !!val
    };
    const _hoisted_1$Q = { key: 0 };
    const _hoisted_2$y = ["placeholder", "onKeydown"];
    const _hoisted_3$i = ["onClick"];
    const COMPONENT_NAME$e = "ElCascader";
    const __default__$14 = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$e
    });
    const _sfc_main$1H = /* @__PURE__ */ defineComponent({
      ...__default__$14,
      props: cascaderProps,
      emits: cascaderEmits,
      setup(__props, { expose, emit: emit2 }) {
        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;
                modifiersData.arrow.x = 35;
              },
              requires: ["arrow"]
            }
          ]
        };
        const attrs = useAttrs$1();
        let inputInitialHeight = 0;
        let pressDeleteCount = 0;
        const nsCascader = useNamespace("cascader");
        const nsInput = useNamespace("input");
        const { t } = useLocale();
        const { form, formItem } = useFormItem();
        const tooltipRef = ref(null);
        const input = ref(null);
        const tagWrapper = ref(null);
        const cascaderPanelRef = ref(null);
        const suggestionPanel = ref(null);
        const popperVisible = ref(false);
        const inputHover = ref(false);
        const filtering = ref(false);
        const filterFocus = ref(false);
        const inputValue = ref("");
        const searchInputValue = ref("");
        const presentTags = ref([]);
        const allPresentTags = ref([]);
        const suggestions = ref([]);
        const isOnComposition = ref(false);
        const cascaderStyle = computed(() => {
          return attrs.style;
        });
        const isDisabled = computed(() => props.disabled || (form == null ? void 0 : form.disabled));
        const inputPlaceholder = computed(() => props.placeholder || t("el.cascader.placeholder"));
        const currentPlaceholder = computed(() => searchInputValue.value || presentTags.value.length > 0 || isOnComposition.value ? "" : inputPlaceholder.value);
        const realSize = useFormSize();
        const tagSize = computed(() => ["small"].includes(realSize.value) ? "small" : "default");
        const multiple = computed(() => !!props.props.multiple);
        const readonly2 = computed(() => !props.filterable || multiple.value);
        const searchKeyword = computed(() => multiple.value ? searchInputValue.value : inputValue.value);
        const checkedNodes = computed(() => {
          var _a2;
          return ((_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.checkedNodes) || [];
        });
        const clearBtnVisible = computed(() => {
          if (!props.clearable || isDisabled.value || filtering.value || !inputHover.value)
            return false;
          return !!checkedNodes.value.length;
        });
        const presentText = computed(() => {
          const { showAllLevels, separator } = props;
          const nodes = checkedNodes.value;
          return nodes.length ? multiple.value ? "" : nodes[0].calcText(showAllLevels, separator) : "";
        });
        const checkedValue = computed({
          get() {
            return cloneDeep(props.modelValue);
          },
          set(val) {
            emit2(UPDATE_MODEL_EVENT, val);
            emit2(CHANGE_EVENT, val);
            if (props.validateEvent) {
              formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
            }
          }
        });
        const cascaderKls = computed(() => {
          return [
            nsCascader.b(),
            nsCascader.m(realSize.value),
            nsCascader.is("disabled", isDisabled.value),
            attrs.class
          ];
        });
        const cascaderIconKls = computed(() => {
          return [
            nsInput.e("icon"),
            "icon-arrow-down",
            nsCascader.is("reverse", popperVisible.value)
          ];
        });
        const inputClass = computed(() => {
          return nsCascader.is("focus", popperVisible.value || filterFocus.value);
        });
        const contentRef = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
        });
        const togglePopperVisible = (visible) => {
          var _a2, _b, _c;
          if (isDisabled.value)
            return;
          visible = visible != null ? visible : !popperVisible.value;
          if (visible !== popperVisible.value) {
            popperVisible.value = visible;
            (_b = (_a2 = input.value) == null ? void 0 : _a2.input) == null ? void 0 : _b.setAttribute("aria-expanded", `${visible}`);
            if (visible) {
              updatePopperPosition();
              nextTick((_c = cascaderPanelRef.value) == null ? void 0 : _c.scrollToExpandingNode);
            } else if (props.filterable) {
              syncPresentTextValue();
            }
            emit2("visibleChange", visible);
          }
        };
        const updatePopperPosition = () => {
          nextTick(() => {
            var _a2;
            (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper();
          });
        };
        const hideSuggestionPanel = () => {
          filtering.value = false;
        };
        const genTag2 = (node) => {
          const { showAllLevels, separator } = props;
          return {
            node,
            key: node.uid,
            text: node.calcText(showAllLevels, separator),
            hitState: false,
            closable: !isDisabled.value && !node.isDisabled,
            isCollapseTag: false
          };
        };
        const deleteTag = (tag) => {
          var _a2;
          const node = tag.node;
          node.doCheck(false);
          (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.calculateCheckedValue();
          emit2("removeTag", node.valueByOption);
        };
        const calculatePresentTags = () => {
          if (!multiple.value)
            return;
          const nodes = checkedNodes.value;
          const tags = [];
          const allTags = [];
          nodes.forEach((node) => allTags.push(genTag2(node)));
          allPresentTags.value = allTags;
          if (nodes.length) {
            nodes.slice(0, props.maxCollapseTags).forEach((node) => tags.push(genTag2(node)));
            const rest = nodes.slice(props.maxCollapseTags);
            const restCount = rest.length;
            if (restCount) {
              if (props.collapseTags) {
                tags.push({
                  key: -1,
                  text: `+ ${restCount}`,
                  closable: false,
                  isCollapseTag: true
                });
              } else {
                rest.forEach((node) => tags.push(genTag2(node)));
              }
            }
          }
          presentTags.value = tags;
        };
        const calculateSuggestions = () => {
          var _a2, _b;
          const { filterMethod, showAllLevels, separator } = props;
          const res = (_b = (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.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) {
            presentTags.value.forEach((tag) => {
              tag.hitState = false;
            });
            allPresentTags.value.forEach((tag) => {
              tag.hitState = false;
            });
          }
          filtering.value = true;
          suggestions.value = res;
          updatePopperPosition();
        };
        const focusFirstNode = () => {
          var _a2;
          let firstNode;
          if (filtering.value && suggestionPanel.value) {
            firstNode = suggestionPanel.value.$el.querySelector(`.${nsCascader.e("suggestion-item")}`);
          } else {
            firstNode = (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.$el.querySelector(`.${nsCascader.b("node")}[tabindex="-1"]`);
          }
          if (firstNode) {
            firstNode.focus();
            !filtering.value && firstNode.click();
          }
        };
        const updateStyle = () => {
          var _a2, _b;
          const inputInner = (_a2 = input.value) == null ? void 0 : _a2.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 = presentTags.value.length > 0 ? `${Math.max(offsetHeight + 6, inputInitialHeight)}px` : `${inputInitialHeight}px`;
            inputInner.style.height = height;
            updatePopperPosition();
          }
        };
        const getCheckedNodes = (leafOnly) => {
          var _a2;
          return (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.getCheckedNodes(leafOnly);
        };
        const handleExpandChange = (value) => {
          updatePopperPosition();
          emit2("expandChange", value);
        };
        const handleComposition = (event) => {
          var _a2;
          const text = (_a2 = event.target) == null ? void 0 : _a2.value;
          if (event.type === "compositionend") {
            isOnComposition.value = false;
            nextTick(() => handleInput(text));
          } else {
            const lastCharacter = text[text.length - 1] || "";
            isOnComposition.value = !isKorean(lastCharacter);
          }
        };
        const handleKeyDown = (e) => {
          if (isOnComposition.value)
            return;
          switch (e.code) {
            case EVENT_CODE.enter:
              togglePopperVisible();
              break;
            case EVENT_CODE.down:
              togglePopperVisible(true);
              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 _a2;
          (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.clearCheckedNodes();
          if (!popperVisible.value && props.filterable) {
            syncPresentTextValue();
          }
          togglePopperVisible(false);
        };
        const syncPresentTextValue = () => {
          const { value } = presentText;
          inputValue.value = value;
          searchInputValue.value = value;
        };
        const handleSuggestionClick = (node) => {
          var _a2, _b;
          const { checked } = node;
          if (multiple.value) {
            (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.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 } = e;
          switch (code) {
            case EVENT_CODE.up:
            case EVENT_CODE.down: {
              const distance = code === EVENT_CODE.up ? -1 : 1;
              focusNode(getSibling(target, distance, `.${nsCascader.e("suggestion-item")}[tabindex="-1"]`));
              break;
            }
            case EVENT_CODE.enter:
              target.click();
              break;
          }
        };
        const handleDelete = () => {
          const tags = presentTags.value;
          const lastTag = tags[tags.length - 1];
          pressDeleteCount = searchInputValue.value ? 0 : pressDeleteCount + 1;
          if (!lastTag || !pressDeleteCount || props.collapseTags && tags.length > 1)
            return;
          if (lastTag.hitState) {
            deleteTag(lastTag);
          } else {
            lastTag.hitState = true;
          }
        };
        const handleFocus = (e) => {
          const el = e.target;
          const name = nsCascader.e("search-input");
          if (el.className === name) {
            filterFocus.value = true;
          }
          emit2("focus", e);
        };
        const handleBlur = (e) => {
          filterFocus.value = false;
          emit2("blur", e);
        };
        const handleFilter = debounce(() => {
          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();
          }
        }, props.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;
        watch(filtering, updatePopperPosition);
        watch([checkedNodes, isDisabled], calculatePresentTags);
        watch(presentTags, () => {
          nextTick(() => updateStyle());
        });
        watch(realSize, async () => {
          await nextTick();
          const inputInner = input.value.input;
          inputInitialHeight = getInputInnerHeight(inputInner) || inputInitialHeight;
          updateStyle();
        });
        watch(presentText, syncPresentTextValue, { immediate: true });
        onMounted(() => {
          const inputInner = input.value.input;
          const inputInnerHeight = getInputInnerHeight(inputInner);
          inputInitialHeight = inputInner.offsetHeight || inputInnerHeight;
          useResizeObserver(inputInner, updateStyle);
        });
        expose({
          getCheckedNodes,
          cascaderPanelRef,
          togglePopperVisible,
          contentRef
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElTooltip), {
            ref_key: "tooltipRef",
            ref: tooltipRef,
            visible: popperVisible.value,
            teleported: _ctx.teleported,
            "popper-class": [unref(nsCascader).e("dropdown"), _ctx.popperClass],
            "popper-options": popperOptions,
            "fallback-placements": [
              "bottom-start",
              "bottom",
              "top-start",
              "top",
              "right",
              "left"
            ],
            "stop-popper-mouse-event": false,
            "gpu-acceleration": false,
            placement: "bottom-start",
            transition: `${unref(nsCascader).namespace.value}-zoom-in-top`,
            effect: "light",
            pure: "",
            persistent: "",
            onHide: hideSuggestionPanel
          }, {
            default: withCtx(() => [
              withDirectives((openBlock(), createElementBlock("div", {
                class: normalizeClass(unref(cascaderKls)),
                style: normalizeStyle(unref(cascaderStyle)),
                onClick: _cache[5] || (_cache[5] = () => togglePopperVisible(unref(readonly2) ? void 0 : true)),
                onKeydown: handleKeyDown,
                onMouseenter: _cache[6] || (_cache[6] = ($event) => inputHover.value = true),
                onMouseleave: _cache[7] || (_cache[7] = ($event) => inputHover.value = false)
              }, [
                createVNode(unref(ElInput), {
                  ref_key: "input",
                  ref: input,
                  modelValue: inputValue.value,
                  "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => inputValue.value = $event),
                  placeholder: unref(currentPlaceholder),
                  readonly: unref(readonly2),
                  disabled: unref(isDisabled),
                  "validate-event": false,
                  size: unref(realSize),
                  class: normalizeClass(unref(inputClass)),
                  tabindex: unref(multiple) && _ctx.filterable && !unref(isDisabled) ? -1 : void 0,
                  onCompositionstart: handleComposition,
                  onCompositionupdate: handleComposition,
                  onCompositionend: handleComposition,
                  onFocus: handleFocus,
                  onBlur: handleBlur,
                  onInput: handleInput
                }, {
                  suffix: withCtx(() => [
                    unref(clearBtnVisible) ? (openBlock(), createBlock(unref(ElIcon), {
                      key: "clear",
                      class: normalizeClass([unref(nsInput).e("icon"), "icon-circle-close"]),
                      onClick: withModifiers(handleClear, ["stop"])
                    }, {
                      default: withCtx(() => [
                        createVNode(unref(circle_close_default))
                      ]),
                      _: 1
                    }, 8, ["class", "onClick"])) : (openBlock(), createBlock(unref(ElIcon), {
                      key: "arrow-down",
                      class: normalizeClass(unref(cascaderIconKls)),
                      onClick: _cache[0] || (_cache[0] = withModifiers(($event) => togglePopperVisible(), ["stop"]))
                    }, {
                      default: withCtx(() => [
                        createVNode(unref(arrow_down_default))
                      ]),
                      _: 1
                    }, 8, ["class"]))
                  ]),
                  _: 1
                }, 8, ["modelValue", "placeholder", "readonly", "disabled", "size", "class", "tabindex"]),
                unref(multiple) ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  ref_key: "tagWrapper",
                  ref: tagWrapper,
                  class: normalizeClass(unref(nsCascader).e("tags"))
                }, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(presentTags.value, (tag) => {
                    return openBlock(), createBlock(unref(ElTag), {
                      key: tag.key,
                      type: _ctx.tagType,
                      size: unref(tagSize),
                      hit: tag.hitState,
                      closable: tag.closable,
                      "disable-transitions": "",
                      onClose: ($event) => deleteTag(tag)
                    }, {
                      default: withCtx(() => [
                        tag.isCollapseTag === false ? (openBlock(), createElementBlock("span", _hoisted_1$Q, toDisplayString(tag.text), 1)) : (openBlock(), createBlock(unref(ElTooltip), {
                          key: 1,
                          disabled: popperVisible.value || !_ctx.collapseTagsTooltip,
                          "fallback-placements": ["bottom", "top", "right", "left"],
                          placement: "bottom",
                          effect: "light"
                        }, {
                          default: withCtx(() => [
                            createBaseVNode("span", null, toDisplayString(tag.text), 1)
                          ]),
                          content: withCtx(() => [
                            createBaseVNode("div", {
                              class: normalizeClass(unref(nsCascader).e("collapse-tags"))
                            }, [
                              (openBlock(true), createElementBlock(Fragment, null, renderList(allPresentTags.value.slice(_ctx.maxCollapseTags), (tag2, idx) => {
                                return openBlock(), createElementBlock("div", {
                                  key: idx,
                                  class: normalizeClass(unref(nsCascader).e("collapse-tag"))
                                }, [
                                  (openBlock(), createBlock(unref(ElTag), {
                                    key: tag2.key,
                                    class: "in-tooltip",
                                    type: _ctx.tagType,
                                    size: unref(tagSize),
                                    hit: tag2.hitState,
                                    closable: tag2.closable,
                                    "disable-transitions": "",
                                    onClose: ($event) => deleteTag(tag2)
                                  }, {
                                    default: withCtx(() => [
                                      createBaseVNode("span", null, toDisplayString(tag2.text), 1)
                                    ]),
                                    _: 2
                                  }, 1032, ["type", "size", "hit", "closable", "onClose"]))
                                ], 2);
                              }), 128))
                            ], 2)
                          ]),
                          _: 2
                        }, 1032, ["disabled"]))
                      ]),
                      _: 2
                    }, 1032, ["type", "size", "hit", "closable", "onClose"]);
                  }), 128)),
                  _ctx.filterable && !unref(isDisabled) ? withDirectives((openBlock(), createElementBlock("input", {
                    key: 0,
                    "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => searchInputValue.value = $event),
                    type: "text",
                    class: normalizeClass(unref(nsCascader).e("search-input")),
                    placeholder: unref(presentText) ? "" : unref(inputPlaceholder),
                    onInput: _cache[3] || (_cache[3] = (e) => handleInput(searchInputValue.value, e)),
                    onClick: _cache[4] || (_cache[4] = withModifiers(($event) => togglePopperVisible(true), ["stop"])),
                    onKeydown: withKeys(handleDelete, ["delete"]),
                    onCompositionstart: handleComposition,
                    onCompositionupdate: handleComposition,
                    onCompositionend: handleComposition,
                    onFocus: handleFocus,
                    onBlur: handleBlur
                  }, null, 42, _hoisted_2$y)), [
                    [vModelText, searchInputValue.value]
                  ]) : createCommentVNode("v-if", true)
                ], 2)) : createCommentVNode("v-if", true)
              ], 38)), [
                [unref(ClickOutside), () => togglePopperVisible(false), unref(contentRef)]
              ])
            ]),
            content: withCtx(() => [
              withDirectives(createVNode(unref(_CascaderPanel), {
                ref_key: "cascaderPanelRef",
                ref: cascaderPanelRef,
                modelValue: unref(checkedValue),
                "onUpdate:modelValue": _cache[8] || (_cache[8] = ($event) => isRef(checkedValue) ? checkedValue.value = $event : null),
                options: _ctx.options,
                props: props.props,
                border: false,
                "render-label": _ctx.$slots.default,
                onExpandChange: handleExpandChange,
                onClose: _cache[9] || (_cache[9] = ($event) => _ctx.$nextTick(() => togglePopperVisible(false)))
              }, null, 8, ["modelValue", "options", "props", "render-label"]), [
                [vShow, !filtering.value]
              ]),
              _ctx.filterable ? withDirectives((openBlock(), createBlock(unref(ElScrollbar), {
                key: 0,
                ref_key: "suggestionPanel",
                ref: suggestionPanel,
                tag: "ul",
                class: normalizeClass(unref(nsCascader).e("suggestion-panel")),
                "view-class": unref(nsCascader).e("suggestion-list"),
                onKeydown: handleSuggestionKeyDown
              }, {
                default: withCtx(() => [
                  suggestions.value.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(suggestions.value, (item) => {
                    return openBlock(), createElementBlock("li", {
                      key: item.uid,
                      class: normalizeClass([
                        unref(nsCascader).e("suggestion-item"),
                        unref(nsCascader).is("checked", item.checked)
                      ]),
                      tabindex: -1,
                      onClick: ($event) => handleSuggestionClick(item)
                    }, [
                      createBaseVNode("span", null, toDisplayString(item.text), 1),
                      item.checked ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
                        default: withCtx(() => [
                          createVNode(unref(check_default))
                        ]),
                        _: 1
                      })) : createCommentVNode("v-if", true)
                    ], 10, _hoisted_3$i);
                  }), 128)) : renderSlot(_ctx.$slots, "empty", { key: 1 }, () => [
                    createBaseVNode("li", {
                      class: normalizeClass(unref(nsCascader).e("empty-text"))
                    }, toDisplayString(unref(t)("el.cascader.noMatch")), 3)
                  ])
                ]),
                _: 3
              }, 8, ["class", "view-class"])), [
                [vShow, filtering.value]
              ]) : createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["visible", "teleported", "popper-class", "transition"]);
        };
      }
    });
    var Cascader = /* @__PURE__ */ _export_sfc$1(_sfc_main$1H, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/cascader/src/cascader.vue"]]);
    Cascader.install = (app) => {
      app.component(Cascader.name, Cascader);
    };
    const _Cascader = Cascader;
    const ElCascader = _Cascader;
    const checkTagProps = buildProps({
      checked: {
        type: Boolean,
        default: false
      }
    });
    const checkTagEmits = {
      "update:checked": (value) => isBoolean(value),
      [CHANGE_EVENT]: (value) => isBoolean(value)
    };
    const __default__$13 = /* @__PURE__ */ defineComponent({
      name: "ElCheckTag"
    });
    const _sfc_main$1G = /* @__PURE__ */ defineComponent({
      ...__default__$13,
      props: checkTagProps,
      emits: checkTagEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("check-tag");
        const containerKls = computed(() => [ns.b(), ns.is("checked", props.checked)]);
        const handleChange = () => {
          const checked = !props.checked;
          emit2(CHANGE_EVENT, checked);
          emit2("update:checked", checked);
        };
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("span", {
            class: normalizeClass(unref(containerKls)),
            onClick: handleChange
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var CheckTag = /* @__PURE__ */ _export_sfc$1(_sfc_main$1G, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/check-tag/src/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__$12 = /* @__PURE__ */ defineComponent({
      name: "ElRow"
    });
    const _sfc_main$1F = /* @__PURE__ */ defineComponent({
      ...__default__$12,
      props: rowProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("row");
        const gutter = computed(() => props.gutter);
        provide(rowContextKey, {
          gutter
        });
        const style = computed(() => {
          const styles = {};
          if (!props.gutter) {
            return styles;
          }
          styles.marginRight = styles.marginLeft = `-${props.gutter / 2}px`;
          return styles;
        });
        const rowKls = computed(() => [
          ns.b(),
          ns.is(`justify-${props.justify}`, props.justify !== "start"),
          ns.is(`align-${props.align}`, !!props.align)
        ]);
        return (_ctx, _cache) => {
          return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
            class: normalizeClass(unref(rowKls)),
            style: normalizeStyle(unref(style))
          }, {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["class", "style"]);
        };
      }
    });
    var Row = /* @__PURE__ */ _export_sfc$1(_sfc_main$1F, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/row/src/row.vue"]]);
    const ElRow = withInstall(Row);
    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__$11 = /* @__PURE__ */ defineComponent({
      name: "ElCol"
    });
    const _sfc_main$1E = /* @__PURE__ */ defineComponent({
      ...__default__$11,
      props: colProps,
      setup(__props) {
        const props = __props;
        const { gutter } = inject(rowContextKey, { gutter: computed(() => 0) });
        const ns = useNamespace("col");
        const style = computed(() => {
          const styles = {};
          if (gutter.value) {
            styles.paddingLeft = styles.paddingRight = `${gutter.value / 2}px`;
          }
          return styles;
        });
        const colKls = computed(() => {
          const classes = [];
          const pos = ["span", "offset", "pull", "push"];
          pos.forEach((prop) => {
            const size2 = props[prop];
            if (isNumber(size2)) {
              if (prop === "span")
                classes.push(ns.b(`${props[prop]}`));
              else if (size2 > 0)
                classes.push(ns.b(`${prop}-${props[prop]}`));
            }
          });
          const sizes = ["xs", "sm", "md", "lg", "xl"];
          sizes.forEach((size2) => {
            if (isNumber(props[size2])) {
              classes.push(ns.b(`${size2}-${props[size2]}`));
            } else if (isObject$1(props[size2])) {
              Object.entries(props[size2]).forEach(([prop, sizeProp]) => {
                classes.push(prop !== "span" ? ns.b(`${size2}-${prop}-${sizeProp}`) : ns.b(`${size2}-${sizeProp}`));
              });
            }
          });
          if (gutter.value) {
            classes.push(ns.is("guttered"));
          }
          return [ns.b(), classes];
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
            class: normalizeClass(unref(colKls)),
            style: normalizeStyle(unref(style))
          }, {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["class", "style"]);
        };
      }
    });
    var Col = /* @__PURE__ */ _export_sfc$1(_sfc_main$1E, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/col/src/col.vue"]]);
    const ElCol = withInstall(Col);
    const emitChangeFn = (value) => typeof isNumber(value);
    const collapseProps = buildProps({
      accordion: Boolean,
      modelValue: {
        type: definePropType([Array, String, Number]),
        default: () => mutable([])
      }
    });
    const collapseEmits = {
      [UPDATE_MODEL_EVENT]: emitChangeFn,
      [CHANGE_EVENT]: emitChangeFn
    };
    const collapseContextKey = Symbol("collapseContextKey");
    const useCollapse = (props, emit2) => {
      const activeNames = ref(castArray$1(props.modelValue));
      const setActiveNames = (_activeNames) => {
        activeNames.value = _activeNames;
        const value = props.accordion ? activeNames.value[0] : activeNames.value;
        emit2(UPDATE_MODEL_EVENT, value);
        emit2(CHANGE_EVENT, value);
      };
      const handleItemClick = (name) => {
        if (props.accordion) {
          setActiveNames([activeNames.value[0] === name ? "" : name]);
        } else {
          const _activeNames = [...activeNames.value];
          const index2 = _activeNames.indexOf(name);
          if (index2 > -1) {
            _activeNames.splice(index2, 1);
          } else {
            _activeNames.push(name);
          }
          setActiveNames(_activeNames);
        }
      };
      watch(() => props.modelValue, () => activeNames.value = castArray$1(props.modelValue), { deep: true });
      provide(collapseContextKey, {
        activeNames,
        handleItemClick
      });
      return {
        activeNames,
        setActiveNames
      };
    };
    const useCollapseDOM = () => {
      const ns = useNamespace("collapse");
      const rootKls = computed(() => ns.b());
      return {
        rootKls
      };
    };
    const __default__$10 = /* @__PURE__ */ defineComponent({
      name: "ElCollapse"
    });
    const _sfc_main$1D = /* @__PURE__ */ defineComponent({
      ...__default__$10,
      props: collapseProps,
      emits: collapseEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const { activeNames, setActiveNames } = useCollapse(props, emit2);
        const { rootKls } = useCollapseDOM();
        expose({
          activeNames,
          setActiveNames
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(rootKls))
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Collapse = /* @__PURE__ */ _export_sfc$1(_sfc_main$1D, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/collapse/src/collapse.vue"]]);
    const __default__$$ = /* @__PURE__ */ defineComponent({
      name: "ElCollapseTransition"
    });
    const _sfc_main$1C = /* @__PURE__ */ defineComponent({
      ...__default__$$,
      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 on2 = {
          beforeEnter(el) {
            if (!el.dataset)
              el.dataset = {};
            el.dataset.oldPaddingTop = el.style.paddingTop;
            el.dataset.oldPaddingBottom = el.style.paddingBottom;
            el.style.maxHeight = 0;
            el.style.paddingTop = 0;
            el.style.paddingBottom = 0;
          },
          enter(el) {
            el.dataset.oldOverflow = el.style.overflow;
            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 openBlock(), createBlock(Transition, mergeProps({
            name: unref(ns).b()
          }, toHandlers(on2)), {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 16, ["name"]);
        };
      }
    });
    var CollapseTransition = /* @__PURE__ */ _export_sfc$1(_sfc_main$1C, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/collapse-transition/src/collapse-transition.vue"]]);
    CollapseTransition.install = (app) => {
      app.component(CollapseTransition.name, CollapseTransition);
    };
    const _CollapseTransition = CollapseTransition;
    const ElCollapseTransition = _CollapseTransition;
    const collapseItemProps = buildProps({
      title: {
        type: String,
        default: ""
      },
      name: {
        type: definePropType([String, Number]),
        default: () => generateId()
      },
      disabled: Boolean
    });
    const useCollapseItem = (props) => {
      const collapse = inject(collapseContextKey);
      const focusing = ref(false);
      const isClick = ref(false);
      const id = ref(generateId());
      const isActive = computed(() => collapse == null ? void 0 : collapse.activeNames.value.includes(props.name));
      const handleFocus = () => {
        setTimeout(() => {
          if (!isClick.value) {
            focusing.value = true;
          } else {
            isClick.value = false;
          }
        }, 50);
      };
      const handleHeaderClick = () => {
        if (props.disabled)
          return;
        collapse == null ? void 0 : collapse.handleItemClick(props.name);
        focusing.value = false;
        isClick.value = true;
      };
      const handleEnterClick = () => {
        collapse == null ? void 0 : collapse.handleItemClick(props.name);
      };
      return {
        focusing,
        id,
        isActive,
        handleFocus,
        handleHeaderClick,
        handleEnterClick
      };
    };
    const useCollapseItemDOM = (props, { focusing, isActive, id }) => {
      const ns = useNamespace("collapse");
      const rootKls = computed(() => [
        ns.b("item"),
        ns.is("active", unref(isActive)),
        ns.is("disabled", props.disabled)
      ]);
      const headKls = computed(() => [
        ns.be("item", "header"),
        ns.is("active", unref(isActive)),
        { focusing: unref(focusing) && !props.disabled }
      ]);
      const arrowKls = computed(() => [
        ns.be("item", "arrow"),
        ns.is("active", unref(isActive))
      ]);
      const itemWrapperKls = computed(() => ns.be("item", "wrap"));
      const itemContentKls = computed(() => ns.be("item", "content"));
      const scopedContentId = computed(() => ns.b(`content-${unref(id)}`));
      const scopedHeadId = computed(() => ns.b(`head-${unref(id)}`));
      return {
        arrowKls,
        headKls,
        rootKls,
        itemWrapperKls,
        itemContentKls,
        scopedContentId,
        scopedHeadId
      };
    };
    const _hoisted_1$P = ["id", "aria-expanded", "aria-controls", "aria-describedby", "tabindex"];
    const _hoisted_2$x = ["id", "aria-hidden", "aria-labelledby"];
    const __default__$_ = /* @__PURE__ */ defineComponent({
      name: "ElCollapseItem"
    });
    const _sfc_main$1B = /* @__PURE__ */ defineComponent({
      ...__default__$_,
      props: collapseItemProps,
      setup(__props, { expose }) {
        const props = __props;
        const {
          focusing,
          id,
          isActive,
          handleFocus,
          handleHeaderClick,
          handleEnterClick
        } = useCollapseItem(props);
        const {
          arrowKls,
          headKls,
          rootKls,
          itemWrapperKls,
          itemContentKls,
          scopedContentId,
          scopedHeadId
        } = useCollapseItemDOM(props, { focusing, isActive, id });
        expose({
          isActive
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(rootKls))
          }, [
            createBaseVNode("button", {
              id: unref(scopedHeadId),
              class: normalizeClass(unref(headKls)),
              "aria-expanded": unref(isActive),
              "aria-controls": unref(scopedContentId),
              "aria-describedby": unref(scopedContentId),
              tabindex: _ctx.disabled ? -1 : 0,
              type: "button",
              onClick: _cache[0] || (_cache[0] = (...args) => unref(handleHeaderClick) && unref(handleHeaderClick)(...args)),
              onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers((...args) => unref(handleEnterClick) && unref(handleEnterClick)(...args), ["stop", "prevent"]), ["space", "enter"])),
              onFocus: _cache[2] || (_cache[2] = (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
              onBlur: _cache[3] || (_cache[3] = ($event) => focusing.value = false)
            }, [
              renderSlot(_ctx.$slots, "title", {}, () => [
                createTextVNode(toDisplayString(_ctx.title), 1)
              ]),
              createVNode(unref(ElIcon), {
                class: normalizeClass(unref(arrowKls))
              }, {
                default: withCtx(() => [
                  createVNode(unref(arrow_right_default))
                ]),
                _: 1
              }, 8, ["class"])
            ], 42, _hoisted_1$P),
            createVNode(unref(_CollapseTransition), null, {
              default: withCtx(() => [
                withDirectives(createBaseVNode("div", {
                  id: unref(scopedContentId),
                  role: "region",
                  class: normalizeClass(unref(itemWrapperKls)),
                  "aria-hidden": !unref(isActive),
                  "aria-labelledby": unref(scopedHeadId)
                }, [
                  createBaseVNode("div", {
                    class: normalizeClass(unref(itemContentKls))
                  }, [
                    renderSlot(_ctx.$slots, "default")
                  ], 2)
                ], 10, _hoisted_2$x), [
                  [vShow, unref(isActive)]
                ])
              ]),
              _: 3
            })
          ], 2);
        };
      }
    });
    var CollapseItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$1B, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/collapse/src/collapse-item.vue"]]);
    const ElCollapse = withInstall(Collapse, {
      CollapseItem
    });
    const ElCollapseItem = withNoopInstall(CollapseItem);
    const alphaSliderProps = buildProps({
      color: {
        type: definePropType(Object),
        required: true
      },
      vertical: {
        type: Boolean,
        default: false
      }
    });
    let isDragging = false;
    function draggable(element, options) {
      if (!isClient)
        return;
      const moveFn = function(event) {
        var _a2;
        (_a2 = options.drag) == null ? void 0 : _a2.call(options, event);
      };
      const upFn = function(event) {
        var _a2;
        document.removeEventListener("mousemove", moveFn);
        document.removeEventListener("mouseup", upFn);
        document.removeEventListener("touchmove", moveFn);
        document.removeEventListener("touchend", upFn);
        document.onselectstart = null;
        document.ondragstart = null;
        isDragging = false;
        (_a2 = options.end) == null ? void 0 : _a2.call(options, event);
      };
      const downFn = function(event) {
        var _a2;
        if (isDragging)
          return;
        event.preventDefault();
        document.onselectstart = () => false;
        document.ondragstart = () => false;
        document.addEventListener("mousemove", moveFn);
        document.addEventListener("mouseup", upFn);
        document.addEventListener("touchmove", moveFn);
        document.addEventListener("touchend", upFn);
        isDragging = true;
        (_a2 = options.start) == null ? void 0 : _a2.call(options, event);
      };
      element.addEventListener("mousedown", downFn);
      element.addEventListener("touchstart", downFn);
    }
    const useAlphaSlider = (props) => {
      const instance = getCurrentInstance();
      const thumb = shallowRef();
      const bar = shallowRef();
      function handleClick(event) {
        const target = event.target;
        if (target !== thumb.value) {
          handleDrag(event);
        }
      }
      function handleDrag(event) {
        if (!bar.value || !thumb.value)
          return;
        const el = instance.vnode.el;
        const rect = el.getBoundingClientRect();
        const { clientX, clientY } = getClientXY(event);
        if (!props.vertical) {
          let left2 = clientX - rect.left;
          left2 = Math.max(thumb.value.offsetWidth / 2, left2);
          left2 = Math.min(left2, rect.width - thumb.value.offsetWidth / 2);
          props.color.set("alpha", Math.round((left2 - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * 100));
        } else {
          let top = clientY - rect.top;
          top = Math.max(thumb.value.offsetHeight / 2, top);
          top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
          props.color.set("alpha", Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * 100));
        }
      }
      return {
        thumb,
        bar,
        handleDrag,
        handleClick
      };
    };
    const useAlphaSliderDOM = (props, {
      bar,
      thumb,
      handleDrag
    }) => {
      const instance = getCurrentInstance();
      const ns = useNamespace("color-alpha-slider");
      const thumbLeft = ref(0);
      const thumbTop = ref(0);
      const background = ref();
      function getThumbLeft() {
        if (!thumb.value)
          return 0;
        if (props.vertical)
          return 0;
        const el = instance.vnode.el;
        const alpha = props.color.get("alpha");
        if (!el)
          return 0;
        return Math.round(alpha * (el.offsetWidth - thumb.value.offsetWidth / 2) / 100);
      }
      function getThumbTop() {
        if (!thumb.value)
          return 0;
        const el = instance.vnode.el;
        if (!props.vertical)
          return 0;
        const alpha = props.color.get("alpha");
        if (!el)
          return 0;
        return Math.round(alpha * (el.offsetHeight - thumb.value.offsetHeight / 2) / 100);
      }
      function getBackground() {
        if (props.color && props.color.value) {
          const { r, g, b: b2 } = props.color.toRgb();
          return `linear-gradient(to right, rgba(${r}, ${g}, ${b2}, 0) 0%, rgba(${r}, ${g}, ${b2}, 1) 100%)`;
        }
        return "";
      }
      function update() {
        thumbLeft.value = getThumbLeft();
        thumbTop.value = getThumbTop();
        background.value = getBackground();
      }
      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();
      });
      watch(() => props.color.get("alpha"), () => update());
      watch(() => props.color.value, () => update());
      const rootKls = computed(() => [ns.b(), ns.is("vertical", props.vertical)]);
      const barKls = computed(() => ns.e("bar"));
      const thumbKls = computed(() => ns.e("thumb"));
      const barStyle = computed(() => ({ background: background.value }));
      const thumbStyle = computed(() => ({
        left: addUnit(thumbLeft.value),
        top: addUnit(thumbTop.value)
      }));
      return { rootKls, barKls, barStyle, thumbKls, thumbStyle, update };
    };
    const COMPONENT_NAME$d = "ElColorAlphaSlider";
    const __default__$Z = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$d
    });
    const _sfc_main$1A = /* @__PURE__ */ defineComponent({
      ...__default__$Z,
      props: alphaSliderProps,
      setup(__props, { expose }) {
        const props = __props;
        const { bar, thumb, handleDrag, handleClick } = useAlphaSlider(props);
        const { rootKls, barKls, barStyle, thumbKls, thumbStyle, update } = useAlphaSliderDOM(props, {
          bar,
          thumb,
          handleDrag
        });
        expose({
          update,
          bar,
          thumb
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(rootKls))
          }, [
            createBaseVNode("div", {
              ref_key: "bar",
              ref: bar,
              class: normalizeClass(unref(barKls)),
              style: normalizeStyle(unref(barStyle)),
              onClick: _cache[0] || (_cache[0] = (...args) => unref(handleClick) && unref(handleClick)(...args))
            }, null, 6),
            createBaseVNode("div", {
              ref_key: "thumb",
              ref: thumb,
              class: normalizeClass(unref(thumbKls)),
              style: normalizeStyle(unref(thumbStyle))
            }, null, 6)
          ], 2);
        };
      }
    });
    var AlphaSlider = /* @__PURE__ */ _export_sfc$1(_sfc_main$1A, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/color-picker/src/components/alpha-slider.vue"]]);
    const _sfc_main$1z = /* @__PURE__ */ defineComponent({
      name: "ElColorHueSlider",
      props: {
        color: {
          type: Object,
          required: true
        },
        vertical: Boolean
      },
      setup(props) {
        const ns = useNamespace("color-hue-slider");
        const instance = getCurrentInstance();
        const thumb = ref();
        const bar = ref();
        const thumbLeft = ref(0);
        const thumbTop = ref(0);
        const hueValue = computed(() => {
          return props.color.get("hue");
        });
        watch(() => hueValue.value, () => {
          update();
        });
        function handleClick(event) {
          const target = event.target;
          if (target !== thumb.value) {
            handleDrag(event);
          }
        }
        function handleDrag(event) {
          if (!bar.value || !thumb.value)
            return;
          const el = instance.vnode.el;
          const rect = el.getBoundingClientRect();
          const { clientX, clientY } = getClientXY(event);
          let hue;
          if (!props.vertical) {
            let left2 = clientX - rect.left;
            left2 = Math.min(left2, rect.width - thumb.value.offsetWidth / 2);
            left2 = Math.max(thumb.value.offsetWidth / 2, left2);
            hue = Math.round((left2 - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * 360);
          } else {
            let top = clientY - rect.top;
            top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
            top = Math.max(thumb.value.offsetHeight / 2, top);
            hue = Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * 360);
          }
          props.color.set("hue", hue);
        }
        function getThumbLeft() {
          if (!thumb.value)
            return 0;
          const el = instance.vnode.el;
          if (props.vertical)
            return 0;
          const hue = props.color.get("hue");
          if (!el)
            return 0;
          return Math.round(hue * (el.offsetWidth - thumb.value.offsetWidth / 2) / 360);
        }
        function getThumbTop() {
          if (!thumb.value)
            return 0;
          const el = instance.vnode.el;
          if (!props.vertical)
            return 0;
          const hue = props.color.get("hue");
          if (!el)
            return 0;
          return Math.round(hue * (el.offsetHeight - thumb.value.offsetHeight / 2) / 360);
        }
        function update() {
          thumbLeft.value = getThumbLeft();
          thumbTop.value = getThumbTop();
        }
        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();
        });
        return {
          bar,
          thumb,
          thumbLeft,
          thumbTop,
          hueValue,
          handleClick,
          update,
          ns
        };
      }
    });
    function _sfc_render$r(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createElementBlock("div", {
        class: normalizeClass([_ctx.ns.b(), _ctx.ns.is("vertical", _ctx.vertical)])
      }, [
        createBaseVNode("div", {
          ref: "bar",
          class: normalizeClass(_ctx.ns.e("bar")),
          onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
        }, null, 2),
        createBaseVNode("div", {
          ref: "thumb",
          class: normalizeClass(_ctx.ns.e("thumb")),
          style: normalizeStyle({
            left: _ctx.thumbLeft + "px",
            top: _ctx.thumbTop + "px"
          })
        }, null, 6)
      ], 2);
    }
    var HueSlider = /* @__PURE__ */ _export_sfc$1(_sfc_main$1z, [["render", _sfc_render$r], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/color-picker/src/components/hue-slider.vue"]]);
    const colorPickerProps = buildProps({
      modelValue: String,
      id: String,
      showAlpha: Boolean,
      colorFormat: String,
      disabled: Boolean,
      size: useSizeProp,
      popperClass: {
        type: String,
        default: ""
      },
      label: {
        type: String,
        default: void 0
      },
      tabindex: {
        type: [String, Number],
        default: 0
      },
      predefine: {
        type: definePropType(Array)
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    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: (event) => event instanceof FocusEvent,
      blur: (event) => event instanceof FocusEvent
    };
    const colorPickerContextKey = Symbol("colorPickerContextKey");
    const hsv2hsl = function(hue, sat, val) {
      return [
        hue,
        sat * val / ((hue = (2 - sat) * val) < 1 ? hue : 2 - hue) || 0,
        hue / 2
      ];
    };
    const isOnePointZero = function(n) {
      return typeof n === "string" && n.includes(".") && Number.parseFloat(n) === 1;
    };
    const isPercentage = function(n) {
      return typeof n === "string" && n.includes("%");
    };
    const bound01 = function(value, max2) {
      if (isOnePointZero(value))
        value = "100%";
      const processPercent = isPercentage(value);
      value = Math.min(max2, Math.max(0, Number.parseFloat(`${value}`)));
      if (processPercent) {
        value = Number.parseInt(`${value * max2}`, 10) / 100;
      }
      if (Math.abs(value - max2) < 1e-6) {
        return 1;
      }
      return value % max2 / Number.parseFloat(max2);
    };
    const INT_HEX_MAP = {
      10: "A",
      11: "B",
      12: "C",
      13: "D",
      14: "E",
      15: "F"
    };
    const hexOne = (value) => {
      value = Math.min(Math.round(value), 255);
      const high = Math.floor(value / 16);
      const low = value % 16;
      return `${INT_HEX_MAP[high] || high}${INT_HEX_MAP[low] || low}`;
    };
    const toHex = function({ r, g, b: b2 }) {
      if (Number.isNaN(+r) || Number.isNaN(+g) || Number.isNaN(+b2))
        return "";
      return `#${hexOne(r)}${hexOne(g)}${hexOne(b2)}`;
    };
    const HEX_INT_MAP = {
      A: 10,
      B: 11,
      C: 12,
      D: 13,
      E: 14,
      F: 15
    };
    const parseHexChannel = function(hex) {
      if (hex.length === 2) {
        return (HEX_INT_MAP[hex[0].toUpperCase()] || +hex[0]) * 16 + (HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1]);
      }
      return HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1];
    };
    const hsl2hsv = function(hue, sat, light) {
      sat = sat / 100;
      light = light / 100;
      let smin = sat;
      const lmin = Math.max(light, 0.01);
      light *= 2;
      sat *= light <= 1 ? light : 2 - light;
      smin *= lmin <= 1 ? lmin : 2 - lmin;
      const v2 = (light + sat) / 2;
      const sv = light === 0 ? 2 * smin / (lmin + smin) : 2 * sat / (light + sat);
      return {
        h: hue,
        s: sv * 100,
        v: v2 * 100
      };
    };
    const rgb2hsv = (r, g, b2) => {
      r = bound01(r, 255);
      g = bound01(g, 255);
      b2 = bound01(b2, 255);
      const max2 = Math.max(r, g, b2);
      const min2 = Math.min(r, g, b2);
      let h2;
      const v2 = max2;
      const d2 = max2 - min2;
      const s2 = max2 === 0 ? 0 : d2 / max2;
      if (max2 === min2) {
        h2 = 0;
      } else {
        switch (max2) {
          case r: {
            h2 = (g - b2) / d2 + (g < b2 ? 6 : 0);
            break;
          }
          case g: {
            h2 = (b2 - r) / d2 + 2;
            break;
          }
          case b2: {
            h2 = (r - g) / d2 + 4;
            break;
          }
        }
        h2 /= 6;
      }
      return { h: h2 * 360, s: s2 * 100, v: v2 * 100 };
    };
    const hsv2rgb = function(h2, s2, v2) {
      h2 = bound01(h2, 360) * 6;
      s2 = bound01(s2, 100);
      v2 = bound01(v2, 100);
      const i = Math.floor(h2);
      const f2 = h2 - i;
      const p2 = v2 * (1 - s2);
      const q2 = v2 * (1 - f2 * s2);
      const t = v2 * (1 - (1 - f2) * s2);
      const mod = i % 6;
      const r = [v2, q2, p2, p2, t, v2][mod];
      const g = [t, v2, v2, q2, p2, p2][mod];
      const b2 = [p2, p2, t, v2, v2, q2][mod];
      return {
        r: Math.round(r * 255),
        g: Math.round(g * 255),
        b: Math.round(b2 * 255)
      };
    };
    class Color {
      constructor(options = {}) {
        this._hue = 0;
        this._saturation = 100;
        this._value = 100;
        this._alpha = 100;
        this.enableAlpha = false;
        this.format = "hex";
        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 p2 in prop) {
            if (hasOwn(prop, p2)) {
              this.set(p2, prop[p2]);
            }
          }
          return;
        }
        this[`_${prop}`] = value;
        this.doOnChange();
      }
      get(prop) {
        if (prop === "alpha") {
          return Math.floor(this[`_${prop}`]);
        }
        return this[`_${prop}`];
      }
      toRgb() {
        return hsv2rgb(this._hue, this._saturation, this._value);
      }
      fromString(value) {
        if (!value) {
          this._hue = 0;
          this._saturation = 100;
          this._value = 100;
          this.doOnChange();
          return;
        }
        const fromHSV = (h2, s2, v2) => {
          this._hue = Math.max(0, Math.min(360, h2));
          this._saturation = Math.max(0, Math.min(100, s2));
          this._value = Math.max(0, Math.min(100, v2));
          this.doOnChange();
        };
        if (value.includes("hsl")) {
          const parts = value.replace(/hsla|hsl|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index2) => index2 > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
          if (parts.length === 4) {
            this._alpha = Number.parseFloat(parts[3]) * 100;
          } else if (parts.length === 3) {
            this._alpha = 100;
          }
          if (parts.length >= 3) {
            const { h: h2, s: s2, v: v2 } = hsl2hsv(parts[0], parts[1], parts[2]);
            fromHSV(h2, s2, v2);
          }
        } else if (value.includes("hsv")) {
          const parts = value.replace(/hsva|hsv|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index2) => index2 > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
          if (parts.length === 4) {
            this._alpha = Number.parseFloat(parts[3]) * 100;
          } else if (parts.length === 3) {
            this._alpha = 100;
          }
          if (parts.length >= 3) {
            fromHSV(parts[0], parts[1], parts[2]);
          }
        } else if (value.includes("rgb")) {
          const parts = value.replace(/rgba|rgb|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index2) => index2 > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
          if (parts.length === 4) {
            this._alpha = Number.parseFloat(parts[3]) * 100;
          } else if (parts.length === 3) {
            this._alpha = 100;
          }
          if (parts.length >= 3) {
            const { h: h2, s: s2, v: v2 } = rgb2hsv(parts[0], parts[1], parts[2]);
            fromHSV(h2, s2, v2);
          }
        } else if (value.includes("#")) {
          const hex = value.replace("#", "").trim();
          if (!/^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(hex))
            return;
          let r, g, b2;
          if (hex.length === 3) {
            r = parseHexChannel(hex[0] + hex[0]);
            g = parseHexChannel(hex[1] + hex[1]);
            b2 = parseHexChannel(hex[2] + hex[2]);
          } else if (hex.length === 6 || hex.length === 8) {
            r = parseHexChannel(hex.slice(0, 2));
            g = parseHexChannel(hex.slice(2, 4));
            b2 = parseHexChannel(hex.slice(4, 6));
          }
          if (hex.length === 8) {
            this._alpha = parseHexChannel(hex.slice(6)) / 255 * 100;
          } else if (hex.length === 3 || hex.length === 6) {
            this._alpha = 100;
          }
          const { h: h2, s: s2, v: v2 } = rgb2hsv(r, g, b2);
          fromHSV(h2, s2, v2);
        }
      }
      compare(color) {
        return Math.abs(color._hue - this._hue) < 2 && Math.abs(color._saturation - this._saturation) < 1 && Math.abs(color._value - this._value) < 1 && Math.abs(color._alpha - this._alpha) < 1;
      }
      doOnChange() {
        const { _hue, _saturation, _value, _alpha, format: format2 } = this;
        if (this.enableAlpha) {
          switch (format2) {
            case "hsl": {
              const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
              this.value = `hsla(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%, ${this.get("alpha") / 100})`;
              break;
            }
            case "hsv": {
              this.value = `hsva(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%, ${this.get("alpha") / 100})`;
              break;
            }
            case "hex": {
              this.value = `${toHex(hsv2rgb(_hue, _saturation, _value))}${hexOne(_alpha * 255 / 100)}`;
              break;
            }
            default: {
              const { r, g, b: b2 } = hsv2rgb(_hue, _saturation, _value);
              this.value = `rgba(${r}, ${g}, ${b2}, ${this.get("alpha") / 100})`;
            }
          }
        } else {
          switch (format2) {
            case "hsl": {
              const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
              this.value = `hsl(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%)`;
              break;
            }
            case "hsv": {
              this.value = `hsv(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%)`;
              break;
            }
            case "rgb": {
              const { r, g, b: b2 } = hsv2rgb(_hue, _saturation, _value);
              this.value = `rgb(${r}, ${g}, ${b2})`;
              break;
            }
            default: {
              this.value = toHex(hsv2rgb(_hue, _saturation, _value));
            }
          }
        }
      }
    }
    const _sfc_main$1y = /* @__PURE__ */ defineComponent({
      props: {
        colors: {
          type: Array,
          required: true
        },
        color: {
          type: Object,
          required: true
        }
      },
      setup(props) {
        const ns = useNamespace("color-predefine");
        const { currentColor } = inject(colorPickerContextKey);
        const rgbaColors = ref(parseColors(props.colors, props.color));
        watch(() => currentColor.value, (val) => {
          const color = new Color();
          color.fromString(val);
          rgbaColors.value.forEach((item) => {
            item.selected = color.compare(item);
          });
        });
        watchEffect(() => {
          rgbaColors.value = parseColors(props.colors, props.color);
        });
        function handleSelect(index2) {
          props.color.fromString(props.colors[index2]);
        }
        function parseColors(colors, color) {
          return colors.map((value) => {
            const c2 = new Color();
            c2.enableAlpha = true;
            c2.format = "rgba";
            c2.fromString(value);
            c2.selected = c2.value === color.value;
            return c2;
          });
        }
        return {
          rgbaColors,
          handleSelect,
          ns
        };
      }
    });
    const _hoisted_1$O = ["onClick"];
    function _sfc_render$q(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createElementBlock("div", {
        class: normalizeClass(_ctx.ns.b())
      }, [
        createBaseVNode("div", {
          class: normalizeClass(_ctx.ns.e("colors"))
        }, [
          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.rgbaColors, (item, index2) => {
            return openBlock(), createElementBlock("div", {
              key: _ctx.colors[index2],
              class: normalizeClass([
                _ctx.ns.e("color-selector"),
                _ctx.ns.is("alpha", item._alpha < 100),
                { selected: item.selected }
              ]),
              onClick: ($event) => _ctx.handleSelect(index2)
            }, [
              createBaseVNode("div", {
                style: normalizeStyle({ backgroundColor: item.value })
              }, null, 4)
            ], 10, _hoisted_1$O);
          }), 128))
        ], 2)
      ], 2);
    }
    var Predefine = /* @__PURE__ */ _export_sfc$1(_sfc_main$1y, [["render", _sfc_render$q], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/color-picker/src/components/predefine.vue"]]);
    const _sfc_main$1x = /* @__PURE__ */ defineComponent({
      name: "ElSlPanel",
      props: {
        color: {
          type: Object,
          required: true
        }
      },
      setup(props) {
        const ns = useNamespace("color-svpanel");
        const instance = getCurrentInstance();
        const cursorTop = ref(0);
        const cursorLeft = ref(0);
        const background = ref("hsl(0, 100%, 50%)");
        const colorValue = computed(() => {
          const hue = props.color.get("hue");
          const value = props.color.get("value");
          return { hue, value };
        });
        function update() {
          const saturation = props.color.get("saturation");
          const value = props.color.get("value");
          const el = instance.vnode.el;
          const { clientWidth: width, clientHeight: height } = el;
          cursorLeft.value = saturation * width / 100;
          cursorTop.value = (100 - value) * height / 100;
          background.value = `hsl(${props.color.get("hue")}, 100%, 50%)`;
        }
        function handleDrag(event) {
          const el = instance.vnode.el;
          const rect = el.getBoundingClientRect();
          const { clientX, clientY } = getClientXY(event);
          let left2 = clientX - rect.left;
          let top = clientY - rect.top;
          left2 = Math.max(0, left2);
          left2 = Math.min(left2, rect.width);
          top = Math.max(0, top);
          top = Math.min(top, rect.height);
          cursorLeft.value = left2;
          cursorTop.value = top;
          props.color.set({
            saturation: left2 / rect.width * 100,
            value: 100 - top / rect.height * 100
          });
        }
        watch(() => colorValue.value, () => {
          update();
        });
        onMounted(() => {
          draggable(instance.vnode.el, {
            drag: (event) => {
              handleDrag(event);
            },
            end: (event) => {
              handleDrag(event);
            }
          });
          update();
        });
        return {
          cursorTop,
          cursorLeft,
          background,
          colorValue,
          handleDrag,
          update,
          ns
        };
      }
    });
    const _hoisted_1$N = /* @__PURE__ */ createBaseVNode("div", null, null, -1);
    const _hoisted_2$w = [
      _hoisted_1$N
    ];
    function _sfc_render$p(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createElementBlock("div", {
        class: normalizeClass(_ctx.ns.b()),
        style: normalizeStyle({
          backgroundColor: _ctx.background
        })
      }, [
        createBaseVNode("div", {
          class: normalizeClass(_ctx.ns.e("white"))
        }, null, 2),
        createBaseVNode("div", {
          class: normalizeClass(_ctx.ns.e("black"))
        }, null, 2),
        createBaseVNode("div", {
          class: normalizeClass(_ctx.ns.e("cursor")),
          style: normalizeStyle({
            top: _ctx.cursorTop + "px",
            left: _ctx.cursorLeft + "px"
          })
        }, _hoisted_2$w, 6)
      ], 6);
    }
    var SvPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1x, [["render", _sfc_render$p], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/color-picker/src/components/sv-panel.vue"]]);
    const _hoisted_1$M = ["onKeydown"];
    const _hoisted_2$v = ["id", "aria-label", "aria-labelledby", "aria-description", "aria-disabled", "tabindex"];
    const __default__$Y = /* @__PURE__ */ defineComponent({
      name: "ElColorPicker"
    });
    const _sfc_main$1w = /* @__PURE__ */ defineComponent({
      ...__default__$Y,
      props: colorPickerProps,
      emits: colorPickerEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("color");
        const { formItem } = useFormItem();
        const colorSize = useFormSize();
        const colorDisabled = useFormDisabled();
        const { inputId: buttonId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const hue = ref();
        const sv = ref();
        const alpha = ref();
        const popper = ref();
        const triggerRef2 = ref();
        const inputRef = ref();
        const {
          isFocused,
          handleFocus: _handleFocus,
          handleBlur
        } = useFocusController(triggerRef2, {
          beforeBlur(event) {
            var _a2;
            return (_a2 = popper.value) == null ? void 0 : _a2.isFocusInsideContent(event);
          },
          afterBlur() {
            setShowPicker(false);
            resetColor();
          }
        });
        const handleFocus = (event) => {
          if (colorDisabled.value)
            return blur();
          _handleFocus(event);
        };
        let shouldActiveChange = true;
        const color = reactive(new Color({
          enableAlpha: props.showAlpha,
          format: props.colorFormat || "",
          value: props.modelValue
        }));
        const showPicker = ref(false);
        const showPanelColor = ref(false);
        const customInput = ref("");
        const displayedColor = computed(() => {
          if (!props.modelValue && !showPanelColor.value) {
            return "transparent";
          }
          return displayedRgb(color, props.showAlpha);
        });
        const currentColor = computed(() => {
          return !props.modelValue && !showPanelColor.value ? "" : color.value;
        });
        const buttonAriaLabel = computed(() => {
          return !isLabeledByFormItem.value ? props.label || t("el.colorpicker.defaultLabel") : void 0;
        });
        const buttonAriaLabelledby = computed(() => {
          return isLabeledByFormItem.value ? formItem == null ? void 0 : formItem.labelId : void 0;
        });
        const btnKls = computed(() => {
          return [
            ns.b("picker"),
            ns.is("disabled", colorDisabled.value),
            ns.bm("picker", colorSize.value),
            ns.is("focused", isFocused.value)
          ];
        });
        function displayedRgb(color2, showAlpha) {
          if (!(color2 instanceof Color)) {
            throw new TypeError("color should be instance of _color Class");
          }
          const { r, g, b: b2 } = color2.toRgb();
          return showAlpha ? `rgba(${r}, ${g}, ${b2}, ${color2.get("alpha") / 100})` : `rgb(${r}, ${g}, ${b2})`;
        }
        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() {
          nextTick(() => {
            if (props.modelValue) {
              color.fromString(props.modelValue);
            } else {
              color.value = "";
              nextTick(() => {
                showPanelColor.value = false;
              });
            }
          });
        }
        function handleTrigger() {
          if (colorDisabled.value)
            return;
          debounceSetShowPicker(!showPicker.value);
        }
        function handleConfirm() {
          color.fromString(customInput.value);
        }
        function confirmValue() {
          const value = color.value;
          emit2(UPDATE_MODEL_EVENT, value);
          emit2("change", value);
          if (props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
          debounceSetShowPicker(false);
          nextTick(() => {
            const newColor = new Color({
              enableAlpha: props.showAlpha,
              format: props.colorFormat || "",
              value: props.modelValue
            });
            if (!color.compare(newColor)) {
              resetColor();
            }
          });
        }
        function clear2() {
          debounceSetShowPicker(false);
          emit2(UPDATE_MODEL_EVENT, null);
          emit2("change", null);
          if (props.modelValue !== null && props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
          resetColor();
        }
        function handleClickOutside(event) {
          if (!showPicker.value)
            return;
          hide();
          if (isFocused.value) {
            const _event2 = new FocusEvent("focus", event);
            handleBlur(_event2);
          }
        }
        function handleEsc(event) {
          event.preventDefault();
          event.stopPropagation();
          setShowPicker(false);
          resetColor();
        }
        function handleKeyDown(event) {
          switch (event.code) {
            case EVENT_CODE.enter:
            case EVENT_CODE.space:
              event.preventDefault();
              event.stopPropagation();
              show();
              inputRef.value.focus();
              break;
            case EVENT_CODE.esc:
              handleEsc(event);
              break;
          }
        }
        function focus() {
          triggerRef2.value.focus();
        }
        function blur() {
          triggerRef2.value.blur();
        }
        onMounted(() => {
          if (props.modelValue) {
            customInput.value = currentColor.value;
          }
        });
        watch(() => props.modelValue, (newVal) => {
          if (!newVal) {
            showPanelColor.value = false;
          } else if (newVal && newVal !== color.value) {
            shouldActiveChange = false;
            color.fromString(newVal);
          }
        });
        watch(() => currentColor.value, (val) => {
          customInput.value = val;
          shouldActiveChange && emit2("activeChange", val);
          shouldActiveChange = true;
        });
        watch(() => color.value, () => {
          if (!props.modelValue && !showPanelColor.value) {
            showPanelColor.value = true;
          }
        });
        watch(() => showPicker.value, () => {
          nextTick(() => {
            var _a2, _b, _c;
            (_a2 = hue.value) == null ? void 0 : _a2.update();
            (_b = sv.value) == null ? void 0 : _b.update();
            (_c = alpha.value) == null ? void 0 : _c.update();
          });
        });
        provide(colorPickerContextKey, {
          currentColor
        });
        expose({
          color,
          show,
          hide,
          focus,
          blur
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(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": [unref(ns).be("picker", "panel"), unref(ns).b("dropdown"), _ctx.popperClass],
            "stop-popper-mouse-event": false,
            effect: "light",
            trigger: "click",
            transition: `${unref(ns).namespace.value}-zoom-in-top`,
            persistent: "",
            onHide: _cache[2] || (_cache[2] = ($event) => setShowPicker(false))
          }, {
            content: withCtx(() => [
              withDirectives((openBlock(), createElementBlock("div", {
                onKeydown: withKeys(handleEsc, ["esc"])
              }, [
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).be("dropdown", "main-wrapper"))
                }, [
                  createVNode(HueSlider, {
                    ref_key: "hue",
                    ref: hue,
                    class: "hue-slider",
                    color: unref(color),
                    vertical: ""
                  }, null, 8, ["color"]),
                  createVNode(SvPanel, {
                    ref_key: "sv",
                    ref: sv,
                    color: unref(color)
                  }, null, 8, ["color"])
                ], 2),
                _ctx.showAlpha ? (openBlock(), createBlock(AlphaSlider, {
                  key: 0,
                  ref_key: "alpha",
                  ref: alpha,
                  color: unref(color)
                }, null, 8, ["color"])) : createCommentVNode("v-if", true),
                _ctx.predefine ? (openBlock(), createBlock(Predefine, {
                  key: 1,
                  ref: "predefine",
                  color: unref(color),
                  colors: _ctx.predefine
                }, null, 8, ["color", "colors"])) : createCommentVNode("v-if", true),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).be("dropdown", "btns"))
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass(unref(ns).be("dropdown", "value"))
                  }, [
                    createVNode(unref(ElInput), {
                      ref_key: "inputRef",
                      ref: inputRef,
                      modelValue: customInput.value,
                      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => customInput.value = $event),
                      "validate-event": false,
                      size: "small",
                      onKeyup: withKeys(handleConfirm, ["enter"]),
                      onBlur: handleConfirm
                    }, null, 8, ["modelValue", "onKeyup"])
                  ], 2),
                  createVNode(unref(ElButton), {
                    class: normalizeClass(unref(ns).be("dropdown", "link-btn")),
                    text: "",
                    size: "small",
                    onClick: clear2
                  }, {
                    default: withCtx(() => [
                      createTextVNode(toDisplayString(unref(t)("el.colorpicker.clear")), 1)
                    ]),
                    _: 1
                  }, 8, ["class"]),
                  createVNode(unref(ElButton), {
                    plain: "",
                    size: "small",
                    class: normalizeClass(unref(ns).be("dropdown", "btn")),
                    onClick: confirmValue
                  }, {
                    default: withCtx(() => [
                      createTextVNode(toDisplayString(unref(t)("el.colorpicker.confirm")), 1)
                    ]),
                    _: 1
                  }, 8, ["class"])
                ], 2)
              ], 40, _hoisted_1$M)), [
                [unref(ClickOutside), handleClickOutside]
              ])
            ]),
            default: withCtx(() => [
              createBaseVNode("div", {
                id: unref(buttonId),
                ref_key: "triggerRef",
                ref: triggerRef2,
                class: normalizeClass(unref(btnKls)),
                role: "button",
                "aria-label": unref(buttonAriaLabel),
                "aria-labelledby": unref(buttonAriaLabelledby),
                "aria-description": unref(t)("el.colorpicker.description", { color: _ctx.modelValue || "" }),
                "aria-disabled": unref(colorDisabled),
                tabindex: unref(colorDisabled) ? -1 : _ctx.tabindex,
                onKeydown: handleKeyDown,
                onFocus: handleFocus,
                onBlur: _cache[1] || (_cache[1] = (...args) => unref(handleBlur) && unref(handleBlur)(...args))
              }, [
                unref(colorDisabled) ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  class: normalizeClass(unref(ns).be("picker", "mask"))
                }, null, 2)) : createCommentVNode("v-if", true),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).be("picker", "trigger")),
                  onClick: handleTrigger
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass([unref(ns).be("picker", "color"), unref(ns).is("alpha", _ctx.showAlpha)])
                  }, [
                    createBaseVNode("span", {
                      class: normalizeClass(unref(ns).be("picker", "color-inner")),
                      style: normalizeStyle({
                        backgroundColor: unref(displayedColor)
                      })
                    }, [
                      withDirectives(createVNode(unref(ElIcon), {
                        class: normalizeClass([unref(ns).be("picker", "icon"), unref(ns).is("icon-arrow-down")])
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_down_default))
                        ]),
                        _: 1
                      }, 8, ["class"]), [
                        [vShow, _ctx.modelValue || showPanelColor.value]
                      ]),
                      withDirectives(createVNode(unref(ElIcon), {
                        class: normalizeClass([unref(ns).be("picker", "empty"), unref(ns).is("icon-close")])
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(close_default))
                        ]),
                        _: 1
                      }, 8, ["class"]), [
                        [vShow, !_ctx.modelValue && !showPanelColor.value]
                      ])
                    ], 6)
                  ], 2)
                ], 2)
              ], 42, _hoisted_2$v)
            ]),
            _: 1
          }, 8, ["visible", "popper-class", "transition"]);
        };
      }
    });
    var ColorPicker = /* @__PURE__ */ _export_sfc$1(_sfc_main$1w, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/color-picker/src/color-picker.vue"]]);
    const ElColorPicker = withInstall(ColorPicker);
    const __default__$X = /* @__PURE__ */ defineComponent({
      name: "ElContainer"
    });
    const _sfc_main$1v = /* @__PURE__ */ defineComponent({
      ...__default__$X,
      props: {
        direction: {
          type: String
        }
      },
      setup(__props) {
        const props = __props;
        const slots = useSlots();
        const ns = useNamespace("container");
        const isVertical = 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 openBlock(), createElementBlock("section", {
            class: normalizeClass([unref(ns).b(), unref(ns).is("vertical", unref(isVertical))])
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Container = /* @__PURE__ */ _export_sfc$1(_sfc_main$1v, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/container/src/container.vue"]]);
    const __default__$W = /* @__PURE__ */ defineComponent({
      name: "ElAside"
    });
    const _sfc_main$1u = /* @__PURE__ */ defineComponent({
      ...__default__$W,
      props: {
        width: {
          type: String,
          default: null
        }
      },
      setup(__props) {
        const props = __props;
        const ns = useNamespace("aside");
        const style = computed(() => props.width ? ns.cssVarBlock({ width: props.width }) : {});
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("aside", {
            class: normalizeClass(unref(ns).b()),
            style: normalizeStyle(unref(style))
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 6);
        };
      }
    });
    var Aside = /* @__PURE__ */ _export_sfc$1(_sfc_main$1u, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/container/src/aside.vue"]]);
    const __default__$V = /* @__PURE__ */ defineComponent({
      name: "ElFooter"
    });
    const _sfc_main$1t = /* @__PURE__ */ defineComponent({
      ...__default__$V,
      props: {
        height: {
          type: String,
          default: null
        }
      },
      setup(__props) {
        const props = __props;
        const ns = useNamespace("footer");
        const style = computed(() => props.height ? ns.cssVarBlock({ height: props.height }) : {});
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("footer", {
            class: normalizeClass(unref(ns).b()),
            style: normalizeStyle(unref(style))
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 6);
        };
      }
    });
    var Footer$2 = /* @__PURE__ */ _export_sfc$1(_sfc_main$1t, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/container/src/footer.vue"]]);
    const __default__$U = /* @__PURE__ */ defineComponent({
      name: "ElHeader"
    });
    const _sfc_main$1s = /* @__PURE__ */ defineComponent({
      ...__default__$U,
      props: {
        height: {
          type: String,
          default: null
        }
      },
      setup(__props) {
        const props = __props;
        const ns = useNamespace("header");
        const style = computed(() => {
          return props.height ? ns.cssVarBlock({
            height: props.height
          }) : {};
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("header", {
            class: normalizeClass(unref(ns).b()),
            style: normalizeStyle(unref(style))
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 6);
        };
      }
    });
    var Header = /* @__PURE__ */ _export_sfc$1(_sfc_main$1s, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/container/src/header.vue"]]);
    const __default__$T = /* @__PURE__ */ defineComponent({
      name: "ElMain"
    });
    const _sfc_main$1r = /* @__PURE__ */ defineComponent({
      ...__default__$T,
      setup(__props) {
        const ns = useNamespace("main");
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("main", {
            class: normalizeClass(unref(ns).b())
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Main = /* @__PURE__ */ _export_sfc$1(_sfc_main$1r, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/container/src/main.vue"]]);
    const ElContainer = withInstall(Container, {
      Aside,
      Footer: Footer$2,
      Header,
      Main
    });
    const ElAside = withNoopInstall(Aside);
    const ElFooter = withNoopInstall(Footer$2);
    const ElHeader = withNoopInstall(Header);
    const ElMain = withNoopInstall(Main);
    var advancedFormat$1 = { exports: {} };
    (function(module2, exports2) {
      !function(e, t) {
        module2.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 s2 = this.$utils(), a2 = (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 s2.s(t2.week(), "w" === e3 ? 1 : 2, "0");
                case "W":
                case "WW":
                  return s2.s(t2.isoWeek(), "W" === e3 ? 1 : 2, "0");
                case "k":
                case "kk":
                  return s2.s(String(0 === t2.$H ? 24 : t2.$H), "k" === e3 ? 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)(a2);
          };
        };
      });
    })(advancedFormat$1);
    var advancedFormatExports = advancedFormat$1.exports;
    const advancedFormat = /* @__PURE__ */ getDefaultExportFromCjs(advancedFormatExports);
    var weekOfYear$1 = { exports: {} };
    (function(module2, exports2) {
      !function(e, t) {
        module2.exports = t();
      }(commonjsGlobal, function() {
        var e = "week", t = "year";
        return function(i, n, r) {
          var f2 = n.prototype;
          f2.week = function(i2) {
            if (void 0 === i2 && (i2 = null), null !== i2)
              return this.add(7 * (i2 - this.week()), "day");
            var n2 = this.$locale().yearStart || 1;
            if (11 === this.month() && this.date() > 25) {
              var f3 = r(this).startOf(t).add(1, t).date(n2), s2 = r(this).endOf(e);
              if (f3.isBefore(s2))
                return 1;
            }
            var a2 = r(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o2 = this.diff(a2, e, true);
            return o2 < 0 ? r(this).startOf("week").week() : Math.ceil(o2);
          }, f2.weeks = function(e2) {
            return void 0 === e2 && (e2 = null), this.week(e2);
          };
        };
      });
    })(weekOfYear$1);
    var weekOfYearExports = weekOfYear$1.exports;
    const weekOfYear = /* @__PURE__ */ getDefaultExportFromCjs(weekOfYearExports);
    var weekYear$1 = { exports: {} };
    (function(module2, exports2) {
      !function(e, t) {
        module2.exports = t();
      }(commonjsGlobal, function() {
        return function(e, t) {
          t.prototype.weekYear = function() {
            var e2 = this.month(), t2 = this.week(), n = this.year();
            return 1 === t2 && 11 === e2 ? n + 1 : 0 === e2 && t2 >= 52 ? n - 1 : n;
          };
        };
      });
    })(weekYear$1);
    var weekYearExports = weekYear$1.exports;
    const weekYear = /* @__PURE__ */ getDefaultExportFromCjs(weekYearExports);
    var dayOfYear$1 = { exports: {} };
    (function(module2, exports2) {
      !function(e, t) {
        module2.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 null == e2 ? t2 : this.add(e2 - t2, "day");
          };
        };
      });
    })(dayOfYear$1);
    var dayOfYearExports = dayOfYear$1.exports;
    const dayOfYear = /* @__PURE__ */ getDefaultExportFromCjs(dayOfYearExports);
    var isSameOrAfter$1 = { exports: {} };
    (function(module2, exports2) {
      !function(e, t) {
        module2.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 isSameOrAfterExports = isSameOrAfter$1.exports;
    const isSameOrAfter = /* @__PURE__ */ getDefaultExportFromCjs(isSameOrAfterExports);
    var isSameOrBefore$1 = { exports: {} };
    (function(module2, exports2) {
      !function(e, i) {
        module2.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 isSameOrBeforeExports = isSameOrBefore$1.exports;
    const isSameOrBefore = /* @__PURE__ */ getDefaultExportFromCjs(isSameOrBeforeExports);
    const ROOT_PICKER_INJECTION_KEY = Symbol();
    const datePickerProps = buildProps({
      ...timePickerDefaultProps,
      type: {
        type: definePropType(String),
        default: "date"
      }
    });
    const selectionModes = ["date", "dates", "year", "month", "week", "range"];
    const datePickerSharedProps = buildProps({
      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
        })
      }
    });
    const panelSharedProps = buildProps({
      type: {
        type: definePropType(String),
        required: true,
        values: datePickTypes
      },
      dateFormat: String,
      timeFormat: String
    });
    const panelRangeSharedProps = buildProps({
      unlinkPanels: 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
      },
      format: {
        type: String,
        default: ""
      }
    });
    const basicDateTableProps = buildProps({
      ...datePickerSharedProps,
      cellClassName: {
        type: definePropType(Function)
      },
      showWeekNumber: Boolean,
      selectionMode: selectionModeWithDefault("date")
    });
    const basicDateTableEmits = ["changerange", "pick", "select"];
    const isValidRange = (range2) => {
      if (!isArray$3(range2))
        return false;
      const [left2, right2] = range2;
      return dayjs.isDayjs(left2) && dayjs.isDayjs(right2) && left2.isSameOrBefore(right2);
    };
    const getDefaultValue = (defaultValue, { lang, unit: unit2, unlinkPanels }) => {
      let start;
      if (isArray$3(defaultValue)) {
        let [left2, right2] = defaultValue.map((d2) => dayjs(d2).locale(lang));
        if (!unlinkPanels) {
          right2 = left2.add(1, unit2);
        }
        return [left2, right2];
      } else if (defaultValue) {
        start = dayjs(defaultValue);
      } else {
        start = dayjs();
      }
      start = start.locale(lang);
      return [start, start.add(1, unit2)];
    };
    const buildPickerTable = (dimension, rows, {
      columnIndexOffset,
      startDate,
      nextEndDate,
      now: now2,
      unit: unit2,
      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 index2 = rowIndex * dimension.column + columnIndex;
          const nextStartDate = relativeDateGetter(index2);
          cell.dayjs = nextStartDate;
          cell.date = nextStartDate.toDate();
          cell.timestamp = nextStartDate.valueOf();
          cell.type = "normal";
          cell.inRange = !!(startDate && nextStartDate.isSameOrAfter(startDate, unit2) && nextEndDate && nextStartDate.isSameOrBefore(nextEndDate, unit2)) || !!(startDate && nextStartDate.isSameOrBefore(startDate, unit2) && nextEndDate && nextStartDate.isSameOrAfter(nextEndDate, unit2));
          if (startDate == null ? void 0 : startDate.isSameOrAfter(nextEndDate)) {
            cell.start = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit2);
            cell.end = startDate && nextStartDate.isSame(startDate, unit2);
          } else {
            cell.start = !!startDate && nextStartDate.isSame(startDate, unit2);
            cell.end = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit2);
          }
          const isToday = nextStartDate.isSame(now2, unit2);
          if (isToday) {
            cell.type = "today";
          }
          setCellMetadata == null ? void 0 : setCellMetadata(cell, { rowIndex, columnIndex });
          row[columnIndex + columnIndexOffset] = cell;
        }
        setRowMetadata == null ? void 0 : setRowMetadata(row);
      }
    };
    const isNormalDay = (type2 = "") => {
      return ["normal", "today"].includes(type2);
    };
    const useBasicDateTable = (props, emit2) => {
      const { lang } = useLocale();
      const tbodyRef = ref();
      const currentCellRef = ref();
      const lastRow = ref();
      const lastColumn = ref();
      const tableRows = ref([[], [], [], [], [], []]);
      let focusWithClick = false;
      const firstDayOfWeek = props.date.$locale().weekStart || 7;
      const WEEKS_CONSTANT = props.date.locale("en").localeData().weekdaysShort().map((_2) => _2.toLowerCase());
      const offsetDay = computed(() => {
        return firstDayOfWeek > 3 ? 7 - firstDayOfWeek : -firstDayOfWeek;
      });
      const startDate = computed(() => {
        const startDayOfMonth = props.date.startOf("month");
        return startDayOfMonth.subtract(startDayOfMonth.day() || 7, "day");
      });
      const WEEKS = computed(() => {
        return WEEKS_CONSTANT.concat(WEEKS_CONSTANT).slice(firstDayOfWeek, firstDayOfWeek + 7);
      });
      const hasCurrent = computed(() => {
        return flatten(unref(rows)).some((row) => {
          return row.isCurrent;
        });
      });
      const days = 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 = computed(() => {
        return props.selectionMode === "dates" ? castArray(props.parsedValue) : [];
      });
      const setDateText = (cell, { count, rowIndex, columnIndex }) => {
        const { startOfMonthDay, dateCountOfMonth, dateCountOfLastMonth } = unref(days);
        const offset2 = unref(offsetDay);
        if (rowIndex >= 0 && rowIndex <= 1) {
          const numberOfDaysFromPreviousMonth = startOfMonthDay + offset2 < 0 ? 7 + startOfMonthDay + offset2 : startOfMonthDay + offset2;
          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: disabledDate2, cellClassName } = props;
        const _selectedDate = unref(selectedDate);
        const shouldIncrement = setDateText(cell, { count, rowIndex, columnIndex });
        const cellDate = cell.dayjs.toDate();
        cell.selected = _selectedDate.find((d2) => d2.valueOf() === cell.dayjs.valueOf());
        cell.isSelected = !!cell.selected;
        cell.isCurrent = isCurrent(cell);
        cell.disabled = disabledDate2 == null ? void 0 : disabledDate2(cellDate);
        cell.customClass = cellClassName == null ? void 0 : cellClassName(cellDate);
        return shouldIncrement;
      };
      const setRowMetadata = (row) => {
        if (props.selectionMode === "week") {
          const [start, end2] = props.showWeekNumber ? [1, 7] : [0, 6];
          const isActive = isWeekActive(row[start + 1]);
          row[start].inRange = isActive;
          row[start].start = isActive;
          row[end2].inRange = isActive;
          row[end2].end = isActive;
        }
      };
      const rows = computed(() => {
        const { minDate, maxDate, rangeState, showWeekNumber } = props;
        const offset2 = unref(offsetDay);
        const rows_ = unref(tableRows);
        const dateUnit = "day";
        let count = 1;
        if (showWeekNumber) {
          for (let rowIndex = 0; rowIndex < 6; rowIndex++) {
            if (!rows_[rowIndex][0]) {
              rows_[rowIndex][0] = {
                type: "week",
                text: unref(startDate).add(rowIndex * 7 + 1, dateUnit).week()
              };
            }
          }
        }
        buildPickerTable({ row: 6, column: 7 }, rows_, {
          startDate: minDate,
          columnIndexOffset: showWeekNumber ? 1 : 0,
          nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
          now: dayjs().locale(unref(lang)).startOf(dateUnit),
          unit: dateUnit,
          relativeDateGetter: (idx) => unref(startDate).add(idx - offset2, dateUnit),
          setCellMetadata: (...args) => {
            if (setCellMetadata(...args, count)) {
              count += 1;
            }
          },
          setRowMetadata
        });
        return rows_;
      });
      watch(() => props.date, async () => {
        var _a2;
        if ((_a2 = unref(tbodyRef)) == null ? void 0 : _a2.contains(document.activeElement)) {
          await nextTick();
          await focus();
        }
      });
      const focus = async () => {
        var _a2;
        return (_a2 = unref(currentCellRef)) == null ? void 0 : _a2.focus();
      };
      const isCurrent = (cell) => {
        return props.selectionMode === "date" && isNormalDay(cell.type) && cellMatchesDate(cell, props.parsedValue);
      };
      const cellMatchesDate = (cell, date2) => {
        if (!date2)
          return false;
        return dayjs(date2).locale(unref(lang)).isSame(props.date.date(Number(cell.text)), "day");
      };
      const getDateOfCell = (row, column) => {
        const offsetFromStart = row * 7 + (column - (props.showWeekNumber ? 1 : 0)) - unref(offsetDay);
        return unref(startDate).add(offsetFromStart, "day");
      };
      const handleMouseMove = (event) => {
        var _a2;
        if (!props.rangeState.selecting)
          return;
        let target = event.target;
        if (target.tagName === "SPAN") {
          target = (_a2 = target.parentNode) == null ? void 0 : _a2.parentNode;
        }
        if (target.tagName === "DIV") {
          target = target.parentNode;
        }
        if (target.tagName !== "TD")
          return;
        const row = target.parentNode.rowIndex - 1;
        const column = target.cellIndex;
        if (unref(rows)[row][column].disabled)
          return;
        if (row !== unref(lastRow) || column !== unref(lastColumn)) {
          lastRow.value = row;
          lastColumn.value = column;
          emit2("changerange", {
            selecting: true,
            endDate: getDateOfCell(row, column)
          });
        }
      };
      const isSelectedCell = (cell) => {
        return !unref(hasCurrent) && (cell == null ? void 0 : cell.text) === 1 && cell.type === "normal" || cell.isCurrent;
      };
      const handleFocus = (event) => {
        if (focusWithClick || 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) {
          emit2("pick", { minDate: newDate, maxDate: null });
          emit2("select", true);
        } else {
          if (newDate >= props.minDate) {
            emit2("pick", { minDate: props.minDate, maxDate: newDate });
          } else {
            emit2("pick", { minDate: newDate, maxDate: props.minDate });
          }
          emit2("select", false);
        }
      };
      const handleWeekPick = (newDate) => {
        const weekNumber = newDate.week();
        const value = `${newDate.year()}w${weekNumber}`;
        emit2("pick", {
          year: newDate.year(),
          week: weekNumber,
          value,
          date: newDate.startOf("week")
        });
      };
      const handleDatesPick = (newDate, selected) => {
        const newValue = selected ? castArray(props.parsedValue).filter((d2) => (d2 == null ? void 0 : d2.valueOf()) !== newDate.valueOf()) : castArray(props.parsedValue).concat([newDate]);
        emit2("pick", newValue);
      };
      const handlePickDate = (event, isKeyboardMovement = false) => {
        const target = event.target.closest("td");
        if (!target)
          return;
        const row = target.parentNode.rowIndex - 1;
        const column = target.cellIndex;
        const cell = 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": {
            emit2("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 && !Array.isArray(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 = computed(() => [
        ns.b(),
        { "is-week-mode": props.selectionMode === "week" }
      ]);
      const tableLabel = computed(() => t("el.datepicker.dateTablePrompt"));
      const weekLabel = computed(() => t("el.datepicker.week"));
      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) {
          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,
        weekLabel,
        getCellClasses,
        getRowKls,
        t
      };
    };
    const basicCellProps = buildProps({
      cell: {
        type: definePropType(Object)
      }
    });
    var ElDatePickerCell = /* @__PURE__ */ defineComponent({
      name: "ElDatePickerCell",
      props: basicCellProps,
      setup(props) {
        const ns = useNamespace("date-table-cell");
        const {
          slots
        } = inject(ROOT_PICKER_INJECTION_KEY);
        return () => {
          const {
            cell
          } = props;
          if (slots.default) {
            const list = slots.default(cell).filter((item) => {
              return item.patchFlag !== -2 && item.type.toString() !== "Symbol(Comment)" && item.type.toString() !== "Symbol(v-cmt)";
            });
            if (list.length) {
              return list;
            }
          }
          return createVNode("div", {
            "class": ns.b()
          }, [createVNode("span", {
            "class": ns.e("text")
          }, [cell == null ? void 0 : cell.text])]);
        };
      }
    });
    const _hoisted_1$L = ["aria-label"];
    const _hoisted_2$u = {
      key: 0,
      scope: "col"
    };
    const _hoisted_3$h = ["aria-label"];
    const _hoisted_4$b = ["aria-current", "aria-selected", "tabindex"];
    const _sfc_main$1q = /* @__PURE__ */ defineComponent({
      __name: "basic-date-table",
      props: basicDateTableProps,
      emits: basicDateTableEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const {
          WEEKS,
          rows,
          tbodyRef,
          currentCellRef,
          focus,
          isCurrent,
          isWeekActive,
          isSelectedCell,
          handlePickDate,
          handleMouseUp,
          handleMouseDown,
          handleMouseMove,
          handleFocus
        } = useBasicDateTable(props, emit2);
        const { tableLabel, tableKls, weekLabel, getCellClasses, getRowKls, t } = useBasicDateTableDOM(props, {
          isCurrent,
          isWeekActive
        });
        expose({
          focus
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("table", {
            "aria-label": unref(tableLabel),
            class: normalizeClass(unref(tableKls)),
            cellspacing: "0",
            cellpadding: "0",
            role: "grid",
            onClick: _cache[1] || (_cache[1] = (...args) => unref(handlePickDate) && unref(handlePickDate)(...args)),
            onMousemove: _cache[2] || (_cache[2] = (...args) => unref(handleMouseMove) && unref(handleMouseMove)(...args)),
            onMousedown: _cache[3] || (_cache[3] = withModifiers((...args) => unref(handleMouseDown) && unref(handleMouseDown)(...args), ["prevent"])),
            onMouseup: _cache[4] || (_cache[4] = (...args) => unref(handleMouseUp) && unref(handleMouseUp)(...args))
          }, [
            createBaseVNode("tbody", {
              ref_key: "tbodyRef",
              ref: tbodyRef
            }, [
              createBaseVNode("tr", null, [
                _ctx.showWeekNumber ? (openBlock(), createElementBlock("th", _hoisted_2$u, toDisplayString(unref(weekLabel)), 1)) : createCommentVNode("v-if", true),
                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(WEEKS), (week, key) => {
                  return openBlock(), createElementBlock("th", {
                    key,
                    "aria-label": unref(t)("el.datepicker.weeksFull." + week),
                    scope: "col"
                  }, toDisplayString(unref(t)("el.datepicker.weeks." + week)), 9, _hoisted_3$h);
                }), 128))
              ]),
              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, rowKey2) => {
                return openBlock(), createElementBlock("tr", {
                  key: rowKey2,
                  class: normalizeClass(unref(getRowKls)(row[1]))
                }, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(row, (cell, columnKey) => {
                    return openBlock(), createElementBlock("td", {
                      key: `${rowKey2}.${columnKey}`,
                      ref_for: true,
                      ref: (el) => unref(isSelectedCell)(cell) && (currentCellRef.value = el),
                      class: normalizeClass(unref(getCellClasses)(cell)),
                      "aria-current": cell.isCurrent ? "date" : void 0,
                      "aria-selected": cell.isCurrent,
                      tabindex: unref(isSelectedCell)(cell) ? 0 : -1,
                      onFocus: _cache[0] || (_cache[0] = (...args) => unref(handleFocus) && unref(handleFocus)(...args))
                    }, [
                      createVNode(unref(ElDatePickerCell), { cell }, null, 8, ["cell"])
                    ], 42, _hoisted_4$b);
                  }), 128))
                ], 2);
              }), 128))
            ], 512)
          ], 42, _hoisted_1$L);
        };
      }
    });
    var DateTable = /* @__PURE__ */ _export_sfc$1(_sfc_main$1q, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/date-picker/src/date-picker-com/basic-date-table.vue"]]);
    const basicMonthTableProps = buildProps({
      ...datePickerSharedProps,
      selectionMode: selectionModeWithDefault("month")
    });
    const _hoisted_1$K = ["aria-label"];
    const _hoisted_2$t = ["aria-selected", "aria-label", "tabindex", "onKeydown"];
    const _hoisted_3$g = { class: "cell" };
    const _sfc_main$1p = /* @__PURE__ */ defineComponent({
      __name: "basic-month-table",
      props: basicMonthTableProps,
      emits: ["changerange", "pick", "select"],
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const datesInMonth = (year, month, lang2) => {
          const firstDay = dayjs().locale(lang2).startOf("month").month(month).year(year);
          const numOfDays = firstDay.daysInMonth();
          return rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
        };
        const ns = useNamespace("month-table");
        const { t, lang } = useLocale();
        const tbodyRef = ref();
        const currentCellRef = ref();
        const months = ref(props.date.locale("en").localeData().monthsShort().map((_2) => _2.toLowerCase()));
        const tableRows = ref([
          [],
          [],
          []
        ]);
        const lastRow = ref();
        const lastColumn = ref();
        const rows = computed(() => {
          var _a2, _b;
          const rows2 = tableRows.value;
          const now2 = 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
              });
              cell.type = "normal";
              const index2 = i * 4 + j;
              const calTime = props.date.startOf("year").month(index2);
              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 ((_a2 = props.minDate) == null ? void 0 : _a2.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 = now2.isSame(calTime);
              if (isToday) {
                cell.type = "today";
              }
              cell.text = index2;
              cell.disabled = ((_b = props.disabledDate) == null ? void 0 : _b.call(props, calTime.toDate())) || false;
            }
          }
          return rows2;
        });
        const focus = () => {
          var _a2;
          (_a2 = currentCellRef.value) == null ? void 0 : _a2.focus();
        };
        const getCellStyle = (cell) => {
          const style = {};
          const year = props.date.year();
          const today = /* @__PURE__ */ new Date();
          const month = cell.text;
          style.disabled = props.disabledDate ? datesInMonth(year, month, lang.value).every(props.disabledDate) : false;
          style.current = castArray(props.parsedValue).findIndex((date2) => dayjs.isDayjs(date2) && date2.year() === year && date2.month() === month) >= 0;
          style.today = today.getFullYear() === year && today.getMonth() === month;
          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).findIndex((date2) => date2.year() === year && date2.month() === month) >= 0;
        };
        const handleMouseMove = (event) => {
          var _a2;
          if (!props.rangeState.selecting)
            return;
          let target = event.target;
          if (target.tagName === "A") {
            target = (_a2 = target.parentNode) == null ? void 0 : _a2.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;
            emit2("changerange", {
              selecting: true,
              endDate: props.date.startOf("year").month(row * 4 + column)
            });
          }
        };
        const handleMonthTableClick = (event) => {
          var _a2;
          const target = (_a2 = event.target) == null ? void 0 : _a2.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 === "range") {
            if (!props.rangeState.selecting) {
              emit2("pick", { minDate: newDate, maxDate: null });
              emit2("select", true);
            } else {
              if (props.minDate && newDate >= props.minDate) {
                emit2("pick", { minDate: props.minDate, maxDate: newDate });
              } else {
                emit2("pick", { minDate: newDate, maxDate: props.minDate });
              }
              emit2("select", false);
            }
          } else {
            emit2("pick", month);
          }
        };
        watch(() => props.date, async () => {
          var _a2, _b;
          if ((_a2 = tbodyRef.value) == null ? void 0 : _a2.contains(document.activeElement)) {
            await nextTick();
            (_b = currentCellRef.value) == null ? void 0 : _b.focus();
          }
        });
        expose({
          focus
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("table", {
            role: "grid",
            "aria-label": unref(t)("el.datepicker.monthTablePrompt"),
            class: normalizeClass(unref(ns).b()),
            onClick: handleMonthTableClick,
            onMousemove: handleMouseMove
          }, [
            createBaseVNode("tbody", {
              ref_key: "tbodyRef",
              ref: tbodyRef
            }, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, key) => {
                return openBlock(), createElementBlock("tr", { key }, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(row, (cell, key_) => {
                    return openBlock(), createElementBlock("td", {
                      key: key_,
                      ref_for: true,
                      ref: (el) => isSelectedCell(cell) && (currentCellRef.value = el),
                      class: normalizeClass(getCellStyle(cell)),
                      "aria-selected": `${isSelectedCell(cell)}`,
                      "aria-label": unref(t)(`el.datepicker.month${+cell.text + 1}`),
                      tabindex: isSelectedCell(cell) ? 0 : -1,
                      onKeydown: [
                        withKeys(withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["space"]),
                        withKeys(withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["enter"])
                      ]
                    }, [
                      createBaseVNode("div", null, [
                        createBaseVNode("span", _hoisted_3$g, toDisplayString(unref(t)("el.datepicker.months." + months.value[cell.text])), 1)
                      ])
                    ], 42, _hoisted_2$t);
                  }), 128))
                ]);
              }), 128))
            ], 512)
          ], 42, _hoisted_1$K);
        };
      }
    });
    var MonthTable = /* @__PURE__ */ _export_sfc$1(_sfc_main$1p, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/date-picker/src/date-picker-com/basic-month-table.vue"]]);
    const { date, disabledDate, parsedValue } = datePickerSharedProps;
    const basicYearTableProps = buildProps({
      date,
      disabledDate,
      parsedValue
    });
    const _hoisted_1$J = ["aria-label"];
    const _hoisted_2$s = ["aria-selected", "tabindex", "onKeydown"];
    const _hoisted_3$f = { class: "cell" };
    const _hoisted_4$a = { key: 1 };
    const _sfc_main$1o = /* @__PURE__ */ defineComponent({
      __name: "basic-year-table",
      props: basicYearTableProps,
      emits: ["pick"],
      setup(__props, { expose, emit: emit2 }) {
        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 = ref();
        const currentCellRef = ref();
        const startYear = computed(() => {
          return Math.floor(props.date.year() / 10) * 10;
        });
        const focus = () => {
          var _a2;
          (_a2 = currentCellRef.value) == null ? void 0 : _a2.focus();
        };
        const getCellKls = (year) => {
          const kls = {};
          const today = dayjs().locale(lang.value);
          kls.disabled = props.disabledDate ? datesInYear(year, lang.value).every(props.disabledDate) : false;
          kls.current = castArray(props.parsedValue).findIndex((d2) => d2.year() === year) >= 0;
          kls.today = today.year() === year;
          return kls;
        };
        const isSelectedCell = (year) => {
          return year === startYear.value && props.date.year() < startYear.value && props.date.year() > startYear.value + 9 || castArray(props.date).findIndex((date2) => date2.year() === year) >= 0;
        };
        const handleYearTableClick = (event) => {
          const clickTarget = event.target;
          const target = clickTarget.closest("td");
          if (target && target.textContent) {
            if (hasClass(target, "disabled"))
              return;
            const year = target.textContent || target.innerText;
            emit2("pick", Number(year));
          }
        };
        watch(() => props.date, async () => {
          var _a2, _b;
          if ((_a2 = tbodyRef.value) == null ? void 0 : _a2.contains(document.activeElement)) {
            await nextTick();
            (_b = currentCellRef.value) == null ? void 0 : _b.focus();
          }
        });
        expose({
          focus
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("table", {
            role: "grid",
            "aria-label": unref(t)("el.datepicker.yearTablePrompt"),
            class: normalizeClass(unref(ns).b()),
            onClick: handleYearTableClick
          }, [
            createBaseVNode("tbody", {
              ref_key: "tbodyRef",
              ref: tbodyRef
            }, [
              (openBlock(), createElementBlock(Fragment, null, renderList(3, (_2, i) => {
                return createBaseVNode("tr", { key: i }, [
                  (openBlock(), createElementBlock(Fragment, null, renderList(4, (__, j) => {
                    return openBlock(), createElementBlock(Fragment, {
                      key: i + "_" + j
                    }, [
                      i * 4 + j < 10 ? (openBlock(), createElementBlock("td", {
                        key: 0,
                        ref_for: true,
                        ref: (el) => isSelectedCell(unref(startYear) + i * 4 + j) && (currentCellRef.value = el),
                        class: normalizeClass(["available", getCellKls(unref(startYear) + i * 4 + j)]),
                        "aria-selected": `${isSelectedCell(unref(startYear) + i * 4 + j)}`,
                        tabindex: isSelectedCell(unref(startYear) + i * 4 + j) ? 0 : -1,
                        onKeydown: [
                          withKeys(withModifiers(handleYearTableClick, ["prevent", "stop"]), ["space"]),
                          withKeys(withModifiers(handleYearTableClick, ["prevent", "stop"]), ["enter"])
                        ]
                      }, [
                        createBaseVNode("span", _hoisted_3$f, toDisplayString(unref(startYear) + i * 4 + j), 1)
                      ], 42, _hoisted_2$s)) : (openBlock(), createElementBlock("td", _hoisted_4$a))
                    ], 64);
                  }), 64))
                ]);
              }), 64))
            ], 512)
          ], 10, _hoisted_1$J);
        };
      }
    });
    var YearTable = /* @__PURE__ */ _export_sfc$1(_sfc_main$1o, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/date-picker/src/date-picker-com/basic-year-table.vue"]]);
    const _hoisted_1$I = ["onClick"];
    const _hoisted_2$r = ["aria-label"];
    const _hoisted_3$e = ["aria-label"];
    const _hoisted_4$9 = ["aria-label"];
    const _hoisted_5$7 = ["aria-label"];
    const _sfc_main$1n = /* @__PURE__ */ defineComponent({
      __name: "panel-date-pick",
      props: panelDatePickProps,
      emits: ["pick", "set-picker-option", "panel-change"],
      setup(__props, { emit: contextEmit }) {
        const props = __props;
        const timeWithinRange = (_2, __, ___) => true;
        const ppNs = useNamespace("picker-panel");
        const dpNs = useNamespace("date-picker");
        const attrs = useAttrs$1();
        const slots = useSlots();
        const { t, lang } = useLocale();
        const pickerBase = inject("EP_PICKER_BASE");
        const popper = inject(TOOLTIP_INJECTION_KEY);
        const { shortcuts, disabledDate: disabledDate2, cellClassName, defaultTime } = pickerBase.props;
        const defaultValue = toRef(pickerBase.props, "defaultValue");
        const currentViewRef = ref();
        const innerDate = ref(dayjs().locale(lang.value));
        const isChangeToNow = ref(false);
        let isShortcut = false;
        const defaultTimeD = computed(() => {
          return dayjs(defaultTime).locale(lang.value);
        });
        const month = computed(() => {
          return innerDate.value.month();
        });
        const year = computed(() => {
          return innerDate.value.year();
        });
        const selectableRange = ref([]);
        const userInputDate = ref(null);
        const userInputTime = ref(null);
        const checkDateWithinRange = (date2) => {
          return selectableRange.value.length > 0 ? timeWithinRange(date2, 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 emit2 = (value, ...args) => {
          if (!value) {
            contextEmit("pick", value, ...args);
          } else if (isArray$3(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 = (value, keepOpen) => {
          if (selectionMode.value === "date") {
            value = value;
            let newDate = props.parsedValue ? props.parsedValue.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;
            emit2(newDate, showTime.value || keepOpen);
          } else if (selectionMode.value === "week") {
            emit2(value.date);
          } else if (selectionMode.value === "dates") {
            emit2(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 = ref("date");
        const yearLabel = 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$2(shortcut.value) ? shortcut.value() : shortcut.value;
          if (shortcutValue) {
            isShortcut = true;
            emit2(dayjs(shortcutValue).locale(lang.value));
            return;
          }
          if (shortcut.onClick) {
            shortcut.onClick({
              attrs,
              slots,
              emit: contextEmit
            });
          }
        };
        const selectionMode = computed(() => {
          const { type: type2 } = props;
          if (["week", "month", "year", "dates"].includes(type2))
            return type2;
          return "date";
        });
        const keyboardMode = computed(() => {
          return selectionMode.value === "date" ? currentView.value : selectionMode.value;
        });
        const hasShortcuts = computed(() => !!shortcuts.length);
        const handleMonthPick = async (month2) => {
          innerDate.value = innerDate.value.startOf("month").month(month2);
          if (selectionMode.value === "month") {
            emit2(innerDate.value, false);
          } else {
            currentView.value = "date";
            if (["month", "year", "date", "week"].includes(selectionMode.value)) {
              emit2(innerDate.value, true);
              await nextTick();
              handleFocusPicker();
            }
          }
          handlePanelChange("month");
        };
        const handleYearPick = async (year2) => {
          if (selectionMode.value === "year") {
            innerDate.value = innerDate.value.startOf("year").year(year2);
            emit2(innerDate.value, false);
          } else {
            innerDate.value = innerDate.value.year(year2);
            currentView.value = "month";
            if (["month", "year", "date", "week"].includes(selectionMode.value)) {
              emit2(innerDate.value, true);
              await nextTick();
              handleFocusPicker();
            }
          }
          handlePanelChange("year");
        };
        const showPicker = async (view) => {
          currentView.value = view;
          await nextTick();
          handleFocusPicker();
        };
        const showTime = computed(() => props.type === "datetime" || props.type === "datetimerange");
        const footerVisible = computed(() => {
          return showTime.value || selectionMode.value === "dates";
        });
        const disabledConfirm = computed(() => {
          if (!disabledDate2)
            return false;
          if (!props.parsedValue)
            return true;
          if (isArray$3(props.parsedValue)) {
            return disabledDate2(props.parsedValue[0].toDate());
          }
          return disabledDate2(props.parsedValue.toDate());
        });
        const onConfirm = () => {
          if (selectionMode.value === "dates") {
            emit2(props.parsedValue);
          } else {
            let result = props.parsedValue;
            if (!result) {
              const defaultTimeD2 = dayjs(defaultTime).locale(lang.value);
              const defaultValueD = getDefaultValue2();
              result = defaultTimeD2.year(defaultValueD.year()).month(defaultValueD.month()).date(defaultValueD.date());
            }
            innerDate.value = result;
            emit2(result);
          }
        };
        const disabledNow = computed(() => {
          if (!disabledDate2)
            return false;
          return disabledDate2(dayjs().locale(lang.value).toDate());
        });
        const changeToNow = () => {
          const now2 = dayjs().locale(lang.value);
          const nowDate = now2.toDate();
          isChangeToNow.value = true;
          if ((!disabledDate2 || !disabledDate2(nowDate)) && checkDateWithinRange(nowDate)) {
            innerDate.value = dayjs().locale(lang.value);
            emit2(innerDate.value);
          }
        };
        const timeFormat = computed(() => {
          return props.timeFormat || extractTimeFormat(props.format);
        });
        const dateFormat = computed(() => {
          return props.dateFormat || extractDateFormat(props.format);
        });
        const visibleTime = computed(() => {
          if (userInputTime.value)
            return userInputTime.value;
          if (!props.parsedValue && !defaultValue.value)
            return;
          return (props.parsedValue || innerDate.value).format(timeFormat.value);
        });
        const visibleDate = computed(() => {
          if (userInputDate.value)
            return userInputDate.value;
          if (!props.parsedValue && !defaultValue.value)
            return;
          return (props.parsedValue || innerDate.value).format(dateFormat.value);
        });
        const timePickerVisible = ref(false);
        const onTimePickerInputFocus = () => {
          timePickerVisible.value = true;
        };
        const handleTimePickClose = () => {
          timePickerVisible.value = false;
        };
        const getUnits = (date2) => {
          return {
            hour: date2.hour(),
            minute: date2.minute(),
            second: date2.second(),
            year: date2.year(),
            month: date2.month(),
            date: date2.date()
          };
        };
        const handleTimePick = (value, visible, first) => {
          const { hour, minute, second } = getUnits(value);
          const newDate = props.parsedValue ? props.parsedValue.hour(hour).minute(minute).second(second) : value;
          innerDate.value = newDate;
          emit2(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: date2 } = getUnits(innerDate.value);
            innerDate.value = newDate.year(year2).month(month2).date(date2);
            userInputTime.value = null;
            timePickerVisible.value = false;
            emit2(innerDate.value, true);
          }
        };
        const handleVisibleDateChange = (value) => {
          const newDate = dayjs(value, dateFormat.value).locale(lang.value);
          if (newDate.isValid()) {
            if (disabledDate2 && disabledDate2(newDate.toDate())) {
              return;
            }
            const { hour, minute, second } = getUnits(innerDate.value);
            innerDate.value = newDate.hour(hour).minute(minute).second(second);
            userInputDate.value = null;
            emit2(innerDate.value, true);
          }
        };
        const isValidValue2 = (date2) => {
          return dayjs.isDayjs(date2) && date2.isValid() && (disabledDate2 ? !disabledDate2(date2.toDate()) : true);
        };
        const formatToString = (value) => {
          if (selectionMode.value === "dates") {
            return value.map((_2) => _2.format(props.format));
          }
          return value.format(props.format);
        };
        const parseUserInput = (value) => {
          return dayjs(value, props.format).locale(lang.value);
        };
        const getDefaultValue2 = () => {
          const parseDate2 = 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 parseDate2;
        };
        const handleFocusPicker = async () => {
          var _a2;
          if (["week", "month", "year", "date"].includes(selectionMode.value)) {
            (_a2 = currentViewRef.value) == null ? void 0 : _a2.focus();
            if (selectionMode.value === "week") {
              handleKeyControl(EVENT_CODE.down);
            }
          }
        };
        const handleKeydownTable = (event) => {
          const { code } = 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();
            emit2(innerDate.value, false);
          }
        };
        const handleKeyControl = (code) => {
          var _a2;
          const { up: up2, down: down2, left: left2, right: right2, home: home2, end: end2, pageUp: pageUp2, pageDown: pageDown2 } = EVENT_CODE;
          const mapping = {
            year: {
              [up2]: -4,
              [down2]: 4,
              [left2]: -1,
              [right2]: 1,
              offset: (date2, step) => date2.setFullYear(date2.getFullYear() + step)
            },
            month: {
              [up2]: -4,
              [down2]: 4,
              [left2]: -1,
              [right2]: 1,
              offset: (date2, step) => date2.setMonth(date2.getMonth() + step)
            },
            week: {
              [up2]: -1,
              [down2]: 1,
              [left2]: -1,
              [right2]: 1,
              offset: (date2, step) => date2.setDate(date2.getDate() + step * 7)
            },
            date: {
              [up2]: -7,
              [down2]: 7,
              [left2]: -1,
              [right2]: 1,
              [home2]: (date2) => -date2.getDay(),
              [end2]: (date2) => -date2.getDay() + 6,
              [pageUp2]: (date2) => -new Date(date2.getFullYear(), date2.getMonth(), 0).getDate(),
              [pageDown2]: (date2) => new Date(date2.getFullYear(), date2.getMonth() + 1, 0).getDate(),
              offset: (date2, step) => date2.setDate(date2.getDate() + step)
            }
          };
          const newDate = innerDate.value.toDate();
          while (Math.abs(innerDate.value.diff(newDate, "year", true)) < 1) {
            const map2 = mapping[keyboardMode.value];
            if (!map2)
              return;
            map2.offset(newDate, isFunction$2(map2[code]) ? map2[code](newDate) : (_a2 = map2[code]) != null ? _a2 : 0);
            if (disabledDate2 && disabledDate2(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);
        };
        watch(() => selectionMode.value, (val) => {
          if (["month", "year"].includes(val)) {
            currentView.value = val;
            return;
          }
          currentView.value = "date";
        }, { immediate: true });
        watch(() => currentView.value, () => {
          popper == null ? void 0 : popper.updatePopper();
        });
        watch(() => defaultValue.value, (val) => {
          if (val) {
            innerDate.value = getDefaultValue2();
          }
        }, { immediate: true });
        watch(() => props.parsedValue, (val) => {
          if (val) {
            if (selectionMode.value === "dates")
              return;
            if (Array.isArray(val))
              return;
            innerDate.value = val;
          } else {
            innerDate.value = getDefaultValue2();
          }
        }, { immediate: true });
        contextEmit("set-picker-option", ["isValidValue", isValidValue2]);
        contextEmit("set-picker-option", ["formatToString", formatToString]);
        contextEmit("set-picker-option", ["parseUserInput", parseUserInput]);
        contextEmit("set-picker-option", ["handleFocusPicker", handleFocusPicker]);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([
              unref(ppNs).b(),
              unref(dpNs).b(),
              {
                "has-sidebar": _ctx.$slots.sidebar || unref(hasShortcuts),
                "has-time": unref(showTime)
              }
            ])
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ppNs).e("body-wrapper"))
            }, [
              renderSlot(_ctx.$slots, "sidebar", {
                class: normalizeClass(unref(ppNs).e("sidebar"))
              }),
              unref(hasShortcuts) ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ppNs).e("sidebar"))
              }, [
                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(shortcuts), (shortcut, key) => {
                  return openBlock(), createElementBlock("button", {
                    key,
                    type: "button",
                    class: normalizeClass(unref(ppNs).e("shortcut")),
                    onClick: ($event) => handleShortcutClick(shortcut)
                  }, toDisplayString(shortcut.text), 11, _hoisted_1$I);
                }), 128))
              ], 2)) : createCommentVNode("v-if", true),
              createBaseVNode("div", {
                class: normalizeClass(unref(ppNs).e("body"))
              }, [
                unref(showTime) ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  class: normalizeClass(unref(dpNs).e("time-header"))
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass(unref(dpNs).e("editor-wrap"))
                  }, [
                    createVNode(unref(ElInput), {
                      placeholder: unref(t)("el.datepicker.selectDate"),
                      "model-value": unref(visibleDate),
                      size: "small",
                      "validate-event": false,
                      onInput: _cache[0] || (_cache[0] = (val) => userInputDate.value = val),
                      onChange: handleVisibleDateChange
                    }, null, 8, ["placeholder", "model-value"])
                  ], 2),
                  withDirectives((openBlock(), createElementBlock("span", {
                    class: normalizeClass(unref(dpNs).e("editor-wrap"))
                  }, [
                    createVNode(unref(ElInput), {
                      placeholder: unref(t)("el.datepicker.selectTime"),
                      "model-value": unref(visibleTime),
                      size: "small",
                      "validate-event": false,
                      onFocus: onTimePickerInputFocus,
                      onInput: _cache[1] || (_cache[1] = (val) => userInputTime.value = val),
                      onChange: handleVisibleTimeChange
                    }, null, 8, ["placeholder", "model-value"]),
                    createVNode(unref(TimePickPanel), {
                      visible: timePickerVisible.value,
                      format: unref(timeFormat),
                      "parsed-value": innerDate.value,
                      onPick: handleTimePick
                    }, null, 8, ["visible", "format", "parsed-value"])
                  ], 2)), [
                    [unref(ClickOutside), handleTimePickClose]
                  ])
                ], 2)) : createCommentVNode("v-if", true),
                withDirectives(createBaseVNode("div", {
                  class: normalizeClass([
                    unref(dpNs).e("header"),
                    (currentView.value === "year" || currentView.value === "month") && unref(dpNs).e("header--bordered")
                  ])
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass(unref(dpNs).e("prev-btn"))
                  }, [
                    createBaseVNode("button", {
                      type: "button",
                      "aria-label": unref(t)(`el.datepicker.prevYear`),
                      class: normalizeClass(["d-arrow-left", unref(ppNs).e("icon-btn")]),
                      onClick: _cache[2] || (_cache[2] = ($event) => moveByYear(false))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_2$r),
                    withDirectives(createBaseVNode("button", {
                      type: "button",
                      "aria-label": unref(t)(`el.datepicker.prevMonth`),
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-left"]),
                      onClick: _cache[3] || (_cache[3] = ($event) => moveByMonth(false))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_3$e), [
                      [vShow, currentView.value === "date"]
                    ])
                  ], 2),
                  createBaseVNode("span", {
                    role: "button",
                    class: normalizeClass(unref(dpNs).e("header-label")),
                    "aria-live": "polite",
                    tabindex: "0",
                    onKeydown: _cache[4] || (_cache[4] = withKeys(($event) => showPicker("year"), ["enter"])),
                    onClick: _cache[5] || (_cache[5] = ($event) => showPicker("year"))
                  }, toDisplayString(unref(yearLabel)), 35),
                  withDirectives(createBaseVNode("span", {
                    role: "button",
                    "aria-live": "polite",
                    tabindex: "0",
                    class: normalizeClass([
                      unref(dpNs).e("header-label"),
                      { active: currentView.value === "month" }
                    ]),
                    onKeydown: _cache[6] || (_cache[6] = withKeys(($event) => showPicker("month"), ["enter"])),
                    onClick: _cache[7] || (_cache[7] = ($event) => showPicker("month"))
                  }, toDisplayString(unref(t)(`el.datepicker.month${unref(month) + 1}`)), 35), [
                    [vShow, currentView.value === "date"]
                  ]),
                  createBaseVNode("span", {
                    class: normalizeClass(unref(dpNs).e("next-btn"))
                  }, [
                    withDirectives(createBaseVNode("button", {
                      type: "button",
                      "aria-label": unref(t)(`el.datepicker.nextMonth`),
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-right"]),
                      onClick: _cache[8] || (_cache[8] = ($event) => moveByMonth(true))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_4$9), [
                      [vShow, currentView.value === "date"]
                    ]),
                    createBaseVNode("button", {
                      type: "button",
                      "aria-label": unref(t)(`el.datepicker.nextYear`),
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                      onClick: _cache[9] || (_cache[9] = ($event) => moveByYear(true))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_5$7)
                  ], 2)
                ], 2), [
                  [vShow, currentView.value !== "time"]
                ]),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ppNs).e("content")),
                  onKeydown: handleKeydownTable
                }, [
                  currentView.value === "date" ? (openBlock(), createBlock(DateTable, {
                    key: 0,
                    ref_key: "currentViewRef",
                    ref: currentViewRef,
                    "selection-mode": unref(selectionMode),
                    date: innerDate.value,
                    "parsed-value": _ctx.parsedValue,
                    "disabled-date": unref(disabledDate2),
                    "cell-class-name": unref(cellClassName),
                    onPick: handleDatePick
                  }, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date", "cell-class-name"])) : createCommentVNode("v-if", true),
                  currentView.value === "year" ? (openBlock(), createBlock(YearTable, {
                    key: 1,
                    ref_key: "currentViewRef",
                    ref: currentViewRef,
                    date: innerDate.value,
                    "disabled-date": unref(disabledDate2),
                    "parsed-value": _ctx.parsedValue,
                    onPick: handleYearPick
                  }, null, 8, ["date", "disabled-date", "parsed-value"])) : createCommentVNode("v-if", true),
                  currentView.value === "month" ? (openBlock(), createBlock(MonthTable, {
                    key: 2,
                    ref_key: "currentViewRef",
                    ref: currentViewRef,
                    date: innerDate.value,
                    "parsed-value": _ctx.parsedValue,
                    "disabled-date": unref(disabledDate2),
                    onPick: handleMonthPick
                  }, null, 8, ["date", "parsed-value", "disabled-date"])) : createCommentVNode("v-if", true)
                ], 34)
              ], 2)
            ], 2),
            withDirectives(createBaseVNode("div", {
              class: normalizeClass(unref(ppNs).e("footer"))
            }, [
              withDirectives(createVNode(unref(ElButton), {
                text: "",
                size: "small",
                class: normalizeClass(unref(ppNs).e("link-btn")),
                disabled: unref(disabledNow),
                onClick: changeToNow
              }, {
                default: withCtx(() => [
                  createTextVNode(toDisplayString(unref(t)("el.datepicker.now")), 1)
                ]),
                _: 1
              }, 8, ["class", "disabled"]), [
                [vShow, unref(selectionMode) !== "dates"]
              ]),
              createVNode(unref(ElButton), {
                plain: "",
                size: "small",
                class: normalizeClass(unref(ppNs).e("link-btn")),
                disabled: unref(disabledConfirm),
                onClick: onConfirm
              }, {
                default: withCtx(() => [
                  createTextVNode(toDisplayString(unref(t)("el.datepicker.confirm")), 1)
                ]),
                _: 1
              }, 8, ["class", "disabled"])
            ], 2), [
              [vShow, unref(footerVisible) && currentView.value === "date"]
            ])
          ], 2);
        };
      }
    });
    var DatePickPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1n, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/date-picker/src/date-picker-com/panel-date-pick.vue"]]);
    const panelDateRangeProps = buildProps({
      ...panelSharedProps,
      ...panelRangeSharedProps
    });
    const useShortcut = (lang) => {
      const { emit: emit2 } = getCurrentInstance();
      const attrs = useAttrs$1();
      const slots = useSlots();
      const handleShortcutClick = (shortcut) => {
        const shortcutValues = isFunction$2(shortcut.value) ? shortcut.value() : shortcut.value;
        if (shortcutValues) {
          emit2("pick", [
            dayjs(shortcutValues[0]).locale(lang.value),
            dayjs(shortcutValues[1]).locale(lang.value)
          ]);
          return;
        }
        if (shortcut.onClick) {
          shortcut.onClick({
            attrs,
            slots,
            emit: emit2
          });
        }
      };
      return handleShortcutClick;
    };
    const useRangePicker = (props, {
      defaultValue,
      leftDate,
      rightDate,
      unit: unit2,
      onParsedValueChanged
    }) => {
      const { emit: emit2 } = getCurrentInstance();
      const { pickerNs } = inject(ROOT_PICKER_INJECTION_KEY);
      const drpNs = useNamespace("date-range-picker");
      const { t, lang } = useLocale();
      const handleShortcutClick = useShortcut(lang);
      const minDate = ref();
      const maxDate = ref();
      const rangeState = ref({
        endDate: null,
        selecting: false
      });
      const handleChangeRange = (val) => {
        rangeState.value = val;
      };
      const handleRangeConfirm = (visible = false) => {
        const _minDate = unref(minDate);
        const _maxDate = unref(maxDate);
        if (isValidRange([_minDate, _maxDate])) {
          emit2("pick", [_minDate, _maxDate], visible);
        }
      };
      const onSelect = (selecting) => {
        rangeState.value.selecting = selecting;
        if (!selecting) {
          rangeState.value.endDate = null;
        }
      };
      const restoreDefault = () => {
        const [start, end2] = getDefaultValue(unref(defaultValue), {
          lang: unref(lang),
          unit: unit2,
          unlinkPanels: props.unlinkPanels
        });
        minDate.value = void 0;
        maxDate.value = void 0;
        leftDate.value = start;
        rightDate.value = end2;
      };
      watch(defaultValue, (val) => {
        if (val) {
          restoreDefault();
        }
      }, { immediate: true });
      watch(() => props.parsedValue, (parsedValue2) => {
        if (isArray$3(parsedValue2) && parsedValue2.length === 2) {
          const [start, end2] = parsedValue2;
          minDate.value = start;
          leftDate.value = start;
          maxDate.value = end2;
          onParsedValueChanged(unref(minDate), unref(maxDate));
        } else {
          restoreDefault();
        }
      }, { immediate: true });
      return {
        minDate,
        maxDate,
        rangeState,
        lang,
        ppNs: pickerNs,
        drpNs,
        handleChangeRange,
        handleRangeConfirm,
        handleShortcutClick,
        onSelect,
        t
      };
    };
    const _hoisted_1$H = ["onClick"];
    const _hoisted_2$q = ["aria-label"];
    const _hoisted_3$d = ["aria-label"];
    const _hoisted_4$8 = ["disabled", "aria-label"];
    const _hoisted_5$6 = ["disabled", "aria-label"];
    const _hoisted_6$3 = ["disabled", "aria-label"];
    const _hoisted_7$1 = ["disabled", "aria-label"];
    const _hoisted_8$1 = ["aria-label"];
    const _hoisted_9$1 = ["aria-label"];
    const unit$1 = "month";
    const _sfc_main$1m = /* @__PURE__ */ defineComponent({
      __name: "panel-date-range",
      props: panelDateRangeProps,
      emits: [
        "pick",
        "set-picker-option",
        "calendar-change",
        "panel-change"
      ],
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const pickerBase = inject("EP_PICKER_BASE");
        const { disabledDate: disabledDate2, cellClassName, format: format2, defaultTime, clearable } = pickerBase.props;
        const shortcuts = toRef(pickerBase.props, "shortcuts");
        const defaultValue = toRef(pickerBase.props, "defaultValue");
        const { lang } = useLocale();
        const leftDate = ref(dayjs().locale(lang.value));
        const rightDate = ref(dayjs().locale(lang.value).add(1, unit$1));
        const {
          minDate,
          maxDate,
          rangeState,
          ppNs,
          drpNs,
          handleChangeRange,
          handleRangeConfirm,
          handleShortcutClick,
          onSelect,
          t
        } = useRangePicker(props, {
          defaultValue,
          leftDate,
          rightDate,
          unit: unit$1,
          onParsedValueChanged
        });
        const dateUserInput = ref({
          min: null,
          max: null
        });
        const timeUserInput = ref({
          min: null,
          max: null
        });
        const leftLabel = computed(() => {
          return `${leftDate.value.year()} ${t("el.datepicker.year")} ${t(`el.datepicker.month${leftDate.value.month() + 1}`)}`;
        });
        const rightLabel = computed(() => {
          return `${rightDate.value.year()} ${t("el.datepicker.year")} ${t(`el.datepicker.month${rightDate.value.month() + 1}`)}`;
        });
        const leftYear = computed(() => {
          return leftDate.value.year();
        });
        const leftMonth = computed(() => {
          return leftDate.value.month();
        });
        const rightYear = computed(() => {
          return rightDate.value.year();
        });
        const rightMonth = computed(() => {
          return rightDate.value.month();
        });
        const hasShortcuts = computed(() => !!shortcuts.value.length);
        const minVisibleDate = computed(() => {
          if (dateUserInput.value.min !== null)
            return dateUserInput.value.min;
          if (minDate.value)
            return minDate.value.format(dateFormat.value);
          return "";
        });
        const maxVisibleDate = 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 = computed(() => {
          if (timeUserInput.value.min !== null)
            return timeUserInput.value.min;
          if (minDate.value)
            return minDate.value.format(timeFormat.value);
          return "";
        });
        const maxVisibleTime = 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 = computed(() => {
          return props.timeFormat || extractTimeFormat(format2);
        });
        const dateFormat = computed(() => {
          return props.dateFormat || extractDateFormat(format2);
        });
        const isValidValue2 = (date2) => {
          return isValidRange(date2) && (disabledDate2 ? !disabledDate2(date2[0].toDate()) && !disabledDate2(date2[1].toDate()) : true);
        };
        const leftPrevYear = () => {
          leftDate.value = leftDate.value.subtract(1, "year");
          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 = leftDate.value.add(1, "year");
            rightDate.value = leftDate.value.add(1, "month");
          } else {
            rightDate.value = rightDate.value.add(1, "year");
          }
          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 = leftDate.value.add(1, "year");
          handlePanelChange("year");
        };
        const leftNextMonth = () => {
          leftDate.value = leftDate.value.add(1, "month");
          handlePanelChange("month");
        };
        const rightPrevYear = () => {
          rightDate.value = rightDate.value.subtract(1, "year");
          handlePanelChange("year");
        };
        const rightPrevMonth = () => {
          rightDate.value = rightDate.value.subtract(1, "month");
          handlePanelChange("month");
        };
        const handlePanelChange = (mode) => {
          emit2("panel-change", [leftDate.value.toDate(), rightDate.value.toDate()], mode);
        };
        const enableMonthArrow = 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 = computed(() => {
          return props.unlinkPanels && rightYear.value * 12 + rightMonth.value - (leftYear.value * 12 + leftMonth.value + 1) >= 12;
        });
        const btnDisabled = computed(() => {
          return !(minDate.value && maxDate.value && !rangeState.value.selecting && isValidRange([minDate.value, maxDate.value]));
        });
        const showTime = computed(() => props.type === "datetime" || props.type === "datetimerange");
        const formatEmit = (emitDayjs, index2) => {
          if (!emitDayjs)
            return;
          if (defaultTime) {
            const defaultTimeD = dayjs(defaultTime[index2] || defaultTime).locale(lang.value);
            return defaultTimeD.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
          }
          return emitDayjs;
        };
        const handleRangePick = (val, close2 = 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;
          }
          emit2("calendar-change", [min_.toDate(), max_ && max_.toDate()]);
          maxDate.value = maxDate_;
          minDate.value = minDate_;
          if (!close2 || showTime.value)
            return;
          handleRangeConfirm();
        };
        const minTimePickerVisible = ref(false);
        const maxTimePickerVisible = ref(false);
        const handleMinTimeClose = () => {
          minTimePickerVisible.value = false;
        };
        const handleMaxTimeClose = () => {
          maxTimePickerVisible.value = false;
        };
        const handleDateInput = (value, type2) => {
          dateUserInput.value[type2] = value;
          const parsedValueD = dayjs(value, dateFormat.value).locale(lang.value);
          if (parsedValueD.isValid()) {
            if (disabledDate2 && disabledDate2(parsedValueD.toDate())) {
              return;
            }
            if (type2 === "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");
              }
            }
          }
        };
        const handleDateChange = (_2, type2) => {
          dateUserInput.value[type2] = null;
        };
        const handleTimeInput = (value, type2) => {
          timeUserInput.value[type2] = value;
          const parsedValueD = dayjs(value, timeFormat.value).locale(lang.value);
          if (parsedValueD.isValid()) {
            if (type2 === "min") {
              minTimePickerVisible.value = true;
              minDate.value = (minDate.value || leftDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
              if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
                maxDate.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;
              if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
                minDate.value = maxDate.value;
              }
            }
          }
        };
        const handleTimeChange = (value, type2) => {
          timeUserInput.value[type2] = null;
          if (type2 === "min") {
            leftDate.value = minDate.value;
            minTimePickerVisible.value = false;
          } else {
            rightDate.value = maxDate.value;
            maxTimePickerVisible.value = false;
          }
        };
        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;
          }
        };
        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;
          }
        };
        const handleClear = () => {
          leftDate.value = getDefaultValue(unref(defaultValue), {
            lang: unref(lang),
            unit: "month",
            unlinkPanels: props.unlinkPanels
          })[0];
          rightDate.value = leftDate.value.add(1, "month");
          emit2("pick", null);
        };
        const formatToString = (value) => {
          return isArray$3(value) ? value.map((_2) => _2.format(format2)) : value.format(format2);
        };
        const parseUserInput = (value) => {
          return isArray$3(value) ? value.map((_2) => dayjs(_2, format2).locale(lang.value)) : dayjs(value, format2).locale(lang.value);
        };
        function onParsedValueChanged(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$1) : maxDate2;
          } else {
            rightDate.value = leftDate.value.add(1, unit$1);
            if (maxDate2) {
              rightDate.value = rightDate.value.hour(maxDate2.hour()).minute(maxDate2.minute()).second(maxDate2.second());
            }
          }
        }
        emit2("set-picker-option", ["isValidValue", isValidValue2]);
        emit2("set-picker-option", ["parseUserInput", parseUserInput]);
        emit2("set-picker-option", ["formatToString", formatToString]);
        emit2("set-picker-option", ["handleClear", handleClear]);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([
              unref(ppNs).b(),
              unref(drpNs).b(),
              {
                "has-sidebar": _ctx.$slots.sidebar || unref(hasShortcuts),
                "has-time": unref(showTime)
              }
            ])
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ppNs).e("body-wrapper"))
            }, [
              renderSlot(_ctx.$slots, "sidebar", {
                class: normalizeClass(unref(ppNs).e("sidebar"))
              }),
              unref(hasShortcuts) ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ppNs).e("sidebar"))
              }, [
                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(shortcuts), (shortcut, key) => {
                  return openBlock(), createElementBlock("button", {
                    key,
                    type: "button",
                    class: normalizeClass(unref(ppNs).e("shortcut")),
                    onClick: ($event) => unref(handleShortcutClick)(shortcut)
                  }, toDisplayString(shortcut.text), 11, _hoisted_1$H);
                }), 128))
              ], 2)) : createCommentVNode("v-if", true),
              createBaseVNode("div", {
                class: normalizeClass(unref(ppNs).e("body"))
              }, [
                unref(showTime) ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  class: normalizeClass(unref(drpNs).e("time-header"))
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass(unref(drpNs).e("editors-wrap"))
                  }, [
                    createBaseVNode("span", {
                      class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
                    }, [
                      createVNode(unref(ElInput), {
                        size: "small",
                        disabled: unref(rangeState).selecting,
                        placeholder: unref(t)("el.datepicker.startDate"),
                        class: normalizeClass(unref(drpNs).e("editor")),
                        "model-value": unref(minVisibleDate),
                        "validate-event": false,
                        onInput: _cache[0] || (_cache[0] = (val) => handleDateInput(val, "min")),
                        onChange: _cache[1] || (_cache[1] = (val) => handleDateChange(val, "min"))
                      }, null, 8, ["disabled", "placeholder", "class", "model-value"])
                    ], 2),
                    withDirectives((openBlock(), createElementBlock("span", {
                      class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
                    }, [
                      createVNode(unref(ElInput), {
                        size: "small",
                        class: normalizeClass(unref(drpNs).e("editor")),
                        disabled: unref(rangeState).selecting,
                        placeholder: unref(t)("el.datepicker.startTime"),
                        "model-value": unref(minVisibleTime),
                        "validate-event": false,
                        onFocus: _cache[2] || (_cache[2] = ($event) => minTimePickerVisible.value = true),
                        onInput: _cache[3] || (_cache[3] = (val) => handleTimeInput(val, "min")),
                        onChange: _cache[4] || (_cache[4] = (val) => handleTimeChange(val, "min"))
                      }, null, 8, ["class", "disabled", "placeholder", "model-value"]),
                      createVNode(unref(TimePickPanel), {
                        visible: minTimePickerVisible.value,
                        format: unref(timeFormat),
                        "datetime-role": "start",
                        "parsed-value": leftDate.value,
                        onPick: handleMinTimePick
                      }, null, 8, ["visible", "format", "parsed-value"])
                    ], 2)), [
                      [unref(ClickOutside), handleMinTimeClose]
                    ])
                  ], 2),
                  createBaseVNode("span", null, [
                    createVNode(unref(ElIcon), null, {
                      default: withCtx(() => [
                        createVNode(unref(arrow_right_default))
                      ]),
                      _: 1
                    })
                  ]),
                  createBaseVNode("span", {
                    class: normalizeClass([unref(drpNs).e("editors-wrap"), "is-right"])
                  }, [
                    createBaseVNode("span", {
                      class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
                    }, [
                      createVNode(unref(ElInput), {
                        size: "small",
                        class: normalizeClass(unref(drpNs).e("editor")),
                        disabled: unref(rangeState).selecting,
                        placeholder: unref(t)("el.datepicker.endDate"),
                        "model-value": unref(maxVisibleDate),
                        readonly: !unref(minDate),
                        "validate-event": false,
                        onInput: _cache[5] || (_cache[5] = (val) => handleDateInput(val, "max")),
                        onChange: _cache[6] || (_cache[6] = (val) => handleDateChange(val, "max"))
                      }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly"])
                    ], 2),
                    withDirectives((openBlock(), createElementBlock("span", {
                      class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
                    }, [
                      createVNode(unref(ElInput), {
                        size: "small",
                        class: normalizeClass(unref(drpNs).e("editor")),
                        disabled: unref(rangeState).selecting,
                        placeholder: unref(t)("el.datepicker.endTime"),
                        "model-value": unref(maxVisibleTime),
                        readonly: !unref(minDate),
                        "validate-event": false,
                        onFocus: _cache[7] || (_cache[7] = ($event) => unref(minDate) && (maxTimePickerVisible.value = true)),
                        onInput: _cache[8] || (_cache[8] = (val) => handleTimeInput(val, "max")),
                        onChange: _cache[9] || (_cache[9] = (val) => handleTimeChange(val, "max"))
                      }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly"]),
                      createVNode(unref(TimePickPanel), {
                        "datetime-role": "end",
                        visible: maxTimePickerVisible.value,
                        format: unref(timeFormat),
                        "parsed-value": rightDate.value,
                        onPick: handleMaxTimePick
                      }, null, 8, ["visible", "format", "parsed-value"])
                    ], 2)), [
                      [unref(ClickOutside), handleMaxTimeClose]
                    ])
                  ], 2)
                ], 2)) : createCommentVNode("v-if", true),
                createBaseVNode("div", {
                  class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-left"])
                }, [
                  createBaseVNode("div", {
                    class: normalizeClass(unref(drpNs).e("header"))
                  }, [
                    createBaseVNode("button", {
                      type: "button",
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-left"]),
                      "aria-label": unref(t)(`el.datepicker.prevYear`),
                      onClick: leftPrevYear
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_2$q),
                    createBaseVNode("button", {
                      type: "button",
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-left"]),
                      "aria-label": unref(t)(`el.datepicker.prevMonth`),
                      onClick: leftPrevMonth
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_3$d),
                    _ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !unref(enableYearArrow),
                      class: normalizeClass([[unref(ppNs).e("icon-btn"), { "is-disabled": !unref(enableYearArrow) }], "d-arrow-right"]),
                      "aria-label": unref(t)(`el.datepicker.nextYear`),
                      onClick: leftNextYear
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_4$8)) : createCommentVNode("v-if", true),
                    _ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
                      key: 1,
                      type: "button",
                      disabled: !unref(enableMonthArrow),
                      class: normalizeClass([[
                        unref(ppNs).e("icon-btn"),
                        { "is-disabled": !unref(enableMonthArrow) }
                      ], "arrow-right"]),
                      "aria-label": unref(t)(`el.datepicker.nextMonth`),
                      onClick: leftNextMonth
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_5$6)) : createCommentVNode("v-if", true),
                    createBaseVNode("div", null, toDisplayString(unref(leftLabel)), 1)
                  ], 2),
                  createVNode(DateTable, {
                    "selection-mode": "range",
                    date: leftDate.value,
                    "min-date": unref(minDate),
                    "max-date": unref(maxDate),
                    "range-state": unref(rangeState),
                    "disabled-date": unref(disabledDate2),
                    "cell-class-name": unref(cellClassName),
                    onChangerange: unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "onChangerange", "onSelect"])
                ], 2),
                createBaseVNode("div", {
                  class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-right"])
                }, [
                  createBaseVNode("div", {
                    class: normalizeClass(unref(drpNs).e("header"))
                  }, [
                    _ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !unref(enableYearArrow),
                      class: normalizeClass([[unref(ppNs).e("icon-btn"), { "is-disabled": !unref(enableYearArrow) }], "d-arrow-left"]),
                      "aria-label": unref(t)(`el.datepicker.prevYear`),
                      onClick: rightPrevYear
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_6$3)) : createCommentVNode("v-if", true),
                    _ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
                      key: 1,
                      type: "button",
                      disabled: !unref(enableMonthArrow),
                      class: normalizeClass([[
                        unref(ppNs).e("icon-btn"),
                        { "is-disabled": !unref(enableMonthArrow) }
                      ], "arrow-left"]),
                      "aria-label": unref(t)(`el.datepicker.prevMonth`),
                      onClick: rightPrevMonth
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_7$1)) : createCommentVNode("v-if", true),
                    createBaseVNode("button", {
                      type: "button",
                      "aria-label": unref(t)(`el.datepicker.nextYear`),
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                      onClick: rightNextYear
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_8$1),
                    createBaseVNode("button", {
                      type: "button",
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-right"]),
                      "aria-label": unref(t)(`el.datepicker.nextMonth`),
                      onClick: rightNextMonth
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_9$1),
                    createBaseVNode("div", null, toDisplayString(unref(rightLabel)), 1)
                  ], 2),
                  createVNode(DateTable, {
                    "selection-mode": "range",
                    date: rightDate.value,
                    "min-date": unref(minDate),
                    "max-date": unref(maxDate),
                    "range-state": unref(rangeState),
                    "disabled-date": unref(disabledDate2),
                    "cell-class-name": unref(cellClassName),
                    onChangerange: unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "onChangerange", "onSelect"])
                ], 2)
              ], 2)
            ], 2),
            unref(showTime) ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ppNs).e("footer"))
            }, [
              unref(clearable) ? (openBlock(), createBlock(unref(ElButton), {
                key: 0,
                text: "",
                size: "small",
                class: normalizeClass(unref(ppNs).e("link-btn")),
                onClick: handleClear
              }, {
                default: withCtx(() => [
                  createTextVNode(toDisplayString(unref(t)("el.datepicker.clear")), 1)
                ]),
                _: 1
              }, 8, ["class"])) : createCommentVNode("v-if", true),
              createVNode(unref(ElButton), {
                plain: "",
                size: "small",
                class: normalizeClass(unref(ppNs).e("link-btn")),
                disabled: unref(btnDisabled),
                onClick: _cache[10] || (_cache[10] = ($event) => unref(handleRangeConfirm)(false))
              }, {
                default: withCtx(() => [
                  createTextVNode(toDisplayString(unref(t)("el.datepicker.confirm")), 1)
                ]),
                _: 1
              }, 8, ["class", "disabled"])
            ], 2)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var DateRangePickPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1m, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/date-picker/src/date-picker-com/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 = computed(() => {
        return `${leftDate.value.year()} ${t("el.datepicker.year")}`;
      });
      const rightLabel = computed(() => {
        return `${rightDate.value.year()} ${t("el.datepicker.year")}`;
      });
      const leftYear = computed(() => {
        return leftDate.value.year();
      });
      const rightYear = 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 _hoisted_1$G = ["onClick"];
    const _hoisted_2$p = ["disabled"];
    const _hoisted_3$c = ["disabled"];
    const unit = "year";
    const __default__$S = /* @__PURE__ */ defineComponent({
      name: "DatePickerMonthRange"
    });
    const _sfc_main$1l = /* @__PURE__ */ defineComponent({
      ...__default__$S,
      props: panelMonthRangeProps,
      emits: panelMonthRangeEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const { lang } = useLocale();
        const pickerBase = inject("EP_PICKER_BASE");
        const { shortcuts, disabledDate: disabledDate2, format: format2 } = pickerBase.props;
        const defaultValue = toRef(pickerBase.props, "defaultValue");
        const leftDate = ref(dayjs().locale(lang.value));
        const rightDate = ref(dayjs().locale(lang.value).add(1, unit));
        const {
          minDate,
          maxDate,
          rangeState,
          ppNs,
          drpNs,
          handleChangeRange,
          handleRangeConfirm,
          handleShortcutClick,
          onSelect
        } = useRangePicker(props, {
          defaultValue,
          leftDate,
          rightDate,
          unit,
          onParsedValueChanged
        });
        const hasShortcuts = computed(() => !!shortcuts.length);
        const {
          leftPrevYear,
          rightNextYear,
          leftNextYear,
          rightPrevYear,
          leftLabel,
          rightLabel,
          leftYear,
          rightYear
        } = useMonthRangeHeader({
          unlinkPanels: toRef(props, "unlinkPanels"),
          leftDate,
          rightDate
        });
        const enableYearArrow = computed(() => {
          return props.unlinkPanels && rightYear.value > leftYear.value + 1;
        });
        const handleRangePick = (val, close2 = true) => {
          const minDate_ = val.minDate;
          const maxDate_ = val.maxDate;
          if (maxDate.value === maxDate_ && minDate.value === minDate_) {
            return;
          }
          emit2("calendar-change", [minDate_.toDate(), maxDate_ && maxDate_.toDate()]);
          maxDate.value = maxDate_;
          minDate.value = minDate_;
          if (!close2)
            return;
          handleRangeConfirm();
        };
        const formatToString = (days) => {
          return days.map((day) => day.format(format2));
        };
        function onParsedValueChanged(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) : maxDate2;
          } else {
            rightDate.value = leftDate.value.add(1, unit);
          }
        }
        emit2("set-picker-option", ["formatToString", formatToString]);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([
              unref(ppNs).b(),
              unref(drpNs).b(),
              {
                "has-sidebar": Boolean(_ctx.$slots.sidebar) || unref(hasShortcuts)
              }
            ])
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ppNs).e("body-wrapper"))
            }, [
              renderSlot(_ctx.$slots, "sidebar", {
                class: normalizeClass(unref(ppNs).e("sidebar"))
              }),
              unref(hasShortcuts) ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ppNs).e("sidebar"))
              }, [
                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(shortcuts), (shortcut, key) => {
                  return openBlock(), createElementBlock("button", {
                    key,
                    type: "button",
                    class: normalizeClass(unref(ppNs).e("shortcut")),
                    onClick: ($event) => unref(handleShortcutClick)(shortcut)
                  }, toDisplayString(shortcut.text), 11, _hoisted_1$G);
                }), 128))
              ], 2)) : createCommentVNode("v-if", true),
              createBaseVNode("div", {
                class: normalizeClass(unref(ppNs).e("body"))
              }, [
                createBaseVNode("div", {
                  class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-left"])
                }, [
                  createBaseVNode("div", {
                    class: normalizeClass(unref(drpNs).e("header"))
                  }, [
                    createBaseVNode("button", {
                      type: "button",
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-left"]),
                      onClick: _cache[0] || (_cache[0] = (...args) => unref(leftPrevYear) && unref(leftPrevYear)(...args))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    _ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !unref(enableYearArrow),
                      class: normalizeClass([[
                        unref(ppNs).e("icon-btn"),
                        { [unref(ppNs).is("disabled")]: !unref(enableYearArrow) }
                      ], "d-arrow-right"]),
                      onClick: _cache[1] || (_cache[1] = (...args) => unref(leftNextYear) && unref(leftNextYear)(...args))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_2$p)) : createCommentVNode("v-if", true),
                    createBaseVNode("div", null, toDisplayString(unref(leftLabel)), 1)
                  ], 2),
                  createVNode(MonthTable, {
                    "selection-mode": "range",
                    date: leftDate.value,
                    "min-date": unref(minDate),
                    "max-date": unref(maxDate),
                    "range-state": unref(rangeState),
                    "disabled-date": unref(disabledDate2),
                    onChangerange: unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "onChangerange", "onSelect"])
                ], 2),
                createBaseVNode("div", {
                  class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-right"])
                }, [
                  createBaseVNode("div", {
                    class: normalizeClass(unref(drpNs).e("header"))
                  }, [
                    _ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !unref(enableYearArrow),
                      class: normalizeClass([[unref(ppNs).e("icon-btn"), { "is-disabled": !unref(enableYearArrow) }], "d-arrow-left"]),
                      onClick: _cache[2] || (_cache[2] = (...args) => unref(rightPrevYear) && unref(rightPrevYear)(...args))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_3$c)) : createCommentVNode("v-if", true),
                    createBaseVNode("button", {
                      type: "button",
                      class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                      onClick: _cache[3] || (_cache[3] = (...args) => unref(rightNextYear) && unref(rightNextYear)(...args))
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    createBaseVNode("div", null, toDisplayString(unref(rightLabel)), 1)
                  ], 2),
                  createVNode(MonthTable, {
                    "selection-mode": "range",
                    date: rightDate.value,
                    "min-date": unref(minDate),
                    "max-date": unref(maxDate),
                    "range-state": unref(rangeState),
                    "disabled-date": unref(disabledDate2),
                    onChangerange: unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "onChangerange", "onSelect"])
                ], 2)
              ], 2)
            ], 2)
          ], 2);
        };
      }
    });
    var MonthRangePickPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$1l, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/date-picker/src/date-picker-com/panel-month-range.vue"]]);
    const getPanel = function(type2) {
      switch (type2) {
        case "daterange":
        case "datetimerange": {
          return DateRangePickPanel;
        }
        case "monthrange": {
          return MonthRangePickPanel;
        }
        default: {
          return DatePickPanel;
        }
      }
    };
    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 DatePicker = /* @__PURE__ */ defineComponent({
      name: "ElDatePicker",
      install: null,
      props: datePickerProps,
      emits: ["update:modelValue"],
      setup(props, {
        expose,
        emit: emit2,
        slots
      }) {
        const ns = useNamespace("picker-panel");
        provide("ElPopperOptions", reactive(toRef(props, "popperOptions")));
        provide(ROOT_PICKER_INJECTION_KEY, {
          slots,
          pickerNs: ns
        });
        const commonPicker = ref();
        const refProps = {
          focus: (focusStartInput = true) => {
            var _a2;
            (_a2 = commonPicker.value) == null ? void 0 : _a2.focus(focusStartInput);
          },
          handleOpen: () => {
            var _a2;
            (_a2 = commonPicker.value) == null ? void 0 : _a2.handleOpen();
          },
          handleClose: () => {
            var _a2;
            (_a2 = commonPicker.value) == null ? void 0 : _a2.handleClose();
          }
        };
        expose(refProps);
        const onModelValueUpdated = (val) => {
          emit2("update:modelValue", val);
        };
        return () => {
          var _a2;
          const format2 = (_a2 = props.format) != null ? _a2 : DEFAULT_FORMATS_DATEPICKER[props.type] || DEFAULT_FORMATS_DATE;
          const Component = getPanel(props.type);
          return createVNode(CommonPicker, mergeProps(props, {
            "format": format2,
            "type": props.type,
            "ref": commonPicker,
            "onUpdate:modelValue": onModelValueUpdated
          }), {
            default: (scopedProps) => createVNode(Component, scopedProps, null),
            "range-separator": slots["range-separator"]
          });
        };
      }
    });
    const _DatePicker = DatePicker;
    _DatePicker.install = (app) => {
      app.component(_DatePicker.name, _DatePicker);
    };
    const ElDatePicker = _DatePicker;
    const descriptionsKey = Symbol("elDescriptions");
    var ElDescriptionsCell = /* @__PURE__ */ defineComponent({
      name: "ElDescriptionsCell",
      props: {
        cell: {
          type: Object
        },
        tag: {
          type: String,
          default: "td"
        },
        type: {
          type: String
        }
      },
      setup() {
        const descriptions = inject(descriptionsKey, {});
        return {
          descriptions
        };
      },
      render() {
        var _a2, _b, _c, _d, _e, _f, _g;
        const item = getNormalizedProps(this.cell);
        const directives = (((_a2 = this.cell) == null ? void 0 : _a2.dirs) || []).map((dire) => {
          const { dir, arg, modifiers, value } = dire;
          return [dir, value, arg, modifiers];
        });
        const { border, direction: direction2 } = this.descriptions;
        const isVertical = direction2 === "vertical";
        const label = ((_d = (_c = (_b = this.cell) == null ? void 0 : _b.children) == null ? void 0 : _c.label) == null ? void 0 : _d.call(_c)) || item.label;
        const content = (_g = (_f = (_e = this.cell) == null ? void 0 : _e.children) == null ? void 0 : _f.default) == null ? void 0 : _g.call(_f);
        const span = item.span;
        const align = item.align ? `is-${item.align}` : "";
        const labelAlign = item.labelAlign ? `is-${item.labelAlign}` : align;
        const className = item.className;
        const labelClassName = item.labelClassName;
        const style = {
          width: addUnit(item.width),
          minWidth: addUnit(item.minWidth)
        };
        const ns = useNamespace("descriptions");
        switch (this.type) {
          case "label":
            return withDirectives(h$1(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
            }, label), directives);
          case "content":
            return withDirectives(h$1(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
            }, content), directives);
          default:
            return withDirectives(h$1("td", {
              style,
              class: [ns.e("cell"), align],
              colSpan: span
            }, [
              !isNil(label) ? h$1("span", {
                class: [ns.e("label"), labelClassName]
              }, label) : void 0,
              h$1("span", {
                class: [ns.e("content"), className]
              }, content)
            ]), directives);
        }
      }
    });
    const descriptionsRowProps = buildProps({
      row: {
        type: definePropType(Array),
        default: () => []
      }
    });
    const _hoisted_1$F = { key: 1 };
    const __default__$R = /* @__PURE__ */ defineComponent({
      name: "ElDescriptionsRow"
    });
    const _sfc_main$1k = /* @__PURE__ */ defineComponent({
      ...__default__$R,
      props: descriptionsRowProps,
      setup(__props) {
        const descriptions = inject(descriptionsKey, {});
        return (_ctx, _cache) => {
          return unref(descriptions).direction === "vertical" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
            createBaseVNode("tr", null, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.row, (cell, _index) => {
                return openBlock(), createBlock(unref(ElDescriptionsCell), {
                  key: `tr1-${_index}`,
                  cell,
                  tag: "th",
                  type: "label"
                }, null, 8, ["cell"]);
              }), 128))
            ]),
            createBaseVNode("tr", null, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.row, (cell, _index) => {
                return openBlock(), createBlock(unref(ElDescriptionsCell), {
                  key: `tr2-${_index}`,
                  cell,
                  tag: "td",
                  type: "content"
                }, null, 8, ["cell"]);
              }), 128))
            ])
          ], 64)) : (openBlock(), createElementBlock("tr", _hoisted_1$F, [
            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.row, (cell, _index) => {
              return openBlock(), createElementBlock(Fragment, {
                key: `tr3-${_index}`
              }, [
                unref(descriptions).border ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                  createVNode(unref(ElDescriptionsCell), {
                    cell,
                    tag: "td",
                    type: "label"
                  }, null, 8, ["cell"]),
                  createVNode(unref(ElDescriptionsCell), {
                    cell,
                    tag: "td",
                    type: "content"
                  }, null, 8, ["cell"])
                ], 64)) : (openBlock(), createBlock(unref(ElDescriptionsCell), {
                  key: 1,
                  cell,
                  tag: "td",
                  type: "both"
                }, null, 8, ["cell"]))
              ], 64);
            }), 128))
          ]));
        };
      }
    });
    var ElDescriptionsRow = /* @__PURE__ */ _export_sfc$1(_sfc_main$1k, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/descriptions/src/descriptions-row.vue"]]);
    const descriptionProps = buildProps({
      border: {
        type: Boolean,
        default: false
      },
      column: {
        type: Number,
        default: 3
      },
      direction: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "horizontal"
      },
      size: useSizeProp,
      title: {
        type: String,
        default: ""
      },
      extra: {
        type: String,
        default: ""
      }
    });
    const __default__$Q = /* @__PURE__ */ defineComponent({
      name: "ElDescriptions"
    });
    const _sfc_main$1j = /* @__PURE__ */ defineComponent({
      ...__default__$Q,
      props: descriptionProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("descriptions");
        const descriptionsSize = useFormSize();
        const slots = useSlots();
        provide(descriptionsKey, props);
        const descriptionKls = 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 _a2;
            return ((_a2 = node == null ? void 0 : node.type) == null ? void 0 : _a2.name) === "ElDescriptionsItem";
          });
          const rows = [];
          let temp = [];
          let count = props.column;
          let totalSpan = 0;
          children.forEach((node, index2) => {
            var _a2;
            const span = ((_a2 = node.props) == null ? void 0 : _a2.span) || 1;
            if (index2 < children.length - 1) {
              totalSpan += span > count ? count : span;
            }
            if (index2 === 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 openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(descriptionKls))
          }, [
            _ctx.title || _ctx.extra || _ctx.$slots.title || _ctx.$slots.extra ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("header"))
            }, [
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).e("title"))
              }, [
                renderSlot(_ctx.$slots, "title", {}, () => [
                  createTextVNode(toDisplayString(_ctx.title), 1)
                ])
              ], 2),
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).e("extra"))
              }, [
                renderSlot(_ctx.$slots, "extra", {}, () => [
                  createTextVNode(toDisplayString(_ctx.extra), 1)
                ])
              ], 2)
            ], 2)) : createCommentVNode("v-if", true),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("body"))
            }, [
              createBaseVNode("table", {
                class: normalizeClass([unref(ns).e("table"), unref(ns).is("bordered", _ctx.border)])
              }, [
                createBaseVNode("tbody", null, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(getRows(), (row, _index) => {
                    return openBlock(), createBlock(ElDescriptionsRow, {
                      key: _index,
                      row
                    }, null, 8, ["row"]);
                  }), 128))
                ])
              ], 2)
            ], 2)
          ], 2);
        };
      }
    });
    var Descriptions = /* @__PURE__ */ _export_sfc$1(_sfc_main$1j, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/descriptions/src/description.vue"]]);
    const descriptionItemProps = buildProps({
      label: {
        type: String,
        default: ""
      },
      span: {
        type: Number,
        default: 1
      },
      width: {
        type: [String, Number],
        default: ""
      },
      minWidth: {
        type: [String, Number],
        default: ""
      },
      align: {
        type: String,
        default: "left"
      },
      labelAlign: {
        type: String,
        default: ""
      },
      className: {
        type: String,
        default: ""
      },
      labelClassName: {
        type: String,
        default: ""
      }
    });
    const DescriptionItem = /* @__PURE__ */ defineComponent({
      name: "ElDescriptionsItem",
      props: descriptionItemProps
    });
    const ElDescriptions = withInstall(Descriptions, {
      DescriptionsItem: DescriptionItem
    });
    const ElDescriptionsItem = withNoopInstall(DescriptionItem);
    const overlayProps = buildProps({
      mask: {
        type: Boolean,
        default: true
      },
      customMaskEvent: {
        type: Boolean,
        default: false
      },
      overlayClass: {
        type: definePropType([
          String,
          Array,
          Object
        ])
      },
      zIndex: {
        type: definePropType([String, Number])
      }
    });
    const overlayEmits = {
      click: (evt) => evt instanceof MouseEvent
    };
    const BLOCK = "overlay";
    var Overlay$1 = /* @__PURE__ */ defineComponent({
      name: "ElOverlay",
      props: overlayProps,
      emits: overlayEmits,
      setup(props, { slots, emit: emit2 }) {
        const ns = useNamespace(BLOCK);
        const onMaskClick = (e) => {
          emit2("click", e);
        };
        const { onClick, onMousedown, onMouseup } = useSameTarget(props.customMaskEvent ? void 0 : onMaskClick);
        return () => {
          return props.mask ? createVNode("div", {
            class: [ns.b(), props.overlayClass],
            style: {
              zIndex: props.zIndex
            },
            onClick,
            onMousedown,
            onMouseup
          }, [renderSlot(slots, "default")], PatchFlags.STYLE | PatchFlags.CLASS | PatchFlags.PROPS, ["onClick", "onMouseup", "onMousedown"]) : h$1("div", {
            class: props.overlayClass,
            style: {
              zIndex: props.zIndex,
              position: "fixed",
              top: "0px",
              right: "0px",
              bottom: "0px",
              left: "0px"
            }
          }, [renderSlot(slots, "default")]);
        };
      }
    });
    const ElOverlay = Overlay$1;
    const dialogInjectionKey = Symbol("dialogInjectionKey");
    const dialogContentProps = buildProps({
      center: Boolean,
      alignCenter: Boolean,
      closeIcon: {
        type: iconPropType
      },
      customClass: {
        type: String,
        default: ""
      },
      draggable: Boolean,
      fullscreen: Boolean,
      showClose: {
        type: Boolean,
        default: true
      },
      title: {
        type: String,
        default: ""
      },
      ariaLevel: {
        type: String,
        default: "2"
      }
    });
    const dialogContentEmits = {
      close: () => true
    };
    const _hoisted_1$E = ["aria-level"];
    const _hoisted_2$o = ["aria-label"];
    const _hoisted_3$b = ["id"];
    const __default__$P = /* @__PURE__ */ defineComponent({ name: "ElDialogContent" });
    const _sfc_main$1i = /* @__PURE__ */ defineComponent({
      ...__default__$P,
      props: dialogContentProps,
      emits: dialogContentEmits,
      setup(__props) {
        const props = __props;
        const { t } = useLocale();
        const { Close } = CloseComponents;
        const { dialogRef, headerRef, bodyId, ns, style } = inject(dialogInjectionKey);
        const { focusTrapRef } = inject(FOCUS_TRAP_INJECTION_KEY);
        const dialogKls = computed(() => [
          ns.b(),
          ns.is("fullscreen", props.fullscreen),
          ns.is("draggable", props.draggable),
          ns.is("align-center", props.alignCenter),
          { [ns.m("center")]: props.center },
          props.customClass
        ]);
        const composedDialogRef = composeRefs(focusTrapRef, dialogRef);
        const draggable2 = computed(() => props.draggable);
        useDraggable(dialogRef, headerRef, draggable2);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref: unref(composedDialogRef),
            class: normalizeClass(unref(dialogKls)),
            style: normalizeStyle(unref(style)),
            tabindex: "-1"
          }, [
            createBaseVNode("header", {
              ref_key: "headerRef",
              ref: headerRef,
              class: normalizeClass(unref(ns).e("header"))
            }, [
              renderSlot(_ctx.$slots, "header", {}, () => [
                createBaseVNode("span", {
                  role: "heading",
                  "aria-level": _ctx.ariaLevel,
                  class: normalizeClass(unref(ns).e("title"))
                }, toDisplayString(_ctx.title), 11, _hoisted_1$E)
              ]),
              _ctx.showClose ? (openBlock(), createElementBlock("button", {
                key: 0,
                "aria-label": unref(t)("el.dialog.close"),
                class: normalizeClass(unref(ns).e("headerbtn")),
                type: "button",
                onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("close"))
              }, [
                createVNode(unref(ElIcon), {
                  class: normalizeClass(unref(ns).e("close"))
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.closeIcon || unref(Close))))
                  ]),
                  _: 1
                }, 8, ["class"])
              ], 10, _hoisted_2$o)) : createCommentVNode("v-if", true)
            ], 2),
            createBaseVNode("div", {
              id: unref(bodyId),
              class: normalizeClass(unref(ns).e("body"))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 10, _hoisted_3$b),
            _ctx.$slots.footer ? (openBlock(), createElementBlock("footer", {
              key: 0,
              class: normalizeClass(unref(ns).e("footer"))
            }, [
              renderSlot(_ctx.$slots, "footer")
            ], 2)) : createCommentVNode("v-if", true)
          ], 6);
        };
      }
    });
    var ElDialogContent = /* @__PURE__ */ _export_sfc$1(_sfc_main$1i, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/dialog/src/dialog-content.vue"]]);
    const dialogProps = buildProps({
      ...dialogContentProps,
      appendToBody: Boolean,
      appendTo: {
        type: definePropType(String),
        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
      },
      openDelay: {
        type: Number,
        default: 0
      },
      closeDelay: {
        type: Number,
        default: 0
      },
      top: {
        type: String
      },
      modelValue: Boolean,
      modalClass: String,
      width: {
        type: [String, Number]
      },
      zIndex: {
        type: Number
      },
      trapFocus: {
        type: Boolean,
        default: false
      },
      headerAriaLevel: {
        type: String,
        default: "2"
      }
    });
    const dialogEmits = {
      open: () => true,
      opened: () => true,
      close: () => true,
      closed: () => true,
      [UPDATE_MODEL_EVENT]: (value) => isBoolean(value),
      openAutoFocus: () => true,
      closeAutoFocus: () => true
    };
    const useDialog = (props, targetRef) => {
      var _a2;
      const instance = getCurrentInstance();
      const emit2 = instance.emit;
      const { nextZIndex } = useZIndex();
      let lastPosition = "";
      const titleId = useId();
      const bodyId = useId();
      const visible = ref(false);
      const closed = ref(false);
      const rendered = ref(false);
      const zIndex2 = ref((_a2 = props.zIndex) != null ? _a2 : nextZIndex());
      let openTimer = void 0;
      let closeTimer = void 0;
      const namespace = useGlobalConfig("namespace", defaultNamespace);
      const style = 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 overlayDialogStyle = computed(() => {
        if (props.alignCenter) {
          return { display: "flex" };
        }
        return {};
      });
      function afterEnter() {
        emit2("opened");
      }
      function afterLeave() {
        emit2("closed");
        emit2(UPDATE_MODEL_EVENT, false);
        if (props.destroyOnClose) {
          rendered.value = false;
        }
      }
      function beforeLeave() {
        emit2("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 close2() {
        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 {
          close2();
        }
      }
      function onModalClick() {
        if (props.closeOnClickModal) {
          handleClose();
        }
      }
      function doOpen() {
        if (!isClient)
          return;
        visible.value = true;
      }
      function doClose() {
        visible.value = false;
      }
      function onOpenAutoFocus() {
        emit2("openAutoFocus");
      }
      function onCloseAutoFocus() {
        emit2("closeAutoFocus");
      }
      function onFocusoutPrevented(event) {
        var _a22;
        if (((_a22 = event.detail) == null ? void 0 : _a22.focusReason) === "pointer") {
          event.preventDefault();
        }
      }
      if (props.lockScroll) {
        useLockscreen(visible);
      }
      function onCloseRequested() {
        if (props.closeOnPressEscape) {
          handleClose();
        }
      }
      watch(() => props.modelValue, (val) => {
        if (val) {
          closed.value = false;
          open();
          rendered.value = true;
          zIndex2.value = isUndefined$1(props.zIndex) ? nextZIndex() : zIndex2.value++;
          nextTick(() => {
            emit2("open");
            if (targetRef.value) {
              targetRef.value.scrollTop = 0;
            }
          });
        } else {
          if (visible.value) {
            close2();
          }
        }
      });
      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;
        }
      });
      onMounted(() => {
        if (props.modelValue) {
          visible.value = true;
          rendered.value = true;
          open();
        }
      });
      return {
        afterEnter,
        afterLeave,
        beforeLeave,
        handleClose,
        onModalClick,
        close: close2,
        doClose,
        onOpenAutoFocus,
        onCloseAutoFocus,
        onCloseRequested,
        onFocusoutPrevented,
        titleId,
        bodyId,
        closed,
        style,
        overlayDialogStyle,
        rendered,
        visible,
        zIndex: zIndex2
      };
    };
    const _hoisted_1$D = ["aria-label", "aria-labelledby", "aria-describedby"];
    const __default__$O = /* @__PURE__ */ defineComponent({
      name: "ElDialog",
      inheritAttrs: false
    });
    const _sfc_main$1h = /* @__PURE__ */ defineComponent({
      ...__default__$O,
      props: dialogProps,
      emits: dialogEmits,
      setup(__props, { expose }) {
        const props = __props;
        const slots = 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"
        }, computed(() => !!slots.title));
        useDeprecated({
          scope: "el-dialog",
          from: "custom-class",
          replacement: "class",
          version: "2.3.0",
          ref: "https://element-plus.org/en-US/component/dialog.html#attributes",
          type: "Attribute"
        }, computed(() => !!props.customClass));
        const ns = useNamespace("dialog");
        const dialogRef = ref();
        const headerRef = ref();
        const dialogContentRef = ref();
        const {
          visible,
          titleId,
          bodyId,
          style,
          overlayDialogStyle,
          rendered,
          zIndex: zIndex2,
          afterEnter,
          afterLeave,
          beforeLeave,
          handleClose,
          onModalClick,
          onOpenAutoFocus,
          onCloseAutoFocus,
          onCloseRequested,
          onFocusoutPrevented
        } = useDialog(props, dialogRef);
        provide(dialogInjectionKey, {
          dialogRef,
          headerRef,
          bodyId,
          ns,
          rendered,
          style
        });
        const overlayEvent = useSameTarget(onModalClick);
        const draggable2 = computed(() => props.draggable && !props.fullscreen);
        expose({
          visible,
          dialogContentRef
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Teleport, {
            to: _ctx.appendTo,
            disabled: _ctx.appendTo !== "body" ? false : !_ctx.appendToBody
          }, [
            createVNode(Transition, {
              name: "dialog-fade",
              onAfterEnter: unref(afterEnter),
              onAfterLeave: unref(afterLeave),
              onBeforeLeave: unref(beforeLeave),
              persisted: ""
            }, {
              default: withCtx(() => [
                withDirectives(createVNode(unref(ElOverlay), {
                  "custom-mask-event": "",
                  mask: _ctx.modal,
                  "overlay-class": _ctx.modalClass,
                  "z-index": unref(zIndex2)
                }, {
                  default: withCtx(() => [
                    createBaseVNode("div", {
                      role: "dialog",
                      "aria-modal": "true",
                      "aria-label": _ctx.title || void 0,
                      "aria-labelledby": !_ctx.title ? unref(titleId) : void 0,
                      "aria-describedby": unref(bodyId),
                      class: normalizeClass(`${unref(ns).namespace.value}-overlay-dialog`),
                      style: normalizeStyle(unref(overlayDialogStyle)),
                      onClick: _cache[0] || (_cache[0] = (...args) => unref(overlayEvent).onClick && unref(overlayEvent).onClick(...args)),
                      onMousedown: _cache[1] || (_cache[1] = (...args) => unref(overlayEvent).onMousedown && unref(overlayEvent).onMousedown(...args)),
                      onMouseup: _cache[2] || (_cache[2] = (...args) => unref(overlayEvent).onMouseup && unref(overlayEvent).onMouseup(...args))
                    }, [
                      createVNode(unref(ElFocusTrap), {
                        loop: "",
                        trapped: unref(visible),
                        "focus-start-el": "container",
                        onFocusAfterTrapped: unref(onOpenAutoFocus),
                        onFocusAfterReleased: unref(onCloseAutoFocus),
                        onFocusoutPrevented: unref(onFocusoutPrevented),
                        onReleaseRequested: unref(onCloseRequested)
                      }, {
                        default: withCtx(() => [
                          unref(rendered) ? (openBlock(), createBlock(ElDialogContent, mergeProps({
                            key: 0,
                            ref_key: "dialogContentRef",
                            ref: dialogContentRef
                          }, _ctx.$attrs, {
                            "custom-class": _ctx.customClass,
                            center: _ctx.center,
                            "align-center": _ctx.alignCenter,
                            "close-icon": _ctx.closeIcon,
                            draggable: unref(draggable2),
                            fullscreen: _ctx.fullscreen,
                            "show-close": _ctx.showClose,
                            title: _ctx.title,
                            "aria-level": _ctx.headerAriaLevel,
                            onClose: unref(handleClose)
                          }), createSlots({
                            header: withCtx(() => [
                              !_ctx.$slots.title ? renderSlot(_ctx.$slots, "header", {
                                key: 0,
                                close: unref(handleClose),
                                titleId: unref(titleId),
                                titleClass: unref(ns).e("title")
                              }) : renderSlot(_ctx.$slots, "title", { key: 1 })
                            ]),
                            default: withCtx(() => [
                              renderSlot(_ctx.$slots, "default")
                            ]),
                            _: 2
                          }, [
                            _ctx.$slots.footer ? {
                              name: "footer",
                              fn: withCtx(() => [
                                renderSlot(_ctx.$slots, "footer")
                              ])
                            } : void 0
                          ]), 1040, ["custom-class", "center", "align-center", "close-icon", "draggable", "fullscreen", "show-close", "title", "aria-level", "onClose"])) : createCommentVNode("v-if", true)
                        ]),
                        _: 3
                      }, 8, ["trapped", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
                    ], 46, _hoisted_1$D)
                  ]),
                  _: 3
                }, 8, ["mask", "overlay-class", "z-index"]), [
                  [vShow, unref(visible)]
                ])
              ]),
              _: 3
            }, 8, ["onAfterEnter", "onAfterLeave", "onBeforeLeave"])
          ], 8, ["to", "disabled"]);
        };
      }
    });
    var Dialog = /* @__PURE__ */ _export_sfc$1(_sfc_main$1h, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/dialog/src/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__$N = /* @__PURE__ */ defineComponent({
      name: "ElDivider"
    });
    const _sfc_main$1g = /* @__PURE__ */ defineComponent({
      ...__default__$N,
      props: dividerProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("divider");
        const dividerStyle = computed(() => {
          return ns.cssVar({
            "border-style": props.borderStyle
          });
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.direction)]),
            style: normalizeStyle(unref(dividerStyle)),
            role: "separator"
          }, [
            _ctx.$slots.default && _ctx.direction !== "vertical" ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass([unref(ns).e("text"), unref(ns).is(_ctx.contentPosition)])
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2)) : createCommentVNode("v-if", true)
          ], 6);
        };
      }
    });
    var Divider = /* @__PURE__ */ _export_sfc$1(_sfc_main$1g, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/divider/src/divider.vue"]]);
    const ElDivider = withInstall(Divider);
    const drawerProps = buildProps({
      ...dialogProps,
      direction: {
        type: String,
        default: "rtl",
        values: ["ltr", "rtl", "ttb", "btt"]
      },
      size: {
        type: [String, Number],
        default: "30%"
      },
      withHeader: {
        type: Boolean,
        default: true
      },
      modalFade: {
        type: Boolean,
        default: true
      },
      headerAriaLevel: {
        type: String,
        default: "2"
      }
    });
    const drawerEmits = dialogEmits;
    const _sfc_main$1f = /* @__PURE__ */ defineComponent({
      name: "ElDrawer",
      components: {
        ElOverlay,
        ElFocusTrap,
        ElIcon,
        Close: close_default
      },
      inheritAttrs: false,
      props: drawerProps,
      emits: drawerEmits,
      setup(props, { slots }) {
        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"
        }, computed(() => !!slots.title));
        useDeprecated({
          scope: "el-drawer",
          from: "custom-class",
          replacement: "class",
          version: "2.3.0",
          ref: "https://element-plus.org/en-US/component/drawer.html#attributes",
          type: "Attribute"
        }, computed(() => !!props.customClass));
        const drawerRef = ref();
        const focusStartRef = ref();
        const ns = useNamespace("drawer");
        const { t } = useLocale();
        const isHorizontal2 = computed(() => props.direction === "rtl" || props.direction === "ltr");
        const drawerSize = computed(() => addUnit(props.size));
        return {
          ...useDialog(props, drawerRef),
          drawerRef,
          focusStartRef,
          isHorizontal: isHorizontal2,
          drawerSize,
          ns,
          t
        };
      }
    });
    const _hoisted_1$C = ["aria-label", "aria-labelledby", "aria-describedby"];
    const _hoisted_2$n = ["id", "aria-level"];
    const _hoisted_3$a = ["aria-label"];
    const _hoisted_4$7 = ["id"];
    function _sfc_render$o(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_close = resolveComponent("close");
      const _component_el_icon = resolveComponent("el-icon");
      const _component_el_focus_trap = resolveComponent("el-focus-trap");
      const _component_el_overlay = resolveComponent("el-overlay");
      return openBlock(), createBlock(Teleport, {
        to: "body",
        disabled: !_ctx.appendToBody
      }, [
        createVNode(Transition, {
          name: _ctx.ns.b("fade"),
          onAfterEnter: _ctx.afterEnter,
          onAfterLeave: _ctx.afterLeave,
          onBeforeLeave: _ctx.beforeLeave,
          persisted: ""
        }, {
          default: withCtx(() => [
            withDirectives(createVNode(_component_el_overlay, {
              mask: _ctx.modal,
              "overlay-class": _ctx.modalClass,
              "z-index": _ctx.zIndex,
              onClick: _ctx.onModalClick
            }, {
              default: withCtx(() => [
                createVNode(_component_el_focus_trap, {
                  loop: "",
                  trapped: _ctx.visible,
                  "focus-trap-el": _ctx.drawerRef,
                  "focus-start-el": _ctx.focusStartRef,
                  onReleaseRequested: _ctx.onCloseRequested
                }, {
                  default: withCtx(() => [
                    createBaseVNode("div", mergeProps({
                      ref: "drawerRef",
                      "aria-modal": "true",
                      "aria-label": _ctx.title || void 0,
                      "aria-labelledby": !_ctx.title ? _ctx.titleId : void 0,
                      "aria-describedby": _ctx.bodyId
                    }, _ctx.$attrs, {
                      class: [_ctx.ns.b(), _ctx.direction, _ctx.visible && "open", _ctx.customClass],
                      style: _ctx.isHorizontal ? "width: " + _ctx.drawerSize : "height: " + _ctx.drawerSize,
                      role: "dialog",
                      onClick: _cache[1] || (_cache[1] = withModifiers(() => {
                      }, ["stop"]))
                    }), [
                      createBaseVNode("span", {
                        ref: "focusStartRef",
                        class: normalizeClass(_ctx.ns.e("sr-focus")),
                        tabindex: "-1"
                      }, null, 2),
                      _ctx.withHeader ? (openBlock(), createElementBlock("header", {
                        key: 0,
                        class: normalizeClass(_ctx.ns.e("header"))
                      }, [
                        !_ctx.$slots.title ? renderSlot(_ctx.$slots, "header", {
                          key: 0,
                          close: _ctx.handleClose,
                          titleId: _ctx.titleId,
                          titleClass: _ctx.ns.e("title")
                        }, () => [
                          !_ctx.$slots.title ? (openBlock(), createElementBlock("span", {
                            key: 0,
                            id: _ctx.titleId,
                            role: "heading",
                            "aria-level": _ctx.headerAriaLevel,
                            class: normalizeClass(_ctx.ns.e("title"))
                          }, toDisplayString(_ctx.title), 11, _hoisted_2$n)) : createCommentVNode("v-if", true)
                        ]) : renderSlot(_ctx.$slots, "title", { key: 1 }, () => [
                          createCommentVNode(" DEPRECATED SLOT ")
                        ]),
                        _ctx.showClose ? (openBlock(), createElementBlock("button", {
                          key: 2,
                          "aria-label": _ctx.t("el.drawer.close"),
                          class: normalizeClass(_ctx.ns.e("close-btn")),
                          type: "button",
                          onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClose && _ctx.handleClose(...args))
                        }, [
                          createVNode(_component_el_icon, {
                            class: normalizeClass(_ctx.ns.e("close"))
                          }, {
                            default: withCtx(() => [
                              createVNode(_component_close)
                            ]),
                            _: 1
                          }, 8, ["class"])
                        ], 10, _hoisted_3$a)) : createCommentVNode("v-if", true)
                      ], 2)) : createCommentVNode("v-if", true),
                      _ctx.rendered ? (openBlock(), createElementBlock("div", {
                        key: 1,
                        id: _ctx.bodyId,
                        class: normalizeClass(_ctx.ns.e("body"))
                      }, [
                        renderSlot(_ctx.$slots, "default")
                      ], 10, _hoisted_4$7)) : createCommentVNode("v-if", true),
                      _ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
                        key: 2,
                        class: normalizeClass(_ctx.ns.e("footer"))
                      }, [
                        renderSlot(_ctx.$slots, "footer")
                      ], 2)) : createCommentVNode("v-if", true)
                    ], 16, _hoisted_1$C)
                  ]),
                  _: 3
                }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onReleaseRequested"])
              ]),
              _: 3
            }, 8, ["mask", "overlay-class", "z-index", "onClick"]), [
              [vShow, _ctx.visible]
            ])
          ]),
          _: 3
        }, 8, ["name", "onAfterEnter", "onAfterLeave", "onBeforeLeave"])
      ], 8, ["disabled"]);
    }
    var Drawer = /* @__PURE__ */ _export_sfc$1(_sfc_main$1f, [["render", _sfc_render$o], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/drawer/src/drawer.vue"]]);
    const ElDrawer = withInstall(Drawer);
    const _sfc_main$1e = /* @__PURE__ */ defineComponent({
      inheritAttrs: false
    });
    function _sfc_render$n(_ctx, _cache, $props, $setup, $data, $options) {
      return renderSlot(_ctx.$slots, "default");
    }
    var Collection = /* @__PURE__ */ _export_sfc$1(_sfc_main$1e, [["render", _sfc_render$n], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/collection/src/collection.vue"]]);
    const _sfc_main$1d = /* @__PURE__ */ defineComponent({
      name: "ElCollectionItem",
      inheritAttrs: false
    });
    function _sfc_render$m(_ctx, _cache, $props, $setup, $data, $options) {
      return renderSlot(_ctx.$slots, "default");
    }
    var CollectionItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$1d, [["render", _sfc_render$m], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/collection/src/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_KEY2 = Symbol(COLLECTION_NAME);
      const COLLECTION_ITEM_INJECTION_KEY2 = Symbol(COLLECTION_ITEM_NAME);
      const ElCollection2 = {
        ...Collection,
        name: COLLECTION_NAME,
        setup() {
          const collectionRef = ref(null);
          const itemMap = /* @__PURE__ */ new Map();
          const getItems = () => {
            const collectionEl = unref(collectionRef);
            if (!collectionEl)
              return [];
            const orderedNodes = Array.from(collectionEl.querySelectorAll(`[${COLLECTION_ITEM_SIGN}]`));
            const items = [...itemMap.values()];
            return items.sort((a2, b2) => orderedNodes.indexOf(a2.ref) - orderedNodes.indexOf(b2.ref));
          };
          provide(COLLECTION_INJECTION_KEY2, {
            itemMap,
            getItems,
            collectionRef
          });
        }
      };
      const ElCollectionItem2 = {
        ...CollectionItem,
        name: COLLECTION_ITEM_NAME,
        setup(_2, { attrs }) {
          const collectionItemRef = ref(null);
          const collectionInjection = inject(COLLECTION_INJECTION_KEY2, void 0);
          provide(COLLECTION_ITEM_INJECTION_KEY2, {
            collectionItemRef
          });
          onMounted(() => {
            const collectionItemEl = unref(collectionItemRef);
            if (collectionItemEl) {
              collectionInjection.itemMap.set(collectionItemEl, {
                ref: collectionItemEl,
                ...attrs
              });
            }
          });
          onBeforeUnmount(() => {
            const collectionItemEl = unref(collectionItemRef);
            collectionInjection.itemMap.delete(collectionItemEl);
          });
        }
      };
      return {
        COLLECTION_INJECTION_KEY: COLLECTION_INJECTION_KEY2,
        COLLECTION_ITEM_INJECTION_KEY: COLLECTION_ITEM_INJECTION_KEY2,
        ElCollection: ElCollection2,
        ElCollectionItem: ElCollectionItem2
      };
    };
    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: ElCollection$1,
      ElCollectionItem: ElCollectionItem$1,
      COLLECTION_INJECTION_KEY: COLLECTION_INJECTION_KEY$1,
      COLLECTION_ITEM_INJECTION_KEY: COLLECTION_ITEM_INJECTION_KEY$1
    } = 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 key = getDirectionAwareKey(event.key, 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 = (array2, atIdx) => {
      return array2.map((_2, idx) => array2[(idx + atIdx) % array2.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$1c = /* @__PURE__ */ defineComponent({
      name: "ElRovingFocusGroupImpl",
      inheritAttrs: false,
      props: rovingFocusGroupProps,
      emits: [CURRENT_TAB_ID_CHANGE_EVT, "entryFocus"],
      setup(props, { emit: emit2 }) {
        var _a2;
        const currentTabbedId = ref((_a2 = props.currentTabId || props.defaultCurrentTabId) != null ? _a2 : null);
        const isBackingOut = ref(false);
        const isClickFocus = ref(false);
        const rovingFocusGroupRef = ref(null);
        const { getItems } = inject(COLLECTION_INJECTION_KEY$1, void 0);
        const rovingFocusGroupRootStyle = computed(() => {
          return [
            {
              outline: "none"
            },
            props.style
          ];
        });
        const onItemFocus = (tabbedId) => {
          emit2(CURRENT_TAB_ID_CHANGE_EVT, tabbedId);
        };
        const onItemShiftTab = () => {
          isBackingOut.value = true;
        };
        const onMousedown = composeEventHandlers((e) => {
          var _a22;
          (_a22 = props.onMousedown) == null ? void 0 : _a22.call(props, e);
        }, () => {
          isClickFocus.value = true;
        });
        const onFocus = composeEventHandlers((e) => {
          var _a22;
          (_a22 = props.onFocus) == null ? void 0 : _a22.call(props, e);
        }, (e) => {
          const isKeyboardFocus = !unref(isClickFocus);
          const { target, currentTarget } = e;
          if (target === currentTarget && isKeyboardFocus && !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 === 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 _a22;
          (_a22 = props.onBlur) == null ? void 0 : _a22.call(props, e);
        }, () => {
          isBackingOut.value = false;
        });
        const handleEntryFocus = (...args) => {
          emit2("entryFocus", ...args);
        };
        provide(ROVING_FOCUS_GROUP_INJECTION_KEY, {
          currentTabbedId: readonly(currentTabbedId),
          loop: toRef(props, "loop"),
          tabIndex: computed(() => {
            return unref(isBackingOut) ? -1 : 0;
          }),
          rovingFocusGroupRef,
          rovingFocusGroupRootStyle,
          orientation: toRef(props, "orientation"),
          dir: toRef(props, "dir"),
          onItemFocus,
          onItemShiftTab,
          onBlur,
          onFocus,
          onMousedown
        });
        watch(() => props.currentTabId, (val) => {
          currentTabbedId.value = val != null ? val : null;
        });
        useEventListener(rovingFocusGroupRef, ENTRY_FOCUS_EVT, handleEntryFocus);
      }
    });
    function _sfc_render$l(_ctx, _cache, $props, $setup, $data, $options) {
      return renderSlot(_ctx.$slots, "default");
    }
    var ElRovingFocusGroupImpl = /* @__PURE__ */ _export_sfc$1(_sfc_main$1c, [["render", _sfc_render$l], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/roving-focus-group/src/roving-focus-group-impl.vue"]]);
    const _sfc_main$1b = /* @__PURE__ */ defineComponent({
      name: "ElRovingFocusGroup",
      components: {
        ElFocusGroupCollection: ElCollection$1,
        ElRovingFocusGroupImpl
      }
    });
    function _sfc_render$k(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_roving_focus_group_impl = resolveComponent("el-roving-focus-group-impl");
      const _component_el_focus_group_collection = resolveComponent("el-focus-group-collection");
      return openBlock(), createBlock(_component_el_focus_group_collection, null, {
        default: withCtx(() => [
          createVNode(_component_el_roving_focus_group_impl, normalizeProps(guardReactiveProps(_ctx.$attrs)), {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 16)
        ]),
        _: 3
      });
    }
    var ElRovingFocusGroup = /* @__PURE__ */ _export_sfc$1(_sfc_main$1b, [["render", _sfc_render$k], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/roving-focus-group/src/roving-focus-group.vue"]]);
    const _sfc_main$1a = /* @__PURE__ */ defineComponent({
      components: {
        ElRovingFocusCollectionItem: ElCollectionItem$1
      },
      props: {
        focusable: {
          type: Boolean,
          default: true
        },
        active: {
          type: Boolean,
          default: false
        }
      },
      emits: ["mousedown", "focus", "keydown"],
      setup(props, { emit: emit2 }) {
        const { currentTabbedId, loop, onItemFocus, onItemShiftTab } = inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
        const { getItems } = inject(COLLECTION_INJECTION_KEY$1, void 0);
        const id = useId();
        const rovingFocusGroupItemRef = ref(null);
        const handleMousedown = composeEventHandlers((e) => {
          emit2("mousedown", e);
        }, (e) => {
          if (!props.focusable) {
            e.preventDefault();
          } else {
            onItemFocus(unref(id));
          }
        });
        const handleFocus = composeEventHandlers((e) => {
          emit2("focus", e);
        }, () => {
          onItemFocus(unref(id));
        });
        const handleKeydown = composeEventHandlers((e) => {
          emit2("keydown", e);
        }, (e) => {
          const { key, shiftKey, target, currentTarget } = e;
          if (key === EVENT_CODE.tab && shiftKey) {
            onItemShiftTab();
            return;
          }
          if (target !== currentTarget)
            return;
          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(currentTarget);
                elements = loop.value ? reorderArray(elements, currentIdx + 1) : elements.slice(currentIdx + 1);
                break;
              }
            }
            nextTick(() => {
              focusFirst(elements);
            });
          }
        });
        const isCurrentTab = computed(() => currentTabbedId.value === unref(id));
        provide(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, {
          rovingFocusGroupItemRef,
          tabIndex: computed(() => unref(isCurrentTab) ? 0 : -1),
          handleMousedown,
          handleFocus,
          handleKeydown
        });
        return {
          id,
          handleKeydown,
          handleFocus,
          handleMousedown
        };
      }
    });
    function _sfc_render$j(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_roving_focus_collection_item = resolveComponent("el-roving-focus-collection-item");
      return openBlock(), createBlock(_component_el_roving_focus_collection_item, {
        id: _ctx.id,
        focusable: _ctx.focusable,
        active: _ctx.active
      }, {
        default: withCtx(() => [
          renderSlot(_ctx.$slots, "default")
        ]),
        _: 3
      }, 8, ["id", "focusable", "active"]);
    }
    var ElRovingFocusItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$1a, [["render", _sfc_render$j], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/roving-focus-group/src/roving-focus-item.vue"]]);
    const dropdownProps = buildProps({
      trigger: useTooltipTriggerProps.trigger,
      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
      },
      showTimeout: {
        type: Number,
        default: 150
      },
      hideTimeout: {
        type: Number,
        default: 150
      },
      tabindex: {
        type: definePropType([Number, String]),
        default: 0
      },
      maxHeight: {
        type: definePropType([Number, String]),
        default: ""
      },
      popperClass: {
        type: String,
        default: ""
      },
      disabled: {
        type: Boolean,
        default: false
      },
      role: {
        type: String,
        default: "menu"
      },
      buttonProps: {
        type: definePropType(Object)
      },
      teleported: useTooltipContentProps.teleported
    });
    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 {
      ElCollection,
      ElCollectionItem,
      COLLECTION_INJECTION_KEY,
      COLLECTION_ITEM_INJECTION_KEY
    } = createCollectionWithScope("Dropdown");
    const DROPDOWN_INJECTION_KEY = Symbol("elDropdown");
    const { ButtonGroup: ElButtonGroup } = ElButton;
    const _sfc_main$19 = /* @__PURE__ */ defineComponent({
      name: "ElDropdown",
      components: {
        ElButton,
        ElButtonGroup,
        ElScrollbar,
        ElDropdownCollection: ElCollection,
        ElTooltip,
        ElRovingFocusGroup,
        ElOnlyChild: OnlyChild,
        ElIcon,
        ArrowDown: arrow_down_default
      },
      props: dropdownProps,
      emits: ["visible-change", "click", "command"],
      setup(props, { emit: emit2 }) {
        const _instance = getCurrentInstance();
        const ns = useNamespace("dropdown");
        const { t } = useLocale();
        const triggeringElementRef = ref();
        const referenceElementRef = ref();
        const popperRef = ref(null);
        const contentRef = ref(null);
        const scrollbar = ref(null);
        const currentTabId = ref(null);
        const isUsingKeyboard = ref(false);
        const triggerKeys = [EVENT_CODE.enter, EVENT_CODE.space, EVENT_CODE.down];
        const wrapStyle = computed(() => ({
          maxHeight: addUnit(props.maxHeight)
        }));
        const dropdownTriggerKls = computed(() => [ns.m(dropdownSize.value)]);
        const trigger2 = computed(() => castArray$1(props.trigger));
        const defaultTriggerId = useId().value;
        const triggerId = computed(() => {
          return props.id || defaultTriggerId;
        });
        watch([triggeringElementRef, trigger2], ([triggeringElement, trigger22], [prevTriggeringElement]) => {
          var _a2, _b, _c;
          if ((_a2 = prevTriggeringElement == null ? void 0 : prevTriggeringElement.$el) == null ? void 0 : _a2.removeEventListener) {
            prevTriggeringElement.$el.removeEventListener("pointerenter", onAutofocusTriggerEnter);
          }
          if ((_b = triggeringElement == null ? void 0 : triggeringElement.$el) == null ? void 0 : _b.removeEventListener) {
            triggeringElement.$el.removeEventListener("pointerenter", onAutofocusTriggerEnter);
          }
          if (((_c = triggeringElement == null ? void 0 : triggeringElement.$el) == null ? void 0 : _c.addEventListener) && trigger22.includes("hover")) {
            triggeringElement.$el.addEventListener("pointerenter", onAutofocusTriggerEnter);
          }
        }, { immediate: true });
        onBeforeUnmount(() => {
          var _a2, _b;
          if ((_b = (_a2 = triggeringElementRef.value) == null ? void 0 : _a2.$el) == null ? void 0 : _b.removeEventListener) {
            triggeringElementRef.value.$el.removeEventListener("pointerenter", onAutofocusTriggerEnter);
          }
        });
        function handleClick() {
          handleClose();
        }
        function handleClose() {
          var _a2;
          (_a2 = popperRef.value) == null ? void 0 : _a2.onClose();
        }
        function handleOpen() {
          var _a2;
          (_a2 = popperRef.value) == null ? void 0 : _a2.onOpen();
        }
        const dropdownSize = useFormSize();
        function commandHandler(...args) {
          emit2("command", ...args);
        }
        function onAutofocusTriggerEnter() {
          var _a2, _b;
          (_b = (_a2 = triggeringElementRef.value) == null ? void 0 : _a2.$el) == null ? void 0 : _b.focus();
        }
        function onItemEnter() {
        }
        function onItemLeave() {
          const contentEl = unref(contentRef);
          trigger2.value.includes("hover") && (contentEl == null ? void 0 : contentEl.focus());
          currentTabId.value = null;
        }
        function handleCurrentTabIdChange(id) {
          currentTabId.value = id;
        }
        function handleEntryFocus(e) {
          if (!isUsingKeyboard.value) {
            e.preventDefault();
            e.stopImmediatePropagation();
          }
        }
        function handleBeforeShowTooltip() {
          emit2("visible-change", true);
        }
        function handleShowTooltip(event) {
          if ((event == null ? void 0 : event.type) === "keydown") {
            contentRef.value.focus();
          }
        }
        function handleBeforeHideTooltip() {
          emit2("visible-change", false);
        }
        provide(DROPDOWN_INJECTION_KEY, {
          contentRef,
          role: computed(() => props.role),
          triggerId,
          isUsingKeyboard,
          onItemEnter,
          onItemLeave
        });
        provide("elDropdown", {
          instance: _instance,
          dropdownSize,
          handleClick,
          commandHandler,
          trigger: toRef(props, "trigger"),
          hideOnClick: toRef(props, "hideOnClick")
        });
        const onFocusAfterTrapped = (e) => {
          var _a2, _b;
          e.preventDefault();
          (_b = (_a2 = contentRef.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2, {
            preventScroll: true
          });
        };
        const handlerMainButtonClick = (event) => {
          emit2("click", event);
        };
        return {
          t,
          ns,
          scrollbar,
          wrapStyle,
          dropdownTriggerKls,
          dropdownSize,
          triggerId,
          triggerKeys,
          currentTabId,
          handleCurrentTabIdChange,
          handlerMainButtonClick,
          handleEntryFocus,
          handleClose,
          handleOpen,
          handleBeforeShowTooltip,
          handleShowTooltip,
          handleBeforeHideTooltip,
          onFocusAfterTrapped,
          popperRef,
          contentRef,
          triggeringElementRef,
          referenceElementRef
        };
      }
    });
    function _sfc_render$i(_ctx, _cache, $props, $setup, $data, $options) {
      var _a2;
      const _component_el_dropdown_collection = resolveComponent("el-dropdown-collection");
      const _component_el_roving_focus_group = resolveComponent("el-roving-focus-group");
      const _component_el_scrollbar = resolveComponent("el-scrollbar");
      const _component_el_only_child = resolveComponent("el-only-child");
      const _component_el_tooltip = resolveComponent("el-tooltip");
      const _component_el_button = resolveComponent("el-button");
      const _component_arrow_down = resolveComponent("arrow-down");
      const _component_el_icon = resolveComponent("el-icon");
      const _component_el_button_group = resolveComponent("el-button-group");
      return openBlock(), createElementBlock("div", {
        class: normalizeClass([_ctx.ns.b(), _ctx.ns.is("disabled", _ctx.disabled)])
      }, [
        createVNode(_component_el_tooltip, {
          ref: "popperRef",
          role: _ctx.role,
          effect: _ctx.effect,
          "fallback-placements": ["bottom", "top"],
          "popper-options": _ctx.popperOptions,
          "gpu-acceleration": false,
          "hide-after": _ctx.trigger === "hover" ? _ctx.hideTimeout : 0,
          "manual-mode": true,
          placement: _ctx.placement,
          "popper-class": [_ctx.ns.e("popper"), _ctx.popperClass],
          "reference-element": (_a2 = _ctx.referenceElementRef) == null ? void 0 : _a2.$el,
          trigger: _ctx.trigger,
          "trigger-keys": _ctx.triggerKeys,
          "trigger-target-el": _ctx.contentRef,
          "show-after": _ctx.trigger === "hover" ? _ctx.showTimeout : 0,
          "stop-popper-mouse-event": false,
          "virtual-ref": _ctx.triggeringElementRef,
          "virtual-triggering": _ctx.splitButton,
          disabled: _ctx.disabled,
          transition: `${_ctx.ns.namespace.value}-zoom-in-top`,
          teleported: _ctx.teleported,
          pure: "",
          persistent: "",
          onBeforeShow: _ctx.handleBeforeShowTooltip,
          onShow: _ctx.handleShowTooltip,
          onBeforeHide: _ctx.handleBeforeHideTooltip
        }, createSlots({
          content: withCtx(() => [
            createVNode(_component_el_scrollbar, {
              ref: "scrollbar",
              "wrap-style": _ctx.wrapStyle,
              tag: "div",
              "view-class": _ctx.ns.e("list")
            }, {
              default: withCtx(() => [
                createVNode(_component_el_roving_focus_group, {
                  loop: _ctx.loop,
                  "current-tab-id": _ctx.currentTabId,
                  orientation: "horizontal",
                  onCurrentTabIdChange: _ctx.handleCurrentTabIdChange,
                  onEntryFocus: _ctx.handleEntryFocus
                }, {
                  default: withCtx(() => [
                    createVNode(_component_el_dropdown_collection, null, {
                      default: withCtx(() => [
                        renderSlot(_ctx.$slots, "dropdown")
                      ]),
                      _: 3
                    })
                  ]),
                  _: 3
                }, 8, ["loop", "current-tab-id", "onCurrentTabIdChange", "onEntryFocus"])
              ]),
              _: 3
            }, 8, ["wrap-style", "view-class"])
          ]),
          _: 2
        }, [
          !_ctx.splitButton ? {
            name: "default",
            fn: withCtx(() => [
              createVNode(_component_el_only_child, {
                id: _ctx.triggerId,
                ref: "triggeringElementRef",
                role: "button",
                tabindex: _ctx.tabindex
              }, {
                default: withCtx(() => [
                  renderSlot(_ctx.$slots, "default")
                ]),
                _: 3
              }, 8, ["id", "tabindex"])
            ])
          } : void 0
        ]), 1032, ["role", "effect", "popper-options", "hide-after", "placement", "popper-class", "reference-element", "trigger", "trigger-keys", "trigger-target-el", "show-after", "virtual-ref", "virtual-triggering", "disabled", "transition", "teleported", "onBeforeShow", "onShow", "onBeforeHide"]),
        _ctx.splitButton ? (openBlock(), createBlock(_component_el_button_group, { key: 0 }, {
          default: withCtx(() => [
            createVNode(_component_el_button, mergeProps({ ref: "referenceElementRef" }, _ctx.buttonProps, {
              size: _ctx.dropdownSize,
              type: _ctx.type,
              disabled: _ctx.disabled,
              tabindex: _ctx.tabindex,
              onClick: _ctx.handlerMainButtonClick
            }), {
              default: withCtx(() => [
                renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 16, ["size", "type", "disabled", "tabindex", "onClick"]),
            createVNode(_component_el_button, 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: withCtx(() => [
                createVNode(_component_el_icon, {
                  class: normalizeClass(_ctx.ns.e("icon"))
                }, {
                  default: withCtx(() => [
                    createVNode(_component_arrow_down)
                  ]),
                  _: 1
                }, 8, ["class"])
              ]),
              _: 1
            }, 16, ["id", "size", "type", "class", "disabled", "tabindex", "aria-label"])
          ]),
          _: 3
        })) : createCommentVNode("v-if", true)
      ], 2);
    }
    var Dropdown = /* @__PURE__ */ _export_sfc$1(_sfc_main$19, [["render", _sfc_render$i], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/dropdown/src/dropdown.vue"]]);
    const _sfc_main$18 = /* @__PURE__ */ defineComponent({
      name: "DropdownItemImpl",
      components: {
        ElIcon
      },
      props: dropdownItemProps,
      emits: ["pointermove", "pointerleave", "click", "clickimpl"],
      setup(_2, { emit: emit2 }) {
        const ns = useNamespace("dropdown");
        const { role: menuRole } = inject(DROPDOWN_INJECTION_KEY, void 0);
        const { collectionItemRef: dropdownCollectionItemRef } = inject(COLLECTION_ITEM_INJECTION_KEY, void 0);
        const { collectionItemRef: rovingFocusCollectionItemRef } = inject(COLLECTION_ITEM_INJECTION_KEY$1, void 0);
        const {
          rovingFocusGroupItemRef,
          tabIndex,
          handleFocus,
          handleKeydown: handleItemKeydown,
          handleMousedown
        } = inject(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, void 0);
        const itemRef = composeRefs(dropdownCollectionItemRef, rovingFocusCollectionItemRef, rovingFocusGroupItemRef);
        const role = computed(() => {
          if (menuRole.value === "menu") {
            return "menuitem";
          } else if (menuRole.value === "navigation") {
            return "link";
          }
          return "button";
        });
        const handleKeydown = composeEventHandlers((e) => {
          const { code } = e;
          if (code === EVENT_CODE.enter || code === EVENT_CODE.space) {
            e.preventDefault();
            e.stopImmediatePropagation();
            emit2("clickimpl", e);
            return true;
          }
        }, handleItemKeydown);
        return {
          ns,
          itemRef,
          dataset: {
            [COLLECTION_ITEM_SIGN]: ""
          },
          role,
          tabIndex,
          handleFocus,
          handleKeydown,
          handleMousedown
        };
      }
    });
    const _hoisted_1$B = ["aria-disabled", "tabindex", "role"];
    function _sfc_render$h(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_icon = resolveComponent("el-icon");
      return openBlock(), createElementBlock(Fragment, null, [
        _ctx.divided ? (openBlock(), createElementBlock("li", mergeProps({
          key: 0,
          role: "separator",
          class: _ctx.ns.bem("menu", "item", "divided")
        }, _ctx.$attrs), null, 16)) : createCommentVNode("v-if", true),
        createBaseVNode("li", 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: _cache[0] || (_cache[0] = (e) => _ctx.$emit("clickimpl", e)),
          onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
          onKeydown: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args), ["self"])),
          onMousedown: _cache[3] || (_cache[3] = (...args) => _ctx.handleMousedown && _ctx.handleMousedown(...args)),
          onPointermove: _cache[4] || (_cache[4] = (e) => _ctx.$emit("pointermove", e)),
          onPointerleave: _cache[5] || (_cache[5] = (e) => _ctx.$emit("pointerleave", e))
        }), [
          _ctx.icon ? (openBlock(), createBlock(_component_el_icon, { key: 0 }, {
            default: withCtx(() => [
              (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
            ]),
            _: 1
          })) : createCommentVNode("v-if", true),
          renderSlot(_ctx.$slots, "default")
        ], 16, _hoisted_1$B)
      ], 64);
    }
    var ElDropdownItemImpl = /* @__PURE__ */ _export_sfc$1(_sfc_main$18, [["render", _sfc_render$h], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/dropdown/src/dropdown-item-impl.vue"]]);
    const useDropdown = () => {
      const elDropdown = inject("elDropdown", {});
      const _elDropdownSize = computed(() => elDropdown == null ? void 0 : elDropdown.dropdownSize);
      return {
        elDropdown,
        _elDropdownSize
      };
    };
    const _sfc_main$17 = /* @__PURE__ */ defineComponent({
      name: "ElDropdownItem",
      components: {
        ElDropdownCollectionItem: ElCollectionItem,
        ElRovingFocusItem,
        ElDropdownItemImpl
      },
      inheritAttrs: false,
      props: dropdownItemProps,
      emits: ["pointermove", "pointerleave", "click"],
      setup(props, { emit: emit2, attrs }) {
        const { elDropdown } = useDropdown();
        const _instance = getCurrentInstance();
        const itemRef = ref(null);
        const textContent = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = unref(itemRef)) == null ? void 0 : _a2.textContent) != null ? _b : "";
        });
        const { onItemEnter, onItemLeave } = inject(DROPDOWN_INJECTION_KEY, void 0);
        const handlePointerMove = composeEventHandlers((e) => {
          emit2("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();
          }
        }));
        const handlePointerLeave = composeEventHandlers((e) => {
          emit2("pointerleave", e);
          return e.defaultPrevented;
        }, whenMouse((e) => {
          onItemLeave(e);
        }));
        const handleClick = composeEventHandlers((e) => {
          if (props.disabled) {
            return;
          }
          emit2("click", e);
          return e.type !== "keydown" && e.defaultPrevented;
        }, (e) => {
          var _a2, _b, _c;
          if (props.disabled) {
            e.stopImmediatePropagation();
            return;
          }
          if ((_a2 = elDropdown == null ? void 0 : elDropdown.hideOnClick) == null ? void 0 : _a2.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 = computed(() => {
          return { ...props, ...attrs };
        });
        return {
          handleClick,
          handlePointerMove,
          handlePointerLeave,
          textContent,
          propsAndAttrs
        };
      }
    });
    function _sfc_render$g(_ctx, _cache, $props, $setup, $data, $options) {
      var _a2;
      const _component_el_dropdown_item_impl = resolveComponent("el-dropdown-item-impl");
      const _component_el_roving_focus_item = resolveComponent("el-roving-focus-item");
      const _component_el_dropdown_collection_item = resolveComponent("el-dropdown-collection-item");
      return openBlock(), createBlock(_component_el_dropdown_collection_item, {
        disabled: _ctx.disabled,
        "text-value": (_a2 = _ctx.textValue) != null ? _a2 : _ctx.textContent
      }, {
        default: withCtx(() => [
          createVNode(_component_el_roving_focus_item, {
            focusable: !_ctx.disabled
          }, {
            default: withCtx(() => [
              createVNode(_component_el_dropdown_item_impl, mergeProps(_ctx.propsAndAttrs, {
                onPointerleave: _ctx.handlePointerLeave,
                onPointermove: _ctx.handlePointerMove,
                onClickimpl: _ctx.handleClick
              }), {
                default: withCtx(() => [
                  renderSlot(_ctx.$slots, "default")
                ]),
                _: 3
              }, 16, ["onPointerleave", "onPointermove", "onClickimpl"])
            ]),
            _: 3
          }, 8, ["focusable"])
        ]),
        _: 3
      }, 8, ["disabled", "text-value"]);
    }
    var DropdownItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$17, [["render", _sfc_render$g], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/dropdown/src/dropdown-item.vue"]]);
    const _sfc_main$16 = /* @__PURE__ */ defineComponent({
      name: "ElDropdownMenu",
      props: dropdownMenuProps,
      setup(props) {
        const ns = useNamespace("dropdown");
        const { _elDropdownSize } = useDropdown();
        const size2 = _elDropdownSize.value;
        const { focusTrapRef, onKeydown } = inject(FOCUS_TRAP_INJECTION_KEY, void 0);
        const { contentRef, role, triggerId } = inject(DROPDOWN_INJECTION_KEY, void 0);
        const { collectionRef: dropdownCollectionRef, getItems } = inject(COLLECTION_INJECTION_KEY, void 0);
        const {
          rovingFocusGroupRef,
          rovingFocusGroupRootStyle,
          tabIndex,
          onBlur,
          onFocus,
          onMousedown
        } = inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
        const { collectionRef: rovingFocusGroupCollectionRef } = inject(COLLECTION_INJECTION_KEY$1, void 0);
        const dropdownKls = computed(() => {
          return [ns.b("menu"), ns.bm("menu", size2 == null ? void 0 : size2.value)];
        });
        const dropdownListWrapperRef = composeRefs(contentRef, dropdownCollectionRef, focusTrapRef, rovingFocusGroupRef, rovingFocusGroupCollectionRef);
        const composedKeydown = composeEventHandlers((e) => {
          var _a2;
          (_a2 = props.onKeydown) == null ? void 0 : _a2.call(props, e);
        }, (e) => {
          const { currentTarget, code, target } = e;
          currentTarget.contains(target);
          if (EVENT_CODE.tab === code) {
            e.stopImmediatePropagation();
          }
          e.preventDefault();
          if (target !== unref(contentRef))
            return;
          if (!FIRST_LAST_KEYS.includes(code))
            return;
          const items = getItems().filter((item) => !item.disabled);
          const targets = items.map((item) => item.ref);
          if (LAST_KEYS.includes(code)) {
            targets.reverse();
          }
          focusFirst(targets);
        });
        const handleKeydown = (e) => {
          composedKeydown(e);
          onKeydown(e);
        };
        return {
          size: size2,
          rovingFocusGroupRootStyle,
          tabIndex,
          dropdownKls,
          role,
          triggerId,
          dropdownListWrapperRef,
          handleKeydown,
          onBlur,
          onFocus,
          onMousedown
        };
      }
    });
    const _hoisted_1$A = ["role", "aria-labelledby"];
    function _sfc_render$f(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createElementBlock("ul", {
        ref: _ctx.dropdownListWrapperRef,
        class: normalizeClass(_ctx.dropdownKls),
        style: normalizeStyle(_ctx.rovingFocusGroupRootStyle),
        tabindex: -1,
        role: _ctx.role,
        "aria-labelledby": _ctx.triggerId,
        onBlur: _cache[0] || (_cache[0] = (...args) => _ctx.onBlur && _ctx.onBlur(...args)),
        onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.onFocus && _ctx.onFocus(...args)),
        onKeydown: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args), ["self"])),
        onMousedown: _cache[3] || (_cache[3] = withModifiers((...args) => _ctx.onMousedown && _ctx.onMousedown(...args), ["self"]))
      }, [
        renderSlot(_ctx.$slots, "default")
      ], 46, _hoisted_1$A);
    }
    var DropdownMenu = /* @__PURE__ */ _export_sfc$1(_sfc_main$16, [["render", _sfc_render$f], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/dropdown/src/dropdown-menu.vue"]]);
    const ElDropdown = withInstall(Dropdown, {
      DropdownItem,
      DropdownMenu
    });
    const ElDropdownItem = withNoopInstall(DropdownItem);
    const ElDropdownMenu = withNoopInstall(DropdownMenu);
    const _hoisted_1$z = {
      viewBox: "0 0 79 86",
      version: "1.1",
      xmlns: "http://www.w3.org/2000/svg",
      "xmlns:xlink": "http://www.w3.org/1999/xlink"
    };
    const _hoisted_2$m = ["id"];
    const _hoisted_3$9 = ["stop-color"];
    const _hoisted_4$6 = ["stop-color"];
    const _hoisted_5$5 = ["id"];
    const _hoisted_6$2 = ["stop-color"];
    const _hoisted_7 = ["stop-color"];
    const _hoisted_8 = ["id"];
    const _hoisted_9 = {
      id: "Illustrations",
      stroke: "none",
      "stroke-width": "1",
      fill: "none",
      "fill-rule": "evenodd"
    };
    const _hoisted_10 = {
      id: "B-type",
      transform: "translate(-1268.000000, -535.000000)"
    };
    const _hoisted_11 = {
      id: "Group-2",
      transform: "translate(1268.000000, 535.000000)"
    };
    const _hoisted_12 = ["fill"];
    const _hoisted_13 = ["fill"];
    const _hoisted_14 = {
      id: "Group-Copy",
      transform: "translate(34.500000, 31.500000) scale(-1, 1) rotate(-25.000000) translate(-34.500000, -31.500000) translate(7.000000, 10.000000)"
    };
    const _hoisted_15 = ["fill"];
    const _hoisted_16 = ["fill"];
    const _hoisted_17 = ["fill"];
    const _hoisted_18 = ["fill"];
    const _hoisted_19 = ["fill"];
    const _hoisted_20 = {
      id: "Rectangle-Copy-17",
      transform: "translate(53.000000, 45.000000)"
    };
    const _hoisted_21 = ["fill", "xlink:href"];
    const _hoisted_22 = ["fill", "mask"];
    const _hoisted_23 = ["fill"];
    const __default__$M = /* @__PURE__ */ defineComponent({
      name: "ImgEmpty"
    });
    const _sfc_main$15 = /* @__PURE__ */ defineComponent({
      ...__default__$M,
      setup(__props) {
        const ns = useNamespace("empty");
        const id = useId();
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("svg", _hoisted_1$z, [
            createBaseVNode("defs", null, [
              createBaseVNode("linearGradient", {
                id: `linearGradient-1-${unref(id)}`,
                x1: "38.8503086%",
                y1: "0%",
                x2: "61.1496914%",
                y2: "100%"
              }, [
                createBaseVNode("stop", {
                  "stop-color": `var(${unref(ns).cssVarBlockName("fill-color-1")})`,
                  offset: "0%"
                }, null, 8, _hoisted_3$9),
                createBaseVNode("stop", {
                  "stop-color": `var(${unref(ns).cssVarBlockName("fill-color-4")})`,
                  offset: "100%"
                }, null, 8, _hoisted_4$6)
              ], 8, _hoisted_2$m),
              createBaseVNode("linearGradient", {
                id: `linearGradient-2-${unref(id)}`,
                x1: "0%",
                y1: "9.5%",
                x2: "100%",
                y2: "90.5%"
              }, [
                createBaseVNode("stop", {
                  "stop-color": `var(${unref(ns).cssVarBlockName("fill-color-1")})`,
                  offset: "0%"
                }, null, 8, _hoisted_6$2),
                createBaseVNode("stop", {
                  "stop-color": `var(${unref(ns).cssVarBlockName("fill-color-6")})`,
                  offset: "100%"
                }, null, 8, _hoisted_7)
              ], 8, _hoisted_5$5),
              createBaseVNode("rect", {
                id: `path-3-${unref(id)}`,
                x: "0",
                y: "0",
                width: "17",
                height: "36"
              }, null, 8, _hoisted_8)
            ]),
            createBaseVNode("g", _hoisted_9, [
              createBaseVNode("g", _hoisted_10, [
                createBaseVNode("g", _hoisted_11, [
                  createBaseVNode("path", {
                    id: "Oval-Copy-2",
                    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(${unref(ns).cssVarBlockName("fill-color-3")})`
                  }, null, 8, _hoisted_12),
                  createBaseVNode("polygon", {
                    id: "Rectangle-Copy-14",
                    fill: `var(${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, _hoisted_13),
                  createBaseVNode("g", _hoisted_14, [
                    createBaseVNode("polygon", {
                      id: "Rectangle-Copy-10",
                      fill: `var(${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, _hoisted_15),
                    createBaseVNode("polygon", {
                      id: "Rectangle-Copy-11",
                      fill: `var(${unref(ns).cssVarBlockName("fill-color-5")})`,
                      points: "-3.69149156e-15 7 38 7 38 43 -3.69149156e-15 43"
                    }, null, 8, _hoisted_16),
                    createBaseVNode("rect", {
                      id: "Rectangle-Copy-12",
                      fill: `url(#linearGradient-1-${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, _hoisted_17),
                    createBaseVNode("polygon", {
                      id: "Rectangle-Copy-13",
                      fill: `var(${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, _hoisted_18)
                  ]),
                  createBaseVNode("rect", {
                    id: "Rectangle-Copy-15",
                    fill: `url(#linearGradient-2-${unref(id)})`,
                    x: "13",
                    y: "45",
                    width: "40",
                    height: "36"
                  }, null, 8, _hoisted_19),
                  createBaseVNode("g", _hoisted_20, [
                    createBaseVNode("use", {
                      id: "Mask",
                      fill: `var(${unref(ns).cssVarBlockName("fill-color-8")})`,
                      transform: "translate(8.500000, 18.000000) scale(-1, 1) translate(-8.500000, -18.000000) ",
                      "xlink:href": `#path-3-${unref(id)}`
                    }, null, 8, _hoisted_21),
                    createBaseVNode("polygon", {
                      id: "Rectangle-Copy",
                      fill: `var(${unref(ns).cssVarBlockName("fill-color-9")})`,
                      mask: `url(#mask-4-${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, _hoisted_22)
                  ]),
                  createBaseVNode("polygon", {
                    id: "Rectangle-Copy-18",
                    fill: `var(${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, _hoisted_23)
                ])
              ])
            ])
          ]);
        };
      }
    });
    var ImgEmpty = /* @__PURE__ */ _export_sfc$1(_sfc_main$15, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/empty/src/img-empty.vue"]]);
    const emptyProps = buildProps({
      image: {
        type: String,
        default: ""
      },
      imageSize: Number,
      description: {
        type: String,
        default: ""
      }
    });
    const _hoisted_1$y = ["src"];
    const _hoisted_2$l = { key: 1 };
    const __default__$L = /* @__PURE__ */ defineComponent({
      name: "ElEmpty"
    });
    const _sfc_main$14 = /* @__PURE__ */ defineComponent({
      ...__default__$L,
      props: emptyProps,
      setup(__props) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("empty");
        const emptyDescription = computed(() => props.description || t("el.table.emptyText"));
        const imageStyle = computed(() => ({
          width: addUnit(props.imageSize)
        }));
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(ns).b())
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("image")),
              style: normalizeStyle(unref(imageStyle))
            }, [
              _ctx.image ? (openBlock(), createElementBlock("img", {
                key: 0,
                src: _ctx.image,
                ondragstart: "return false"
              }, null, 8, _hoisted_1$y)) : renderSlot(_ctx.$slots, "image", { key: 1 }, () => [
                createVNode(ImgEmpty)
              ])
            ], 6),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("description"))
            }, [
              _ctx.$slots.description ? renderSlot(_ctx.$slots, "description", { key: 0 }) : (openBlock(), createElementBlock("p", _hoisted_2$l, toDisplayString(unref(emptyDescription)), 1))
            ], 2),
            _ctx.$slots.default ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("bottom"))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var Empty = /* @__PURE__ */ _export_sfc$1(_sfc_main$14, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/empty/src/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
      },
      minScale: {
        type: Number,
        default: 0.2
      },
      maxScale: {
        type: Number,
        default: 7
      }
    });
    const imageViewerEmits = {
      close: () => true,
      switch: (index2) => isNumber(index2),
      rotate: (deg) => isNumber(deg)
    };
    const _hoisted_1$x = ["src"];
    const __default__$K = /* @__PURE__ */ defineComponent({
      name: "ElImageViewer"
    });
    const _sfc_main$13 = /* @__PURE__ */ defineComponent({
      ...__default__$K,
      props: imageViewerProps,
      emits: imageViewerEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const modes = {
          CONTAIN: {
            name: "contain",
            icon: markRaw(full_screen_default)
          },
          ORIGINAL: {
            name: "original",
            icon: markRaw(scale_to_original_default)
          }
        };
        const { t } = useLocale();
        const ns = useNamespace("image-viewer");
        const { nextZIndex } = useZIndex();
        const wrapper = ref();
        const imgRefs = ref([]);
        const scopeEventListener = effectScope();
        const loading = ref(true);
        const activeIndex = ref(props.initialIndex);
        const mode = shallowRef(modes.CONTAIN);
        const transform = ref({
          scale: 1,
          deg: 0,
          offsetX: 0,
          offsetY: 0,
          enableTransition: false
        });
        const isSingle = computed(() => {
          const { urlList } = props;
          return urlList.length <= 1;
        });
        const isFirst = computed(() => {
          return activeIndex.value === 0;
        });
        const isLast = computed(() => {
          return activeIndex.value === props.urlList.length - 1;
        });
        const currentImg = computed(() => {
          return props.urlList[activeIndex.value];
        });
        const arrowPrevKls = computed(() => [
          ns.e("btn"),
          ns.e("prev"),
          ns.is("disabled", !props.infinite && isFirst.value)
        ]);
        const arrowNextKls = computed(() => [
          ns.e("btn"),
          ns.e("next"),
          ns.is("disabled", !props.infinite && isLast.value)
        ]);
        const imgStyle = computed(() => {
          const { scale, deg, offsetX, offsetY, enableTransition } = transform.value;
          let translateX = offsetX / scale;
          let translateY = offsetY / scale;
          switch (deg % 360) {
            case 90:
            case -270:
              [translateX, translateY] = [translateY, -translateX];
              break;
            case 180:
            case -180:
              [translateX, translateY] = [-translateX, -translateY];
              break;
            case 270:
            case -90:
              [translateX, translateY] = [-translateY, translateX];
              break;
          }
          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 computedZIndex = computed(() => {
          return isNumber(props.zIndex) ? props.zIndex : nextZIndex();
        });
        function hide() {
          unregisterEventListener();
          emit2("close");
        }
        function registerEventListener() {
          const keydownHandler = throttle((e) => {
            switch (e.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) {
          loading.value = false;
          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: 1,
            deg: 0,
            offsetX: 0,
            offsetY: 0,
            enableTransition: false
          };
        }
        function toggleMode() {
          if (loading.value)
            return;
          const modeNames = keysOf(modes);
          const modeValues = Object.values(modes);
          const currentMode = mode.value.name;
          const index2 = modeValues.findIndex((i) => i.name === currentMode);
          const nextIndex = (index2 + 1) % modeNames.length;
          mode.value = modes[modeNames[nextIndex]];
          reset();
        }
        function setActiveItem(index2) {
          const len = props.urlList.length;
          activeIndex.value = (index2 + 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)
            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;
              emit2("rotate", transform.value.deg);
              break;
            case "anticlockwise":
              transform.value.deg -= rotateDeg;
              emit2("rotate", transform.value.deg);
              break;
          }
          transform.value.enableTransition = enableTransition;
        }
        watch(currentImg, () => {
          nextTick(() => {
            const $img = imgRefs.value[0];
            if (!($img == null ? void 0 : $img.complete)) {
              loading.value = true;
            }
          });
        });
        watch(activeIndex, (val) => {
          reset();
          emit2("switch", val);
        });
        onMounted(() => {
          var _a2, _b;
          registerEventListener();
          (_b = (_a2 = wrapper.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
        });
        expose({
          setActiveItem
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Teleport, {
            to: "body",
            disabled: !_ctx.teleported
          }, [
            createVNode(Transition, {
              name: "viewer-fade",
              appear: ""
            }, {
              default: withCtx(() => [
                createBaseVNode("div", {
                  ref_key: "wrapper",
                  ref: wrapper,
                  tabindex: -1,
                  class: normalizeClass(unref(ns).e("wrapper")),
                  style: normalizeStyle({ zIndex: unref(computedZIndex) })
                }, [
                  createBaseVNode("div", {
                    class: normalizeClass(unref(ns).e("mask")),
                    onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.hideOnClickModal && hide(), ["self"]))
                  }, null, 2),
                  createCommentVNode(" CLOSE "),
                  createBaseVNode("span", {
                    class: normalizeClass([unref(ns).e("btn"), unref(ns).e("close")]),
                    onClick: hide
                  }, [
                    createVNode(unref(ElIcon), null, {
                      default: withCtx(() => [
                        createVNode(unref(close_default))
                      ]),
                      _: 1
                    })
                  ], 2),
                  createCommentVNode(" ARROW "),
                  !unref(isSingle) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                    createBaseVNode("span", {
                      class: normalizeClass(unref(arrowPrevKls)),
                      onClick: prev
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    createBaseVNode("span", {
                      class: normalizeClass(unref(arrowNextKls)),
                      onClick: next
                    }, [
                      createVNode(unref(ElIcon), null, {
                        default: withCtx(() => [
                          createVNode(unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 2)
                  ], 64)) : createCommentVNode("v-if", true),
                  createCommentVNode(" ACTIONS "),
                  createBaseVNode("div", {
                    class: normalizeClass([unref(ns).e("btn"), unref(ns).e("actions")])
                  }, [
                    createBaseVNode("div", {
                      class: normalizeClass(unref(ns).e("actions__inner"))
                    }, [
                      createVNode(unref(ElIcon), {
                        onClick: _cache[1] || (_cache[1] = ($event) => handleActions("zoomOut"))
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(zoom_out_default))
                        ]),
                        _: 1
                      }),
                      createVNode(unref(ElIcon), {
                        onClick: _cache[2] || (_cache[2] = ($event) => handleActions("zoomIn"))
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(zoom_in_default))
                        ]),
                        _: 1
                      }),
                      createBaseVNode("i", {
                        class: normalizeClass(unref(ns).e("actions__divider"))
                      }, null, 2),
                      createVNode(unref(ElIcon), { onClick: toggleMode }, {
                        default: withCtx(() => [
                          (openBlock(), createBlock(resolveDynamicComponent(unref(mode).icon)))
                        ]),
                        _: 1
                      }),
                      createBaseVNode("i", {
                        class: normalizeClass(unref(ns).e("actions__divider"))
                      }, null, 2),
                      createVNode(unref(ElIcon), {
                        onClick: _cache[3] || (_cache[3] = ($event) => handleActions("anticlockwise"))
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(refresh_left_default))
                        ]),
                        _: 1
                      }),
                      createVNode(unref(ElIcon), {
                        onClick: _cache[4] || (_cache[4] = ($event) => handleActions("clockwise"))
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(refresh_right_default))
                        ]),
                        _: 1
                      })
                    ], 2)
                  ], 2),
                  createCommentVNode(" CANVAS "),
                  createBaseVNode("div", {
                    class: normalizeClass(unref(ns).e("canvas"))
                  }, [
                    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.urlList, (url, i) => {
                      return withDirectives((openBlock(), createElementBlock("img", {
                        ref_for: true,
                        ref: (el) => imgRefs.value[i] = el,
                        key: url,
                        src: url,
                        style: normalizeStyle(unref(imgStyle)),
                        class: normalizeClass(unref(ns).e("img")),
                        onLoad: handleImgLoad,
                        onError: handleImgError,
                        onMousedown: handleMouseDown
                      }, null, 46, _hoisted_1$x)), [
                        [vShow, i === activeIndex.value]
                      ]);
                    }), 128))
                  ], 2),
                  renderSlot(_ctx.$slots, "default")
                ], 6)
              ]),
              _: 3
            })
          ], 8, ["disabled"]);
        };
      }
    });
    var ImageViewer = /* @__PURE__ */ _export_sfc$1(_sfc_main$13, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/image-viewer/src/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
      },
      minScale: {
        type: Number,
        default: 0.2
      },
      maxScale: {
        type: Number,
        default: 7
      }
    });
    const imageEmits = {
      load: (evt) => evt instanceof Event,
      error: (evt) => evt instanceof Event,
      switch: (val) => isNumber(val),
      close: () => true,
      show: () => true
    };
    const _hoisted_1$w = ["src", "loading"];
    const _hoisted_2$k = { key: 0 };
    const __default__$J = /* @__PURE__ */ defineComponent({
      name: "ElImage",
      inheritAttrs: false
    });
    const _sfc_main$12 = /* @__PURE__ */ defineComponent({
      ...__default__$J,
      props: imageProps,
      emits: imageEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        let prevOverflow = "";
        const { t } = useLocale();
        const ns = useNamespace("image");
        const rawAttrs = useAttrs$1();
        const attrs = useAttrs();
        const imageSrc = ref();
        const hasLoadError = ref(false);
        const isLoading = ref(true);
        const showViewer = ref(false);
        const container = ref();
        const _scrollContainer = ref();
        const supportLoading = isClient && "loading" in HTMLImageElement.prototype;
        let stopScrollListener;
        let stopWheelListener;
        const imageKls = computed(() => [
          ns.e("inner"),
          preview.value && ns.e("preview"),
          isLoading.value && ns.is("loading")
        ]);
        const containerStyle = computed(() => rawAttrs.style);
        const imageStyle = computed(() => {
          const { fit } = props;
          if (isClient && fit) {
            return { objectFit: fit };
          }
          return {};
        });
        const preview = computed(() => {
          const { previewSrcList } = props;
          return Array.isArray(previewSrcList) && previewSrcList.length > 0;
        });
        const imageIndex = computed(() => {
          const { previewSrcList, initialIndex } = props;
          let previewIndex = initialIndex;
          if (initialIndex > previewSrcList.length - 1) {
            previewIndex = 0;
          }
          return previewIndex;
        });
        const isManual = 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;
          emit2("load", event);
        }
        function handleError2(event) {
          isLoading.value = false;
          hasLoadError.value = true;
          emit2("error", event);
        }
        function handleLazyLoad() {
          if (isInContainer(container.value, _scrollContainer.value)) {
            loadImage();
            removeLazyLoadListener();
          }
        }
        const lazyLoadHandler = useThrottleFn(handleLazyLoad, 200, true);
        async function addLazyLoadListener() {
          var _a2;
          if (!isClient)
            return;
          await nextTick();
          const { scrollContainer } = props;
          if (isElement$1(scrollContainer)) {
            _scrollContainer.value = scrollContainer;
          } else if (isString$1(scrollContainer) && scrollContainer !== "") {
            _scrollContainer.value = (_a2 = document.querySelector(scrollContainer)) != null ? _a2 : void 0;
          } else if (container.value) {
            _scrollContainer.value = getScrollContainer(container.value);
          }
          if (_scrollContainer.value) {
            stopScrollListener = useEventListener(_scrollContainer, "scroll", lazyLoadHandler);
            setTimeout(() => handleLazyLoad(), 100);
          }
        }
        function removeLazyLoadListener() {
          if (!isClient || !_scrollContainer.value || !lazyLoadHandler)
            return;
          stopScrollListener == null ? void 0 : stopScrollListener();
          _scrollContainer.value = void 0;
        }
        function wheelHandler(e) {
          if (!e.ctrlKey)
            return;
          if (e.deltaY < 0) {
            e.preventDefault();
            return false;
          } else if (e.deltaY > 0) {
            e.preventDefault();
            return false;
          }
        }
        function clickHandler() {
          if (!preview.value)
            return;
          stopWheelListener = useEventListener("wheel", wheelHandler, {
            passive: false
          });
          prevOverflow = document.body.style.overflow;
          document.body.style.overflow = "hidden";
          showViewer.value = true;
          emit2("show");
        }
        function closeViewer() {
          stopWheelListener == null ? void 0 : stopWheelListener();
          document.body.style.overflow = prevOverflow;
          showViewer.value = false;
          emit2("close");
        }
        function switchViewer(val) {
          emit2("switch", val);
        }
        watch(() => props.src, () => {
          if (isManual.value) {
            isLoading.value = true;
            hasLoadError.value = false;
            removeLazyLoadListener();
            addLazyLoadListener();
          } else {
            loadImage();
          }
        });
        onMounted(() => {
          if (isManual.value) {
            addLazyLoadListener();
          } else {
            loadImage();
          }
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "container",
            ref: container,
            class: normalizeClass([unref(ns).b(), _ctx.$attrs.class]),
            style: normalizeStyle(unref(containerStyle))
          }, [
            hasLoadError.value ? renderSlot(_ctx.$slots, "error", { key: 0 }, () => [
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).e("error"))
              }, toDisplayString(unref(t)("el.image.error")), 3)
            ]) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
              imageSrc.value !== void 0 ? (openBlock(), createElementBlock("img", mergeProps({ key: 0 }, unref(attrs), {
                src: imageSrc.value,
                loading: _ctx.loading,
                style: unref(imageStyle),
                class: unref(imageKls),
                onClick: clickHandler,
                onLoad: handleLoad,
                onError: handleError2
              }), null, 16, _hoisted_1$w)) : createCommentVNode("v-if", true),
              isLoading.value ? (openBlock(), createElementBlock("div", {
                key: 1,
                class: normalizeClass(unref(ns).e("wrapper"))
              }, [
                renderSlot(_ctx.$slots, "placeholder", {}, () => [
                  createBaseVNode("div", {
                    class: normalizeClass(unref(ns).e("placeholder"))
                  }, null, 2)
                ])
              ], 2)) : createCommentVNode("v-if", true)
            ], 64)),
            unref(preview) ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
              showViewer.value ? (openBlock(), createBlock(unref(ElImageViewer), {
                key: 0,
                "z-index": _ctx.zIndex,
                "initial-index": unref(imageIndex),
                infinite: _ctx.infinite,
                "zoom-rate": _ctx.zoomRate,
                "min-scale": _ctx.minScale,
                "max-scale": _ctx.maxScale,
                "url-list": _ctx.previewSrcList,
                "hide-on-click-modal": _ctx.hideOnClickModal,
                teleported: _ctx.previewTeleported,
                "close-on-press-escape": _ctx.closeOnPressEscape,
                onClose: closeViewer,
                onSwitch: switchViewer
              }, {
                default: withCtx(() => [
                  _ctx.$slots.viewer ? (openBlock(), createElementBlock("div", _hoisted_2$k, [
                    renderSlot(_ctx.$slots, "viewer")
                  ])) : createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 8, ["z-index", "initial-index", "infinite", "zoom-rate", "min-scale", "max-scale", "url-list", "hide-on-click-modal", "teleported", "close-on-press-escape"])) : createCommentVNode("v-if", true)
            ], 64)) : createCommentVNode("v-if", true)
          ], 6);
        };
      }
    });
    var Image$1 = /* @__PURE__ */ _export_sfc$1(_sfc_main$12, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/image/src/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.POSITIVE_INFINITY
      },
      min: {
        type: Number,
        default: Number.NEGATIVE_INFINITY
      },
      modelValue: Number,
      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,
      label: String,
      placeholder: String,
      precision: {
        type: Number,
        validator: (val) => val >= 0 && val === Number.parseInt(`${val}`, 10)
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    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 _hoisted_1$v = ["aria-label", "onKeydown"];
    const _hoisted_2$j = ["aria-label", "onKeydown"];
    const __default__$I = /* @__PURE__ */ defineComponent({
      name: "ElInputNumber"
    });
    const _sfc_main$11 = /* @__PURE__ */ defineComponent({
      ...__default__$I,
      props: inputNumberProps,
      emits: inputNumberEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("input-number");
        const input = ref();
        const data = reactive({
          currentValue: props.modelValue,
          userInput: null
        });
        const { formItem } = useFormItem();
        const minDisabled = computed(() => isNumber(props.modelValue) && props.modelValue <= props.min);
        const maxDisabled = computed(() => isNumber(props.modelValue) && props.modelValue >= props.max);
        const numPrecision = computed(() => {
          const stepPrecision = getPrecision(props.step);
          if (!isUndefined(props.precision)) {
            if (stepPrecision > props.precision)
              ;
            return props.precision;
          } else {
            return Math.max(getPrecision(props.modelValue), stepPrecision);
          }
        });
        const controlsAtRight = computed(() => {
          return props.controls && props.controlsPosition === "right";
        });
        const inputNumberSize = useFormSize();
        const inputNumberDisabled = useFormDisabled();
        const displayValue = 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;
          return toPrecision(val + props.step * coefficient);
        };
        const increase = () => {
          if (props.readonly || inputNumberDisabled.value || maxDisabled.value)
            return;
          const value = Number(displayValue.value) || 0;
          const newVal = ensurePrecision(value);
          setCurrentValue(newVal);
          emit2(INPUT_EVENT, data.currentValue);
        };
        const decrease = () => {
          if (props.readonly || inputNumberDisabled.value || minDisabled.value)
            return;
          const value = Number(displayValue.value) || 0;
          const newVal = ensurePrecision(value, -1);
          setCurrentValue(newVal);
          emit2(INPUT_EVENT, data.currentValue);
        };
        const verifyValue = (value, update) => {
          const { max: max2, min: min2, step, precision, stepStrictly, valueOnClear } = props;
          if (max2 < min2) {
            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: min2, max: max2 }[valueOnClear] : valueOnClear;
          }
          if (stepStrictly) {
            newVal = toPrecision(Math.round(newVal / step) * step, precision);
          }
          if (!isUndefined(precision)) {
            newVal = toPrecision(newVal, precision);
          }
          if (newVal > max2 || newVal < min2) {
            newVal = newVal > max2 ? max2 : min2;
            update && emit2(UPDATE_MODEL_EVENT, newVal);
          }
          return newVal;
        };
        const setCurrentValue = (value, emitChange = true) => {
          var _a2;
          const oldVal = data.currentValue;
          const newVal = verifyValue(value);
          if (!emitChange) {
            emit2(UPDATE_MODEL_EVENT, newVal);
            return;
          }
          if (oldVal === newVal)
            return;
          data.userInput = null;
          emit2(UPDATE_MODEL_EVENT, newVal);
          emit2(CHANGE_EVENT, newVal, oldVal);
          if (props.validateEvent) {
            (_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn());
          }
          data.currentValue = newVal;
        };
        const handleInput = (value) => {
          data.userInput = value;
          const newVal = value === "" ? null : Number(value);
          emit2(INPUT_EVENT, newVal);
          setCurrentValue(newVal, false);
        };
        const handleInputChange = (value) => {
          const newVal = value !== "" ? Number(value) : "";
          if (isNumber(newVal) && !Number.isNaN(newVal) || value === "") {
            setCurrentValue(newVal);
          }
          data.userInput = null;
        };
        const focus = () => {
          var _a2, _b;
          (_b = (_a2 = input.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
        };
        const blur = () => {
          var _a2, _b;
          (_b = (_a2 = input.value) == null ? void 0 : _a2.blur) == null ? void 0 : _b.call(_a2);
        };
        const handleFocus = (event) => {
          emit2("focus", event);
        };
        const handleBlur = (event) => {
          var _a2;
          emit2("blur", event);
          if (props.validateEvent) {
            (_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "blur").catch((err) => debugWarn());
          }
        };
        watch(() => props.modelValue, (value) => {
          const userInput = verifyValue(data.userInput);
          const newValue = verifyValue(value, true);
          if (!isNumber(userInput) && (!userInput || userInput !== newValue)) {
            data.currentValue = newValue;
            data.userInput = null;
          }
        }, { immediate: true });
        onMounted(() => {
          var _a2;
          const { min: min2, max: max2, modelValue } = props;
          const innerInput = (_a2 = input.value) == null ? void 0 : _a2.input;
          innerInput.setAttribute("role", "spinbutton");
          if (Number.isFinite(max2)) {
            innerInput.setAttribute("aria-valuemax", String(max2));
          } else {
            innerInput.removeAttribute("aria-valuemax");
          }
          if (Number.isFinite(min2)) {
            innerInput.setAttribute("aria-valuemin", String(min2));
          } 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;
            }
            emit2(UPDATE_MODEL_EVENT, val);
          }
        });
        onUpdated(() => {
          var _a2, _b;
          const innerInput = (_a2 = input.value) == null ? void 0 : _a2.input;
          innerInput == null ? void 0 : innerInput.setAttribute("aria-valuenow", `${(_b = data.currentValue) != null ? _b : ""}`);
        });
        expose({
          focus,
          blur
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([
              unref(ns).b(),
              unref(ns).m(unref(inputNumberSize)),
              unref(ns).is("disabled", unref(inputNumberDisabled)),
              unref(ns).is("without-controls", !_ctx.controls),
              unref(ns).is("controls-right", unref(controlsAtRight))
            ]),
            onDragstart: _cache[1] || (_cache[1] = withModifiers(() => {
            }, ["prevent"]))
          }, [
            _ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
              key: 0,
              role: "button",
              "aria-label": unref(t)("el.inputNumber.decrease"),
              class: normalizeClass([unref(ns).e("decrease"), unref(ns).is("disabled", unref(minDisabled))]),
              onKeydown: withKeys(decrease, ["enter"])
            }, [
              createVNode(unref(ElIcon), null, {
                default: withCtx(() => [
                  unref(controlsAtRight) ? (openBlock(), createBlock(unref(arrow_down_default), { key: 0 })) : (openBlock(), createBlock(unref(minus_default), { key: 1 }))
                ]),
                _: 1
              })
            ], 42, _hoisted_1$v)), [
              [unref(vRepeatClick), decrease]
            ]) : createCommentVNode("v-if", true),
            _ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
              key: 1,
              role: "button",
              "aria-label": unref(t)("el.inputNumber.increase"),
              class: normalizeClass([unref(ns).e("increase"), unref(ns).is("disabled", unref(maxDisabled))]),
              onKeydown: withKeys(increase, ["enter"])
            }, [
              createVNode(unref(ElIcon), null, {
                default: withCtx(() => [
                  unref(controlsAtRight) ? (openBlock(), createBlock(unref(arrow_up_default), { key: 0 })) : (openBlock(), createBlock(unref(plus_default), { key: 1 }))
                ]),
                _: 1
              })
            ], 42, _hoisted_2$j)), [
              [unref(vRepeatClick), increase]
            ]) : createCommentVNode("v-if", true),
            createVNode(unref(ElInput), {
              id: _ctx.id,
              ref_key: "input",
              ref: input,
              type: "number",
              step: _ctx.step,
              "model-value": unref(displayValue),
              placeholder: _ctx.placeholder,
              readonly: _ctx.readonly,
              disabled: unref(inputNumberDisabled),
              size: unref(inputNumberSize),
              max: _ctx.max,
              min: _ctx.min,
              name: _ctx.name,
              label: _ctx.label,
              "validate-event": false,
              onWheel: _cache[0] || (_cache[0] = withModifiers(() => {
              }, ["prevent"])),
              onKeydown: [
                withKeys(withModifiers(increase, ["prevent"]), ["up"]),
                withKeys(withModifiers(decrease, ["prevent"]), ["down"])
              ],
              onBlur: handleBlur,
              onFocus: handleFocus,
              onInput: handleInput,
              onChange: handleInputChange
            }, null, 8, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "label", "onKeydown"])
          ], 34);
        };
      }
    });
    var InputNumber = /* @__PURE__ */ _export_sfc$1(_sfc_main$11, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/input-number/src/input-number.vue"]]);
    const ElInputNumber = withInstall(InputNumber);
    const linkProps = buildProps({
      type: {
        type: String,
        values: ["primary", "success", "warning", "info", "danger", "default"],
        default: "default"
      },
      underline: {
        type: Boolean,
        default: true
      },
      disabled: { type: Boolean, default: false },
      href: { type: String, default: "" },
      icon: {
        type: iconPropType
      }
    });
    const linkEmits = {
      click: (evt) => evt instanceof MouseEvent
    };
    const _hoisted_1$u = ["href"];
    const __default__$H = /* @__PURE__ */ defineComponent({
      name: "ElLink"
    });
    const _sfc_main$10 = /* @__PURE__ */ defineComponent({
      ...__default__$H,
      props: linkProps,
      emits: linkEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("link");
        const linkKls = computed(() => [
          ns.b(),
          ns.m(props.type),
          ns.is("disabled", props.disabled),
          ns.is("underline", props.underline && !props.disabled)
        ]);
        function handleClick(event) {
          if (!props.disabled)
            emit2("click", event);
        }
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("a", {
            class: normalizeClass(unref(linkKls)),
            href: _ctx.disabled || !_ctx.href ? void 0 : _ctx.href,
            onClick: handleClick
          }, [
            _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
              default: withCtx(() => [
                (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
              ]),
              _: 1
            })) : createCommentVNode("v-if", true),
            _ctx.$slots.default ? (openBlock(), createElementBlock("span", {
              key: 1,
              class: normalizeClass(unref(ns).e("inner"))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2)) : createCommentVNode("v-if", true),
            _ctx.$slots.icon ? renderSlot(_ctx.$slots, "icon", { key: 2 }) : createCommentVNode("v-if", true)
          ], 10, _hoisted_1$u);
        };
      }
    });
    var Link = /* @__PURE__ */ _export_sfc$1(_sfc_main$10, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/link/src/link.vue"]]);
    const ElLink = withInstall(Link);
    let SubMenu$1 = class SubMenu {
      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) => {
            let prevDef = false;
            switch (event.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.space: {
                prevDef = true;
                event.currentTarget.click();
                break;
              }
            }
            if (prevDef) {
              event.preventDefault();
              event.stopPropagation();
            }
            return false;
          });
        });
      }
    };
    let MenuItem$1 = class MenuItem {
      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$1(this, menuChild);
        }
        this.addListeners();
      }
      addListeners() {
        this.domNode.addEventListener("keydown", (event) => {
          let prevDef = false;
          switch (event.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.space: {
              prevDef = true;
              event.currentTarget.click();
              break;
            }
          }
          if (prevDef) {
            event.preventDefault();
          }
        });
      }
    };
    let Menu$1 = class Menu {
      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$1(child, namespace);
          }
        });
      }
    };
    const _sfc_main$$ = /* @__PURE__ */ defineComponent({
      name: "ElMenuCollapseTransition",
      setup() {
        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 {
          listeners
        };
      }
    });
    function _sfc_render$e(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createBlock(Transition, mergeProps({ mode: "out-in" }, _ctx.listeners), {
        default: withCtx(() => [
          renderSlot(_ctx.$slots, "default")
        ]),
        _: 3
      }, 16);
    }
    var ElMenuCollapseTransition = /* @__PURE__ */ _export_sfc$1(_sfc_main$$, [["render", _sfc_render$e], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/menu/src/menu-collapse-transition.vue"]]);
    function useMenu(instance, currentIndex) {
      const indexPath = 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 = 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 = computed(() => {
        const color = props.backgroundColor;
        if (!color) {
          return "";
        } else {
          return new TinyColor(color).shade(20).toString();
        }
      });
      return menuBarColor;
    }
    const useMenuCssVar = (props, level) => {
      const ns = useNamespace("menu");
      return computed(() => {
        return 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 subMenuProps = buildProps({
      index: {
        type: String,
        required: true
      },
      showTimeout: {
        type: Number,
        default: 300
      },
      hideTimeout: {
        type: Number,
        default: 300
      },
      popperClass: String,
      disabled: Boolean,
      popperAppendToBody: {
        type: Boolean,
        default: void 0
      },
      teleported: {
        type: Boolean,
        default: void 0
      },
      popperOffset: {
        type: Number,
        default: 6
      },
      expandCloseIcon: {
        type: iconPropType
      },
      expandOpenIcon: {
        type: iconPropType
      },
      collapseCloseIcon: {
        type: iconPropType
      },
      collapseOpenIcon: {
        type: iconPropType
      }
    });
    const COMPONENT_NAME$c = "ElSubMenu";
    var SubMenu = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$c,
      props: subMenuProps,
      setup(props, { slots, expose }) {
        useDeprecated({
          from: "popper-append-to-body",
          replacement: "teleported",
          scope: COMPONENT_NAME$c,
          version: "2.3.0",
          ref: "https://element-plus.org/en-US/component/menu.html#submenu-attributes"
        }, computed(() => props.popperAppendToBody !== void 0));
        const instance = getCurrentInstance();
        const { indexPath, parentMenu } = useMenu(instance, computed(() => props.index));
        const nsMenu = useNamespace("menu");
        const nsSubMenu = useNamespace("sub-menu");
        const rootMenu = inject("rootMenu");
        if (!rootMenu)
          throwError(COMPONENT_NAME$c, "can not inject root menu");
        const subMenu = inject(`subMenu:${parentMenu.value.uid}`);
        if (!subMenu)
          throwError(COMPONENT_NAME$c, "can not inject sub menu");
        const items = ref({});
        const subMenus = ref({});
        let timeout;
        const mouseInChild = ref(false);
        const verticalTitleRef = ref();
        const vPopper = ref(null);
        const currentPlacement = computed(() => mode.value === "horizontal" && isFirstLevel.value ? "bottom-start" : "right-start");
        const subMenuTitleIcon = computed(() => {
          return mode.value === "horizontal" && isFirstLevel.value || mode.value === "vertical" && !rootMenu.props.collapse ? props.expandCloseIcon && props.expandOpenIcon ? opened.value ? props.expandOpenIcon : props.expandCloseIcon : arrow_down_default : props.collapseCloseIcon && props.collapseOpenIcon ? opened.value ? props.collapseOpenIcon : props.collapseCloseIcon : arrow_right_default;
        });
        const isFirstLevel = computed(() => {
          return subMenu.level === 0;
        });
        const appendToBody = computed(() => {
          var _a2;
          const value = (_a2 = props.teleported) != null ? _a2 : props.popperAppendToBody;
          return value === void 0 ? isFirstLevel.value : value;
        });
        const menuTransitionName = computed(() => rootMenu.props.collapse ? `${nsMenu.namespace.value}-zoom-in-left` : `${nsMenu.namespace.value}-zoom-in-top`);
        const fallbackPlacements = 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 = computed(() => rootMenu.openedMenus.includes(props.index));
        const active = computed(() => {
          let isActive = false;
          Object.values(items.value).forEach((item2) => {
            if (item2.active) {
              isActive = true;
            }
          });
          Object.values(subMenus.value).forEach((subItem) => {
            if (subItem.active) {
              isActive = true;
            }
          });
          return isActive;
        });
        const mode = computed(() => rootMenu.props.mode);
        const item = reactive({
          index: props.index,
          indexPath,
          active
        });
        const ulStyle = useMenuCssVar(rootMenu.props, subMenu.level + 1);
        const doDestroy = () => {
          var _a2, _b, _c;
          return (_c = (_b = (_a2 = vPopper.value) == null ? void 0 : _a2.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 = props.showTimeout) => {
          var _a2;
          if (event.type === "focus") {
            return;
          }
          if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical" || props.disabled) {
            return;
          }
          subMenu.mouseInChild.value = true;
          timeout == null ? void 0 : timeout();
          ({ stop: timeout } = useTimeoutFn(() => {
            rootMenu.openMenu(props.index, indexPath.value);
          }, showTimeout));
          if (appendToBody.value) {
            (_a2 = parentMenu.value.vnode.el) == null ? void 0 : _a2.dispatchEvent(new MouseEvent("mouseenter"));
          }
        };
        const handleMouseleave = (deepDispatch = false) => {
          var _a2, _b;
          if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical") {
            return;
          }
          timeout == null ? void 0 : timeout();
          subMenu.mouseInChild.value = false;
          ({ stop: timeout } = useTimeoutFn(() => !mouseInChild.value && rootMenu.closeMenu(props.index, indexPath.value), props.hideTimeout));
          if (appendToBody.value && deepDispatch) {
            if (((_a2 = instance.parent) == null ? void 0 : _a2.type.name) === "ElSubMenu") {
              (_b = subMenu.handleMouseleave) == null ? void 0 : _b.call(subMenu, true);
            }
          }
        };
        watch(() => rootMenu.props.collapse, (value) => handleCollapseToggle(Boolean(value)));
        {
          const addSubMenu = (item2) => {
            subMenus.value[item2.index] = item2;
          };
          const removeSubMenu = (item2) => {
            delete subMenus.value[item2.index];
          };
          provide(`subMenu:${instance.uid}`, {
            addSubMenu,
            removeSubMenu,
            handleMouseleave,
            mouseInChild,
            level: subMenu.level + 1
          });
        }
        expose({
          opened
        });
        onMounted(() => {
          rootMenu.addSubMenu(item);
          subMenu.addSubMenu(item);
        });
        onBeforeUnmount(() => {
          subMenu.removeSubMenu(item);
          rootMenu.removeSubMenu(item);
        });
        return () => {
          var _a2;
          const titleTag = [
            (_a2 = slots.title) == null ? void 0 : _a2.call(slots),
            h$1(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) ? h$1(instance.appContext.components[subMenuTitleIcon.value]) : h$1(subMenuTitleIcon.value)
            })
          ];
          const child = rootMenu.isMenuPopup ? h$1(ElTooltip, {
            ref: vPopper,
            visible: opened.value,
            effect: "light",
            pure: true,
            offset: props.popperOffset,
            showArrow: false,
            persistent: true,
            popperClass: props.popperClass,
            placement: currentPlacement.value,
            teleported: appendToBody.value,
            fallbackPlacements: fallbackPlacements.value,
            transition: menuTransitionName.value,
            gpuAcceleration: false
          }, {
            content: () => {
              var _a22;
              return h$1("div", {
                class: [
                  nsMenu.m(mode.value),
                  nsMenu.m("popup-container"),
                  props.popperClass
                ],
                onMouseenter: (evt) => handleMouseenter(evt, 100),
                onMouseleave: () => handleMouseleave(true),
                onFocus: (evt) => handleMouseenter(evt, 100)
              }, [
                h$1("ul", {
                  class: [
                    nsMenu.b(),
                    nsMenu.m("popup"),
                    nsMenu.m(`popup-${currentPlacement.value}`)
                  ],
                  style: ulStyle.value
                }, [(_a22 = slots.default) == null ? void 0 : _a22.call(slots)])
              ]);
            },
            default: () => h$1("div", {
              class: nsSubMenu.e("title"),
              onClick: handleClick
            }, titleTag)
          }) : h$1(Fragment, {}, [
            h$1("div", {
              class: nsSubMenu.e("title"),
              ref: verticalTitleRef,
              onClick: handleClick
            }, titleTag),
            h$1(_CollapseTransition, {}, {
              default: () => {
                var _a22;
                return withDirectives(h$1("ul", {
                  role: "menu",
                  class: [nsMenu.b(), nsMenu.m("inline")],
                  style: ulStyle.value
                }, [(_a22 = slots.default) == null ? void 0 : _a22.call(slots)]), [[vShow, opened.value]]);
              }
            })
          ]);
          return h$1("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(true),
            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,
      collapseTransition: {
        type: Boolean,
        default: true
      },
      ellipsis: {
        type: Boolean,
        default: true
      },
      popperEffect: {
        type: String,
        values: ["dark", "light"],
        default: "dark"
      }
    });
    const checkIndexPath = (indexPath) => Array.isArray(indexPath) && indexPath.every((path) => isString$1(path));
    const menuEmits = {
      close: (index2, indexPath) => isString$1(index2) && checkIndexPath(indexPath),
      open: (index2, indexPath) => isString$1(index2) && checkIndexPath(indexPath),
      select: (index2, indexPath, item, routerResult) => isString$1(index2) && checkIndexPath(indexPath) && isObject$1(item) && (routerResult === void 0 || routerResult instanceof Promise)
    };
    var Menu = /* @__PURE__ */ defineComponent({
      name: "ElMenu",
      props: menuProps,
      emits: menuEmits,
      setup(props, { emit: emit2, slots, expose }) {
        const instance = getCurrentInstance();
        const router2 = instance.appContext.config.globalProperties.$router;
        const menu = ref();
        const nsMenu = useNamespace("menu");
        const nsSubMenu = useNamespace("sub-menu");
        const sliceIndex = ref(-1);
        const openedMenus = ref(props.defaultOpeneds && !props.collapse ? props.defaultOpeneds.slice(0) : []);
        const activeIndex = ref(props.defaultActive);
        const items = ref({});
        const subMenus = ref({});
        const isMenuPopup = computed(() => {
          return 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((index2) => {
            const subMenu = subMenus.value[index2];
            subMenu && openMenu(index2, subMenu.indexPath);
          });
        };
        const openMenu = (index2, indexPath) => {
          if (openedMenus.value.includes(index2))
            return;
          if (props.uniqueOpened) {
            openedMenus.value = openedMenus.value.filter((index22) => indexPath.includes(index22));
          }
          openedMenus.value.push(index2);
          emit2("open", index2, indexPath);
        };
        const close2 = (index2) => {
          const i = openedMenus.value.indexOf(index2);
          if (i !== -1) {
            openedMenus.value.splice(i, 1);
          }
        };
        const closeMenu = (index2, indexPath) => {
          close2(index2);
          emit2("close", index2, indexPath);
        };
        const handleSubMenuClick = ({
          index: index2,
          indexPath
        }) => {
          const isOpened = openedMenus.value.includes(index2);
          if (isOpened) {
            closeMenu(index2, indexPath);
          } else {
            openMenu(index2, indexPath);
          }
        };
        const handleMenuItemClick = (menuItem) => {
          if (props.mode === "horizontal" || props.collapse) {
            openedMenus.value = [];
          }
          const { index: index2, indexPath } = menuItem;
          if (isNil(index2) || isNil(indexPath))
            return;
          if (props.router && router2) {
            const route = menuItem.route || index2;
            const routerResult = router2.push(route).then((res) => {
              if (!res)
                activeIndex.value = index2;
              return res;
            });
            emit2("select", index2, indexPath, { index: index2, indexPath, route }, routerResult);
          } else {
            activeIndex.value = index2;
            emit2("select", index2, indexPath, { index: index2, indexPath });
          }
        };
        const updateActiveIndex = (val) => {
          const itemsInData = items.value;
          const item = itemsInData[val] || activeIndex.value && itemsInData[activeIndex.value] || itemsInData[props.defaultActive];
          if (item) {
            activeIndex.value = item.index;
          } else {
            activeIndex.value = val;
          }
        };
        const calcSliceIndex = () => {
          var _a2, _b;
          if (!menu.value)
            return -1;
          const items2 = Array.from((_b = (_a2 = menu.value) == null ? void 0 : _a2.childNodes) != null ? _b : []).filter((item) => item.nodeName !== "#comment" && (item.nodeName !== "#text" || item.nodeValue));
          const moreItemWidth = 64;
          const paddingLeft = Number.parseInt(getComputedStyle(menu.value).paddingLeft, 10);
          const paddingRight = Number.parseInt(getComputedStyle(menu.value).paddingRight, 10);
          const menuWidth = menu.value.clientWidth - paddingLeft - paddingRight;
          let calcWidth = 0;
          let sliceIndex2 = 0;
          items2.forEach((item, index2) => {
            calcWidth += item.offsetWidth || 0;
            if (calcWidth <= menuWidth - moreItemWidth) {
              sliceIndex2 = index2 + 1;
            }
          });
          return sliceIndex2 === items2.length ? -1 : sliceIndex2;
        };
        const debounce2 = (fn2, wait = 33.34) => {
          let timmer;
          return () => {
            timmer && clearTimeout(timmer);
            timmer = setTimeout(() => {
              fn2();
            }, wait);
          };
        };
        let isFirstTimeRender = true;
        const handleResize = () => {
          const callback = () => {
            sliceIndex.value = -1;
            nextTick(() => {
              sliceIndex.value = calcSliceIndex();
            });
          };
          isFirstTimeRender ? callback() : debounce2(callback)();
          isFirstTimeRender = false;
        };
        watch(() => props.defaultActive, (currentActive) => {
          if (!items.value[currentActive]) {
            activeIndex.value = "";
          }
          updateActiveIndex(currentActive);
        });
        watch(() => props.collapse, (value) => {
          if (value)
            openedMenus.value = [];
        });
        watch(items.value, initMenu);
        let resizeStopper;
        watchEffect(() => {
          if (props.mode === "horizontal" && props.ellipsis)
            resizeStopper = useResizeObserver(menu, handleResize).stop;
          else
            resizeStopper == null ? void 0 : resizeStopper();
        });
        {
          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];
          };
          provide("rootMenu", reactive({
            props,
            openedMenus,
            items,
            subMenus,
            activeIndex,
            isMenuPopup,
            addMenuItem,
            removeMenuItem,
            addSubMenu,
            removeSubMenu,
            openMenu,
            closeMenu,
            handleMenuItemClick,
            handleSubMenuClick
          }));
          provide(`subMenu:${instance.uid}`, {
            addSubMenu,
            removeSubMenu,
            mouseInChild: ref(false),
            level: 0
          });
        }
        onMounted(() => {
          if (props.mode === "horizontal") {
            new Menu$1(instance.vnode.el, nsMenu.namespace.value);
          }
        });
        {
          const open = (index2) => {
            const { indexPath } = subMenus.value[index2];
            indexPath.forEach((i) => openMenu(i, indexPath));
          };
          expose({
            open,
            close: close2,
            handleResize
          });
        }
        return () => {
          var _a2, _b;
          let slot = (_b = (_a2 = slots.default) == null ? void 0 : _a2.call(slots)) != null ? _b : [];
          const vShowMore = [];
          if (props.mode === "horizontal" && menu.value) {
            const originalSlot = flattedChildren(slot);
            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(h$1(SubMenu, {
                index: "sub-menu-more",
                class: nsSubMenu.e("hide-arrow")
              }, {
                title: () => h$1(ElIcon, {
                  class: nsSubMenu.e("icon-more")
                }, { default: () => h$1(more_default) }),
                default: () => slotMore
              }));
            }
          }
          const ulStyle = useMenuCssVar(props, 0);
          const vMenu = h$1("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]);
          if (props.collapseTransition && props.mode === "vertical") {
            return h$1(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) && Array.isArray(item.indexPath)
    };
    const COMPONENT_NAME$b = "ElMenuItem";
    const _sfc_main$_ = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$b,
      components: {
        ElTooltip
      },
      props: menuItemProps,
      emits: menuItemEmits,
      setup(props, { emit: emit2 }) {
        const instance = getCurrentInstance();
        const rootMenu = inject("rootMenu");
        const nsMenu = useNamespace("menu");
        const nsMenuItem = useNamespace("menu-item");
        if (!rootMenu)
          throwError(COMPONENT_NAME$b, "can not inject root menu");
        const { parentMenu, indexPath } = useMenu(instance, toRef(props, "index"));
        const subMenu = inject(`subMenu:${parentMenu.value.uid}`);
        if (!subMenu)
          throwError(COMPONENT_NAME$b, "can not inject sub menu");
        const active = computed(() => props.index === rootMenu.activeIndex);
        const item = reactive({
          index: props.index,
          indexPath,
          active
        });
        const handleClick = () => {
          if (!props.disabled) {
            rootMenu.handleMenuItemClick({
              index: props.index,
              indexPath: indexPath.value,
              route: props.route
            });
            emit2("click", item);
          }
        };
        onMounted(() => {
          subMenu.addSubMenu(item);
          rootMenu.addMenuItem(item);
        });
        onBeforeUnmount(() => {
          subMenu.removeSubMenu(item);
          rootMenu.removeMenuItem(item);
        });
        return {
          parentMenu,
          rootMenu,
          active,
          nsMenu,
          nsMenuItem,
          handleClick
        };
      }
    });
    function _sfc_render$d(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_tooltip = resolveComponent("el-tooltip");
      return openBlock(), createElementBlock("li", {
        class: normalizeClass([
          _ctx.nsMenuItem.b(),
          _ctx.nsMenuItem.is("active", _ctx.active),
          _ctx.nsMenuItem.is("disabled", _ctx.disabled)
        ]),
        role: "menuitem",
        tabindex: "-1",
        onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
      }, [
        _ctx.parentMenu.type.name === "ElMenu" && _ctx.rootMenu.props.collapse && _ctx.$slots.title ? (openBlock(), createBlock(_component_el_tooltip, {
          key: 0,
          effect: _ctx.rootMenu.props.popperEffect,
          placement: "right",
          "fallback-placements": ["left"],
          persistent: ""
        }, {
          content: withCtx(() => [
            renderSlot(_ctx.$slots, "title")
          ]),
          default: withCtx(() => [
            createBaseVNode("div", {
              class: normalizeClass(_ctx.nsMenu.be("tooltip", "trigger"))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2)
          ]),
          _: 3
        }, 8, ["effect"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
          renderSlot(_ctx.$slots, "default"),
          renderSlot(_ctx.$slots, "title")
        ], 64))
      ], 2);
    }
    var MenuItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$_, [["render", _sfc_render$d], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/menu/src/menu-item.vue"]]);
    const menuItemGroupProps = {
      title: String
    };
    const COMPONENT_NAME$a = "ElMenuItemGroup";
    const _sfc_main$Z = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$a,
      props: menuItemGroupProps,
      setup() {
        const ns = useNamespace("menu-item-group");
        return {
          ns
        };
      }
    });
    function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createElementBlock("li", {
        class: normalizeClass(_ctx.ns.b())
      }, [
        createBaseVNode("div", {
          class: normalizeClass(_ctx.ns.e("title"))
        }, [
          !_ctx.$slots.title ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
            createTextVNode(toDisplayString(_ctx.title), 1)
          ], 64)) : renderSlot(_ctx.$slots, "title", { key: 1 })
        ], 2),
        createBaseVNode("ul", null, [
          renderSlot(_ctx.$slots, "default")
        ])
      ], 2);
    }
    var MenuItemGroup = /* @__PURE__ */ _export_sfc$1(_sfc_main$Z, [["render", _sfc_render$c], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/menu/src/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 _hoisted_1$t = ["aria-label"];
    const __default__$G = /* @__PURE__ */ defineComponent({
      name: "ElPageHeader"
    });
    const _sfc_main$Y = /* @__PURE__ */ defineComponent({
      ...__default__$G,
      props: pageHeaderProps,
      emits: pageHeaderEmits,
      setup(__props, { emit: emit2 }) {
        const slots = useSlots();
        const { t } = useLocale();
        const ns = useNamespace("page-header");
        const kls = computed(() => {
          return [
            ns.b(),
            {
              [ns.m("has-breadcrumb")]: !!slots.breadcrumb,
              [ns.m("has-extra")]: !!slots.extra,
              [ns.is("contentful")]: !!slots.default
            }
          ];
        });
        function handleClick() {
          emit2("back");
        }
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(kls))
          }, [
            _ctx.$slots.breadcrumb ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("breadcrumb"))
            }, [
              renderSlot(_ctx.$slots, "breadcrumb")
            ], 2)) : createCommentVNode("v-if", true),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("header"))
            }, [
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).e("left"))
              }, [
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("back")),
                  role: "button",
                  tabindex: "0",
                  onClick: handleClick
                }, [
                  _ctx.icon || _ctx.$slots.icon ? (openBlock(), createElementBlock("div", {
                    key: 0,
                    "aria-label": _ctx.title || unref(t)("el.pageHeader.title"),
                    class: normalizeClass(unref(ns).e("icon"))
                  }, [
                    renderSlot(_ctx.$slots, "icon", {}, () => [
                      _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
                        default: withCtx(() => [
                          (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
                        ]),
                        _: 1
                      })) : createCommentVNode("v-if", true)
                    ])
                  ], 10, _hoisted_1$t)) : createCommentVNode("v-if", true),
                  createBaseVNode("div", {
                    class: normalizeClass(unref(ns).e("title"))
                  }, [
                    renderSlot(_ctx.$slots, "title", {}, () => [
                      createTextVNode(toDisplayString(_ctx.title || unref(t)("el.pageHeader.title")), 1)
                    ])
                  ], 2)
                ], 2),
                createVNode(unref(ElDivider), { direction: "vertical" }),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("content"))
                }, [
                  renderSlot(_ctx.$slots, "content", {}, () => [
                    createTextVNode(toDisplayString(_ctx.content), 1)
                  ])
                ], 2)
              ], 2),
              _ctx.$slots.extra ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ns).e("extra"))
              }, [
                renderSlot(_ctx.$slots, "extra")
              ], 2)) : createCommentVNode("v-if", true)
            ], 2),
            _ctx.$slots.default ? (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(unref(ns).e("main"))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var PageHeader = /* @__PURE__ */ _export_sfc$1(_sfc_main$Y, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/page-header/src/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 _hoisted_1$s = ["disabled", "aria-label", "aria-disabled"];
    const _hoisted_2$i = { key: 0 };
    const __default__$F = /* @__PURE__ */ defineComponent({
      name: "ElPaginationPrev"
    });
    const _sfc_main$X = /* @__PURE__ */ defineComponent({
      ...__default__$F,
      props: paginationPrevProps,
      emits: paginationPrevEmits,
      setup(__props) {
        const props = __props;
        const { t } = useLocale();
        const internalDisabled = computed(() => props.disabled || props.currentPage <= 1);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("button", {
            type: "button",
            class: "btn-prev",
            disabled: unref(internalDisabled),
            "aria-label": _ctx.prevText || unref(t)("el.pagination.prev"),
            "aria-disabled": unref(internalDisabled),
            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
          }, [
            _ctx.prevText ? (openBlock(), createElementBlock("span", _hoisted_2$i, toDisplayString(_ctx.prevText), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
              default: withCtx(() => [
                (openBlock(), createBlock(resolveDynamicComponent(_ctx.prevIcon)))
              ]),
              _: 1
            }))
          ], 8, _hoisted_1$s);
        };
      }
    });
    var Prev = /* @__PURE__ */ _export_sfc$1(_sfc_main$X, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/pagination/src/components/prev.vue"]]);
    const paginationNextProps = buildProps({
      disabled: Boolean,
      currentPage: {
        type: Number,
        default: 1
      },
      pageCount: {
        type: Number,
        default: 50
      },
      nextText: {
        type: String
      },
      nextIcon: {
        type: iconPropType
      }
    });
    const _hoisted_1$r = ["disabled", "aria-label", "aria-disabled"];
    const _hoisted_2$h = { key: 0 };
    const __default__$E = /* @__PURE__ */ defineComponent({
      name: "ElPaginationNext"
    });
    const _sfc_main$W = /* @__PURE__ */ defineComponent({
      ...__default__$E,
      props: paginationNextProps,
      emits: ["click"],
      setup(__props) {
        const props = __props;
        const { t } = useLocale();
        const internalDisabled = computed(() => props.disabled || props.currentPage === props.pageCount || props.pageCount === 0);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("button", {
            type: "button",
            class: "btn-next",
            disabled: unref(internalDisabled),
            "aria-label": _ctx.nextText || unref(t)("el.pagination.next"),
            "aria-disabled": unref(internalDisabled),
            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
          }, [
            _ctx.nextText ? (openBlock(), createElementBlock("span", _hoisted_2$h, toDisplayString(_ctx.nextText), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
              default: withCtx(() => [
                (openBlock(), createBlock(resolveDynamicComponent(_ctx.nextIcon)))
              ]),
              _: 1
            }))
          ], 8, _hoisted_1$r);
        };
      }
    });
    var Next = /* @__PURE__ */ _export_sfc$1(_sfc_main$W, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/pagination/src/components/next.vue"]]);
    const selectGroupKey = Symbol("ElSelectGroup");
    const selectKey = Symbol("ElSelect");
    function useOption$1(props, states) {
      const select = inject(selectKey);
      const selectGroup = inject(selectGroupKey, { disabled: false });
      const isObject$1$1 = computed(() => isObject$1(props.value));
      const itemSelected = computed(() => {
        if (!select.props.multiple) {
          return isEqual2(props.value, select.props.modelValue);
        } else {
          return contains(select.props.modelValue, props.value);
        }
      });
      const limitReached = computed(() => {
        if (select.props.multiple) {
          const modelValue = select.props.modelValue || [];
          return !itemSelected.value && modelValue.length >= select.props.multipleLimit && select.props.multipleLimit > 0;
        } else {
          return false;
        }
      });
      const currentLabel = computed(() => {
        return props.label || (isObject$1$1.value ? "" : props.value);
      });
      const currentValue = computed(() => {
        return props.value || props.label || "";
      });
      const isDisabled = computed(() => {
        return props.disabled || states.groupDisabled || limitReached.value;
      });
      const instance = getCurrentInstance();
      const contains = (arr = [], target) => {
        if (!isObject$1$1.value) {
          return arr && arr.includes(target);
        } else {
          const valueKey = select.props.valueKey;
          return arr && arr.some((item) => {
            return toRaw(get(item, valueKey)) === get(target, valueKey);
          });
        }
      };
      const isEqual2 = (a2, b2) => {
        if (!isObject$1$1.value) {
          return a2 === b2;
        } else {
          const { valueKey } = select.props;
          return get(a2, valueKey) === get(b2, valueKey);
        }
      };
      const hoverItem = () => {
        if (!props.disabled && !selectGroup.disabled) {
          select.hoverIndex = select.optionsArray.indexOf(instance.proxy);
        }
      };
      watch(() => currentLabel.value, () => {
        if (!props.created && !select.props.remote)
          select.setSelected();
      });
      watch(() => props.value, (val, oldVal) => {
        const { remote, valueKey } = select.props;
        if (!Object.is(val, oldVal)) {
          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();
        }
      });
      watch(() => selectGroup.disabled, () => {
        states.groupDisabled = selectGroup.disabled;
      }, { immediate: true });
      const { queryChange } = toRaw(select);
      watch(queryChange, (changes) => {
        const { query } = unref(changes);
        const regexp2 = new RegExp(escapeStringRegexp(query), "i");
        states.visible = regexp2.test(currentLabel.value) || props.created;
        if (!states.visible) {
          select.filteredOptionsCount--;
        }
      }, { immediate: true });
      return {
        select,
        currentLabel,
        currentValue,
        itemSelected,
        isDisabled,
        hoverItem
      };
    }
    const _sfc_main$V = /* @__PURE__ */ defineComponent({
      name: "ElOption",
      componentName: "ElOption",
      props: {
        value: {
          required: true,
          type: [String, Number, Boolean, Object]
        },
        label: [String, Number],
        created: Boolean,
        disabled: Boolean
      },
      setup(props) {
        const ns = useNamespace("select");
        const id = useId();
        const containerKls = computed(() => [
          ns.be("dropdown", "item"),
          ns.is("disabled", unref(isDisabled)),
          {
            selected: unref(itemSelected),
            hover: unref(hover)
          }
        ]);
        const states = reactive({
          index: -1,
          groupDisabled: false,
          visible: true,
          hitState: false,
          hover: false
        });
        const { currentLabel, itemSelected, isDisabled, select, hoverItem } = useOption$1(props, states);
        const { visible, hover } = toRefs(states);
        const vm = getCurrentInstance().proxy;
        select.onOptionCreate(vm);
        onBeforeUnmount(() => {
          const key = vm.value;
          const { selected } = select;
          const selectedOptions = select.props.multiple ? selected : [selected];
          const doesSelected = selectedOptions.some((item) => {
            return item.value === vm.value;
          });
          nextTick(() => {
            if (select.cachedOptions.get(key) === vm && !doesSelected) {
              select.cachedOptions.delete(key);
            }
          });
          select.onOptionDestroy(key, vm);
        });
        function selectOptionClick() {
          if (props.disabled !== true && states.groupDisabled !== true) {
            select.handleOptionSelect(vm);
          }
        }
        return {
          ns,
          id,
          containerKls,
          currentLabel,
          itemSelected,
          isDisabled,
          select,
          hoverItem,
          visible,
          hover,
          selectOptionClick,
          states
        };
      }
    });
    const _hoisted_1$q = ["id", "aria-disabled", "aria-selected"];
    function _sfc_render$b(_ctx, _cache, $props, $setup, $data, $options) {
      return withDirectives((openBlock(), createElementBlock("li", {
        id: _ctx.id,
        class: normalizeClass(_ctx.containerKls),
        role: "option",
        "aria-disabled": _ctx.isDisabled || void 0,
        "aria-selected": _ctx.itemSelected,
        onMouseenter: _cache[0] || (_cache[0] = (...args) => _ctx.hoverItem && _ctx.hoverItem(...args)),
        onClick: _cache[1] || (_cache[1] = withModifiers((...args) => _ctx.selectOptionClick && _ctx.selectOptionClick(...args), ["stop"]))
      }, [
        renderSlot(_ctx.$slots, "default", {}, () => [
          createBaseVNode("span", null, toDisplayString(_ctx.currentLabel), 1)
        ])
      ], 42, _hoisted_1$q)), [
        [vShow, _ctx.visible]
      ]);
    }
    var Option = /* @__PURE__ */ _export_sfc$1(_sfc_main$V, [["render", _sfc_render$b], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/select/src/option.vue"]]);
    const _sfc_main$U = /* @__PURE__ */ defineComponent({
      name: "ElSelectDropdown",
      componentName: "ElSelectDropdown",
      setup() {
        const select = inject(selectKey);
        const ns = useNamespace("select");
        const popperClass = computed(() => select.props.popperClass);
        const isMultiple = computed(() => select.props.multiple);
        const isFitInputWidth = computed(() => select.props.fitInputWidth);
        const minWidth = ref("");
        function updateMinWidth() {
          var _a2;
          minWidth.value = `${(_a2 = select.selectWrapper) == null ? void 0 : _a2.offsetWidth}px`;
        }
        onMounted(() => {
          updateMinWidth();
          useResizeObserver(select.selectWrapper, updateMinWidth);
        });
        return {
          ns,
          minWidth,
          popperClass,
          isMultiple,
          isFitInputWidth
        };
      }
    });
    function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createElementBlock("div", {
        class: normalizeClass([_ctx.ns.b("dropdown"), _ctx.ns.is("multiple", _ctx.isMultiple), _ctx.popperClass]),
        style: normalizeStyle({ [_ctx.isFitInputWidth ? "width" : "minWidth"]: _ctx.minWidth })
      }, [
        _ctx.$slots.header ? (openBlock(), createElementBlock("div", {
          key: 0,
          class: normalizeClass(_ctx.ns.be("dropdown", "header"))
        }, [
          renderSlot(_ctx.$slots, "header")
        ], 2)) : createCommentVNode("v-if", true),
        renderSlot(_ctx.$slots, "default"),
        _ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
          key: 1,
          class: normalizeClass(_ctx.ns.be("dropdown", "footer"))
        }, [
          renderSlot(_ctx.$slots, "footer")
        ], 2)) : createCommentVNode("v-if", true)
      ], 6);
    }
    var ElSelectMenu$1 = /* @__PURE__ */ _export_sfc$1(_sfc_main$U, [["render", _sfc_render$a], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/select/src/select-dropdown.vue"]]);
    function useSelectStates(props) {
      const { t } = useLocale();
      return reactive({
        options: /* @__PURE__ */ new Map(),
        cachedOptions: /* @__PURE__ */ new Map(),
        disabledOptions: /* @__PURE__ */ new Map(),
        createdLabel: null,
        createdSelected: false,
        selected: props.multiple ? [] : {},
        inputLength: 20,
        inputWidth: 0,
        optionsCount: 0,
        filteredOptionsCount: 0,
        visible: false,
        selectedLabel: "",
        hoverIndex: -1,
        query: "",
        previousQuery: null,
        inputHovering: false,
        cachedPlaceHolder: "",
        currentPlaceholder: t("el.select.placeholder"),
        menuVisibleOnFocus: false,
        isOnComposition: false,
        prefixWidth: 11,
        mouseEnter: false,
        focused: false
      });
    }
    const useSelect$2 = (props, states, ctx) => {
      const { t } = useLocale();
      const ns = useNamespace("select");
      useDeprecated({
        from: "suffixTransition",
        replacement: "override style scheme",
        version: "2.3.0",
        scope: "props",
        ref: "https://element-plus.org/en-US/component/select.html#select-attributes"
      }, computed(() => props.suffixTransition === false));
      const reference = ref(null);
      const input = ref(null);
      const iOSInput = ref(null);
      const tooltipRef = ref(null);
      const tagTooltipRef = ref(null);
      const tags = ref(null);
      const selectWrapper = ref(null);
      const scrollbar = ref(null);
      const hoverOption = ref();
      const queryChange = shallowRef({ query: "" });
      const groupQueryChange = shallowRef("");
      const optionList = ref([]);
      let originClientHeight = 0;
      const { form, formItem } = useFormItem();
      const readonly2 = computed(() => !props.filterable || props.multiple || !states.visible);
      const selectDisabled = computed(() => props.disabled || (form == null ? void 0 : form.disabled));
      const showClose = computed(() => {
        const hasValue = props.multiple ? Array.isArray(props.modelValue) && props.modelValue.length > 0 : props.modelValue !== void 0 && props.modelValue !== null && props.modelValue !== "";
        const criteria = props.clearable && !selectDisabled.value && states.inputHovering && hasValue;
        return criteria;
      });
      const iconComponent = computed(() => props.remote && props.filterable && !props.remoteShowSuffix ? "" : props.suffixIcon);
      const iconReverse = computed(() => ns.is("reverse", iconComponent.value && states.visible && props.suffixTransition));
      const showStatusIconAndState = computed(() => (form == null ? void 0 : form.statusIcon) && (formItem == null ? void 0 : formItem.validateState) && ValidateComponentsMap[formItem == null ? void 0 : formItem.validateState]);
      const debounce$1 = computed(() => props.remote ? 300 : 0);
      const emptyText = computed(() => {
        if (props.loading) {
          return props.loadingText || t("el.select.loading");
        } else {
          if (props.remote && states.query === "" && states.options.size === 0)
            return false;
          if (props.filterable && states.query && states.options.size > 0 && states.filteredOptionsCount === 0) {
            return props.noMatchText || t("el.select.noMatch");
          }
          if (states.options.size === 0) {
            return props.noDataText || t("el.select.noData");
          }
        }
        return null;
      });
      const optionsArray = computed(() => {
        const list = Array.from(states.options.values());
        const newList = [];
        optionList.value.forEach((item) => {
          const index2 = list.findIndex((i) => i.currentLabel === item);
          if (index2 > -1) {
            newList.push(list[index2]);
          }
        });
        return newList.length >= list.length ? newList : list;
      });
      const cachedOptionsArray = computed(() => Array.from(states.cachedOptions.values()));
      const showNewOption = computed(() => {
        const hasExistingOption = optionsArray.value.filter((option) => {
          return !option.created;
        }).some((option) => {
          return option.currentLabel === states.query;
        });
        return props.filterable && props.allowCreate && states.query !== "" && !hasExistingOption;
      });
      const selectSize = useFormSize();
      const collapseTagSize = computed(() => ["small"].includes(selectSize.value) ? "small" : "default");
      const dropMenuVisible = computed({
        get() {
          return states.visible && emptyText.value !== false;
        },
        set(val) {
          states.visible = val;
        }
      });
      watch([() => selectDisabled.value, () => selectSize.value, () => form == null ? void 0 : form.size], () => {
        nextTick(() => {
          resetInputHeight();
        });
      });
      watch(() => props.placeholder, (val) => {
        states.cachedPlaceHolder = states.currentPlaceholder = val;
        const hasValue = props.multiple && Array.isArray(props.modelValue) && props.modelValue.length > 0;
        if (hasValue) {
          states.currentPlaceholder = "";
        }
      });
      watch(() => props.modelValue, (val, oldVal) => {
        if (props.multiple) {
          resetInputHeight();
          if (val && val.length > 0 || input.value && states.query !== "") {
            states.currentPlaceholder = "";
          } else {
            states.currentPlaceholder = states.cachedPlaceHolder;
          }
          if (props.filterable && !props.reserveKeyword) {
            states.query = "";
            handleQueryChange(states.query);
          }
        }
        setSelected();
        if (props.filterable && !props.multiple) {
          states.inputLength = 20;
        }
        if (!isEqual$1(val, oldVal) && props.validateEvent) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
        }
      }, {
        flush: "post",
        deep: true
      });
      watch(() => states.visible, (val) => {
        var _a2, _b, _c, _d, _e;
        if (!val) {
          if (props.filterable) {
            if (isFunction$2(props.filterMethod)) {
              props.filterMethod("");
            }
            if (isFunction$2(props.remoteMethod)) {
              props.remoteMethod("");
            }
          }
          states.query = "";
          states.previousQuery = null;
          states.selectedLabel = "";
          states.inputLength = 20;
          states.menuVisibleOnFocus = false;
          resetHoverIndex();
          nextTick(() => {
            if (input.value && input.value.value === "" && states.selected.length === 0) {
              states.currentPlaceholder = states.cachedPlaceHolder;
            }
          });
          if (!props.multiple) {
            if (states.selected) {
              if (props.filterable && props.allowCreate && states.createdSelected && states.createdLabel) {
                states.selectedLabel = states.createdLabel;
              } else {
                states.selectedLabel = states.selected.currentLabel;
              }
              if (props.filterable)
                states.query = states.selectedLabel;
            }
            if (props.filterable) {
              states.currentPlaceholder = states.cachedPlaceHolder;
            }
          }
        } else {
          (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
          if (props.filterable) {
            states.filteredOptionsCount = states.optionsCount;
            states.query = props.remote ? "" : states.selectedLabel;
            (_d = (_c = iOSInput.value) == null ? void 0 : _c.focus) == null ? void 0 : _d.call(_c);
            if (props.multiple) {
              (_e = input.value) == null ? void 0 : _e.focus();
            } else {
              if (states.selectedLabel) {
                states.currentPlaceholder = `${states.selectedLabel}`;
                states.selectedLabel = "";
              }
            }
            handleQueryChange(states.query);
            if (!props.multiple && !props.remote) {
              queryChange.value.query = "";
              triggerRef(queryChange);
              triggerRef(groupQueryChange);
            }
          }
        }
        ctx.emit("visible-change", val);
      });
      watch(() => states.options.entries(), () => {
        var _a2, _b, _c;
        if (!isClient)
          return;
        (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
        if (props.multiple) {
          resetInputHeight();
        }
        const inputs = ((_c = selectWrapper.value) == null ? void 0 : _c.querySelectorAll("input")) || [];
        if (!props.filterable && !props.defaultFirstOption && !isUndefined(props.modelValue) || !Array.from(inputs).includes(document.activeElement)) {
          setSelected();
        }
        if (props.defaultFirstOption && (props.filterable || props.remote) && states.filteredOptionsCount) {
          checkDefaultFirstOption();
        }
      }, {
        flush: "post"
      });
      watch(() => states.hoverIndex, (val) => {
        if (isNumber(val) && val > -1) {
          hoverOption.value = optionsArray.value[val] || {};
        } else {
          hoverOption.value = {};
        }
        optionsArray.value.forEach((option) => {
          option.hover = hoverOption.value === option;
        });
      });
      const resetInputHeight = () => {
        nextTick(() => {
          var _a2, _b;
          if (!reference.value)
            return;
          const input2 = reference.value.$el.querySelector("input");
          originClientHeight = originClientHeight || (input2.clientHeight > 0 ? input2.clientHeight + 2 : 0);
          const _tags = tags.value;
          const cssVarOfSelectSize = getComputedStyle(input2).getPropertyValue(ns.cssVarName("input-height"));
          const gotSize = Number.parseFloat(cssVarOfSelectSize) || getComponentSize(selectSize.value || (form == null ? void 0 : form.size));
          const sizeInMap = selectSize.value || gotSize === originClientHeight || originClientHeight <= 0 ? gotSize : originClientHeight;
          const isElHidden = input2.offsetParent === null;
          !isElHidden && (input2.style.height = `${(states.selected.length === 0 ? sizeInMap : Math.max(_tags ? _tags.clientHeight + (_tags.clientHeight > sizeInMap ? 6 : 0) : 0, sizeInMap)) - 2}px`);
          if (states.visible && emptyText.value !== false) {
            (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
          }
        });
      };
      const handleQueryChange = async (val) => {
        if (states.previousQuery === val || states.isOnComposition)
          return;
        if (states.previousQuery === null && (isFunction$2(props.filterMethod) || isFunction$2(props.remoteMethod))) {
          states.previousQuery = val;
          return;
        }
        states.previousQuery = val;
        nextTick(() => {
          var _a2, _b;
          if (states.visible)
            (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
        });
        states.hoverIndex = -1;
        if (props.multiple && props.filterable) {
          nextTick(() => {
            if (!selectDisabled.value) {
              const length = input.value.value.length * 15 + 20;
              states.inputLength = props.collapseTags ? Math.min(50, length) : length;
              managePlaceholder();
            }
            resetInputHeight();
          });
        }
        if (props.remote && isFunction$2(props.remoteMethod)) {
          states.hoverIndex = -1;
          props.remoteMethod(val);
        } else if (isFunction$2(props.filterMethod)) {
          props.filterMethod(val);
          triggerRef(groupQueryChange);
        } else {
          states.filteredOptionsCount = states.optionsCount;
          queryChange.value.query = val;
          triggerRef(queryChange);
          triggerRef(groupQueryChange);
        }
        if (props.defaultFirstOption && (props.filterable || props.remote) && states.filteredOptionsCount) {
          await nextTick();
          checkDefaultFirstOption();
        }
      };
      const managePlaceholder = () => {
        if (states.currentPlaceholder !== "") {
          states.currentPlaceholder = input.value.value ? "" : states.cachedPlaceHolder;
        }
      };
      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];
        states.hoverIndex = getValueIndex(optionsArray.value, userCreatedOption || firstOriginOption);
      };
      const setSelected = () => {
        var _a2;
        if (!props.multiple) {
          const option = getOption(props.modelValue);
          if ((_a2 = option.props) == null ? void 0 : _a2.created) {
            states.createdLabel = option.props.value;
            states.createdSelected = true;
          } else {
            states.createdSelected = false;
          }
          states.selectedLabel = option.currentLabel;
          states.selected = option;
          if (props.filterable)
            states.query = states.selectedLabel;
          return;
        } else {
          states.selectedLabel = "";
        }
        const result = [];
        if (Array.isArray(props.modelValue)) {
          props.modelValue.forEach((value) => {
            result.push(getOption(value));
          });
        }
        states.selected = result;
        nextTick(() => {
          resetInputHeight();
        });
      };
      const getOption = (value) => {
        let option;
        const isObjectValue = toRawType(value).toLowerCase() === "object";
        const isNull = toRawType(value).toLowerCase() === "null";
        const isUndefined2 = toRawType(value).toLowerCase() === "undefined";
        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 = {
              value,
              currentLabel: cachedOption.currentLabel,
              isDisabled: cachedOption.isDisabled
            };
            break;
          }
        }
        if (option)
          return option;
        const label = isObjectValue ? value.label : !isNull && !isUndefined2 ? value : "";
        const newOption = {
          value,
          currentLabel: label
        };
        if (props.multiple) {
          newOption.hitState = false;
        }
        return newOption;
      };
      const resetHoverIndex = () => {
        setTimeout(() => {
          const valueKey = props.valueKey;
          if (!props.multiple) {
            states.hoverIndex = optionsArray.value.findIndex((item) => {
              return getValueKey(item) === getValueKey(states.selected);
            });
          } else {
            if (states.selected.length > 0) {
              states.hoverIndex = Math.min.apply(null, states.selected.map((selected) => {
                return optionsArray.value.findIndex((item) => {
                  return get(item, valueKey) === get(selected, valueKey);
                });
              }));
            } else {
              states.hoverIndex = -1;
            }
          }
        }, 300);
      };
      const handleResize = () => {
        var _a2, _b;
        resetInputWidth();
        (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
        props.multiple && resetInputHeight();
      };
      const resetInputWidth = () => {
        var _a2;
        states.inputWidth = (_a2 = reference.value) == null ? void 0 : _a2.$el.offsetWidth;
      };
      const onInputChange = () => {
        if (props.filterable && states.query !== states.selectedLabel) {
          states.query = states.selectedLabel;
          handleQueryChange(states.query);
        }
      };
      const debouncedOnInputChange = debounce(() => {
        onInputChange();
      }, debounce$1.value);
      const debouncedQueryChange = debounce((e) => {
        handleQueryChange(e.target.value);
      }, debounce$1.value);
      const emitChange = (val) => {
        if (!isEqual$1(props.modelValue, val)) {
          ctx.emit(CHANGE_EVENT, val);
        }
      };
      const getLastNotDisabledIndex = (value) => findLastIndex(value, (it2) => !states.disabledOptions.has(it2));
      const deletePrevTag = (e) => {
        if (e.code === EVENT_CODE.delete)
          return;
        if (e.target.value.length <= 0 && !toggleLastOptionHitState()) {
          const value = props.modelValue.slice();
          const lastNotDisabledIndex = getLastNotDisabledIndex(value);
          if (lastNotDisabledIndex < 0)
            return;
          value.splice(lastNotDisabledIndex, 1);
          ctx.emit(UPDATE_MODEL_EVENT, value);
          emitChange(value);
        }
        if (e.target.value.length === 1 && props.modelValue.length === 0) {
          states.currentPlaceholder = states.cachedPlaceHolder;
        }
      };
      const deleteTag = (event, tag) => {
        const index2 = states.selected.indexOf(tag);
        if (index2 > -1 && !selectDisabled.value) {
          const value = props.modelValue.slice();
          value.splice(index2, 1);
          ctx.emit(UPDATE_MODEL_EVENT, value);
          emitChange(value);
          ctx.emit("remove-tag", tag.value);
        }
        event.stopPropagation();
        focus();
      };
      const deleteSelected = (event) => {
        event.stopPropagation();
        const value = props.multiple ? [] : "";
        if (!isString$1(value)) {
          for (const item of states.selected) {
            if (item.isDisabled)
              value.push(item.value);
          }
        }
        ctx.emit(UPDATE_MODEL_EVENT, value);
        emitChange(value);
        states.hoverIndex = -1;
        states.visible = false;
        ctx.emit("clear");
        focus();
      };
      const handleOptionSelect = (option) => {
        var _a2;
        if (props.multiple) {
          const value = (props.modelValue || []).slice();
          const optionIndex = getValueIndex(value, option.value);
          if (optionIndex > -1) {
            value.splice(optionIndex, 1);
          } else if (props.multipleLimit <= 0 || value.length < props.multipleLimit) {
            value.push(option.value);
          }
          ctx.emit(UPDATE_MODEL_EVENT, value);
          emitChange(value);
          if (option.created) {
            states.query = "";
            handleQueryChange("");
            states.inputLength = 20;
          }
          if (props.filterable)
            (_a2 = input.value) == null ? void 0 : _a2.focus();
        } else {
          ctx.emit(UPDATE_MODEL_EVENT, option.value);
          emitChange(option.value);
          states.visible = false;
        }
        setSoftFocus();
        if (states.visible)
          return;
        nextTick(() => {
          scrollToOption(option);
        });
      };
      const getValueIndex = (arr = [], value) => {
        if (!isObject$1(value))
          return arr.indexOf(value);
        const valueKey = props.valueKey;
        let index2 = -1;
        arr.some((item, i) => {
          if (toRaw(get(item, valueKey)) === get(value, valueKey)) {
            index2 = i;
            return true;
          }
          return false;
        });
        return index2;
      };
      const setSoftFocus = () => {
        const _input = input.value || reference.value;
        if (_input) {
          _input == null ? void 0 : _input.focus();
        }
      };
      const scrollToOption = (option) => {
        var _a2, _b, _c, _d, _e;
        const targetOption = Array.isArray(option) ? option[0] : option;
        let target = null;
        if (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 = (_a2 = tooltipRef.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef) == null ? void 0 : _c.querySelector) == null ? void 0 : _d.call(_c, `.${ns.be("dropdown", "wrap")}`);
          if (menu) {
            scrollIntoView(menu, target);
          }
        }
        (_e = scrollbar.value) == null ? void 0 : _e.handleScroll();
      };
      const onOptionCreate = (vm) => {
        states.optionsCount++;
        states.filteredOptionsCount++;
        states.options.set(vm.value, vm);
        states.cachedOptions.set(vm.value, vm);
        vm.disabled && states.disabledOptions.set(vm.value, vm);
      };
      const onOptionDestroy = (key, vm) => {
        if (states.options.get(key) === vm) {
          states.optionsCount--;
          states.filteredOptionsCount--;
          states.options.delete(key);
        }
      };
      const resetInputState = (e) => {
        if (e.code !== EVENT_CODE.backspace)
          toggleLastOptionHitState(false);
        states.inputLength = input.value.value.length * 15 + 20;
        resetInputHeight();
      };
      const toggleLastOptionHitState = (hit) => {
        if (!Array.isArray(states.selected))
          return;
        const lastNotDisabledIndex = getLastNotDisabledIndex(states.selected.map((it2) => it2.value));
        const option = states.selected[lastNotDisabledIndex];
        if (!option)
          return;
        if (hit === true || hit === false) {
          option.hitState = hit;
          return hit;
        }
        option.hitState = !option.hitState;
        return option.hitState;
      };
      const handleComposition = (event) => {
        const text = event.target.value;
        if (event.type === "compositionend") {
          states.isOnComposition = false;
          nextTick(() => handleQueryChange(text));
        } else {
          const lastCharacter = text[text.length - 1] || "";
          states.isOnComposition = !isKorean(lastCharacter);
        }
      };
      const handleMenuEnter = () => {
        nextTick(() => scrollToOption(states.selected));
      };
      const handleFocus = (event) => {
        if (!states.focused) {
          if (props.automaticDropdown || props.filterable) {
            if (props.filterable && !states.visible) {
              states.menuVisibleOnFocus = true;
            }
            states.visible = true;
          }
          states.focused = true;
          ctx.emit("focus", event);
        }
      };
      const focus = () => {
        var _a2, _b;
        if (states.visible) {
          (_a2 = input.value || reference.value) == null ? void 0 : _a2.focus();
        } else {
          (_b = reference.value) == null ? void 0 : _b.focus();
        }
      };
      const blur = () => {
        var _a2, _b, _c;
        states.visible = false;
        (_a2 = reference.value) == null ? void 0 : _a2.blur();
        (_c = (_b = iOSInput.value) == null ? void 0 : _b.blur) == null ? void 0 : _c.call(_b);
      };
      const handleBlur = (event) => {
        var _a2, _b, _c;
        if (((_a2 = tooltipRef.value) == null ? void 0 : _a2.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event)) || ((_c = selectWrapper.value) == null ? void 0 : _c.contains(event.relatedTarget))) {
          return;
        }
        states.visible && handleClose();
        states.focused = false;
        ctx.emit("blur", event);
      };
      const handleClearClick = (event) => {
        deleteSelected(event);
      };
      const handleClose = () => {
        states.visible = false;
      };
      const handleKeydownEscape = (event) => {
        if (states.visible) {
          event.preventDefault();
          event.stopPropagation();
          states.visible = false;
        }
      };
      const toggleMenu = (e) => {
        if (e && !states.mouseEnter) {
          return;
        }
        if (!selectDisabled.value) {
          if (states.menuVisibleOnFocus) {
            states.menuVisibleOnFocus = false;
          } else {
            if (!tooltipRef.value || !tooltipRef.value.isFocusInsideContent()) {
              states.visible = !states.visible;
            }
          }
          focus();
        }
      };
      const selectOption = () => {
        if (!states.visible) {
          toggleMenu();
        } else {
          if (optionsArray.value[states.hoverIndex]) {
            handleOptionSelect(optionsArray.value[states.hoverIndex]);
          }
        }
      };
      const getValueKey = (item) => {
        return isObject$1(item.value) ? get(item.value, props.valueKey) : item.value;
      };
      const optionsAllDisabled = computed(() => optionsArray.value.filter((option) => option.visible).every((option) => option.disabled));
      const showTagList = computed(() => props.multiple ? states.selected.slice(0, props.maxCollapseTags) : []);
      const collapseTagList = computed(() => props.multiple ? states.selected.slice(props.maxCollapseTags) : []);
      const navigateOptions = (direction2) => {
        if (!states.visible) {
          states.visible = true;
          return;
        }
        if (states.options.size === 0 || states.filteredOptionsCount === 0)
          return;
        if (states.isOnComposition)
          return;
        if (!optionsAllDisabled.value) {
          if (direction2 === "next") {
            states.hoverIndex++;
            if (states.hoverIndex === states.options.size) {
              states.hoverIndex = 0;
            }
          } else if (direction2 === "prev") {
            states.hoverIndex--;
            if (states.hoverIndex < 0) {
              states.hoverIndex = states.options.size - 1;
            }
          }
          const option = optionsArray.value[states.hoverIndex];
          if (option.disabled === true || option.states.groupDisabled === true || !option.visible) {
            navigateOptions(direction2);
          }
          nextTick(() => scrollToOption(hoverOption.value));
        }
      };
      const handleMouseEnter = () => {
        states.mouseEnter = true;
      };
      const handleMouseLeave = () => {
        states.mouseEnter = false;
      };
      const handleDeleteTooltipTag = (event, tag) => {
        var _a2, _b;
        deleteTag(event, tag);
        (_b = (_a2 = tagTooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
      };
      const selectTagsStyle = computed(() => ({
        maxWidth: `${unref(states.inputWidth) - 32 - (showStatusIconAndState.value ? 22 : 0)}px`,
        width: "100%"
      }));
      return {
        optionList,
        optionsArray,
        hoverOption,
        selectSize,
        handleResize,
        debouncedOnInputChange,
        debouncedQueryChange,
        deletePrevTag,
        deleteTag,
        deleteSelected,
        handleOptionSelect,
        scrollToOption,
        readonly: readonly2,
        resetInputHeight,
        showClose,
        iconComponent,
        iconReverse,
        showNewOption,
        collapseTagSize,
        setSelected,
        managePlaceholder,
        selectDisabled,
        emptyText,
        toggleLastOptionHitState,
        resetInputState,
        handleComposition,
        onOptionCreate,
        onOptionDestroy,
        handleMenuEnter,
        handleFocus,
        focus,
        blur,
        handleBlur,
        handleClearClick,
        handleClose,
        handleKeydownEscape,
        toggleMenu,
        selectOption,
        getValueKey,
        navigateOptions,
        handleDeleteTooltipTag,
        dropMenuVisible,
        queryChange,
        groupQueryChange,
        showTagList,
        collapseTagList,
        selectTagsStyle,
        reference,
        input,
        iOSInput,
        tooltipRef,
        tagTooltipRef,
        tags,
        selectWrapper,
        scrollbar,
        handleMouseEnter,
        handleMouseLeave
      };
    };
    var ElOptions = /* @__PURE__ */ defineComponent({
      name: "ElOptions",
      emits: ["update-options"],
      setup(_2, { slots, emit: emit2 }) {
        let cachedOptions = [];
        function isSameOptions(a2, b2) {
          if (a2.length !== b2.length)
            return false;
          for (const [index2] of a2.entries()) {
            if (a2[index2] != b2[index2]) {
              return false;
            }
          }
          return true;
        }
        return () => {
          var _a2, _b;
          const children = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
          const filteredOptions = [];
          function filterOptions(children2) {
            if (!Array.isArray(children2))
              return;
            children2.forEach((item) => {
              var _a22, _b2, _c, _d;
              const name = (_a22 = (item == null ? void 0 : item.type) || {}) == null ? void 0 : _a22.name;
              if (name === "ElOptionGroup") {
                filterOptions(!isString$1(item.children) && !Array.isArray(item.children) && isFunction$2((_b2 = item.children) == null ? void 0 : _b2.default) ? (_c = item.children) == null ? void 0 : _c.default() : item.children);
              } else if (name === "ElOption") {
                filteredOptions.push((_d = item.props) == null ? void 0 : _d.label);
              } else if (Array.isArray(item.children)) {
                filterOptions(item.children);
              }
            });
          }
          if (children.length) {
            filterOptions((_b = children[0]) == null ? void 0 : _b.children);
          }
          if (!isSameOptions(filteredOptions, cachedOptions)) {
            cachedOptions = filteredOptions;
            emit2("update-options", filteredOptions);
          }
          return children;
        };
      }
    });
    const COMPONENT_NAME$9 = "ElSelect";
    const _sfc_main$T = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$9,
      componentName: COMPONENT_NAME$9,
      components: {
        ElInput,
        ElSelectMenu: ElSelectMenu$1,
        ElOption: Option,
        ElOptions,
        ElTag,
        ElScrollbar,
        ElTooltip,
        ElIcon
      },
      directives: { ClickOutside },
      props: {
        name: String,
        id: String,
        modelValue: {
          type: [Array, String, Number, Boolean, Object],
          default: void 0
        },
        autocomplete: {
          type: String,
          default: "off"
        },
        automaticDropdown: Boolean,
        size: {
          type: String,
          validator: isValidComponentSize
        },
        effect: {
          type: String,
          default: "light"
        },
        disabled: Boolean,
        clearable: Boolean,
        filterable: Boolean,
        allowCreate: Boolean,
        loading: Boolean,
        popperClass: {
          type: String,
          default: ""
        },
        popperOptions: {
          type: Object,
          default: () => ({})
        },
        remote: Boolean,
        loadingText: String,
        noMatchText: String,
        noDataText: String,
        remoteMethod: Function,
        filterMethod: 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" },
        validateEvent: {
          type: Boolean,
          default: true
        },
        remoteShowSuffix: Boolean,
        suffixTransition: {
          type: Boolean,
          default: true
        },
        placement: {
          type: String,
          values: Ee,
          default: "bottom-start"
        },
        ariaLabel: {
          type: String,
          default: void 0
        }
      },
      emits: [
        UPDATE_MODEL_EVENT,
        CHANGE_EVENT,
        "remove-tag",
        "clear",
        "visible-change",
        "focus",
        "blur"
      ],
      setup(props, ctx) {
        const nsSelect = useNamespace("select");
        const nsInput = useNamespace("input");
        const { t } = useLocale();
        const contentId = useId();
        const states = useSelectStates(props);
        const {
          optionList,
          optionsArray,
          hoverOption,
          selectSize,
          readonly: readonly2,
          handleResize,
          collapseTagSize,
          debouncedOnInputChange,
          debouncedQueryChange,
          deletePrevTag,
          deleteTag,
          deleteSelected,
          handleOptionSelect,
          scrollToOption,
          setSelected,
          resetInputHeight,
          managePlaceholder,
          showClose,
          selectDisabled,
          iconComponent,
          iconReverse,
          showNewOption,
          emptyText,
          toggleLastOptionHitState,
          resetInputState,
          handleComposition,
          onOptionCreate,
          onOptionDestroy,
          handleMenuEnter,
          handleFocus,
          focus,
          blur,
          handleBlur,
          handleClearClick,
          handleClose,
          handleKeydownEscape,
          toggleMenu,
          selectOption,
          getValueKey,
          navigateOptions,
          handleDeleteTooltipTag,
          dropMenuVisible,
          reference,
          input,
          iOSInput,
          tooltipRef,
          tagTooltipRef,
          tags,
          selectWrapper,
          scrollbar,
          queryChange,
          groupQueryChange,
          handleMouseEnter,
          handleMouseLeave,
          showTagList,
          collapseTagList,
          selectTagsStyle
        } = useSelect$2(props, states, ctx);
        const {
          inputWidth,
          selected,
          inputLength,
          filteredOptionsCount,
          visible,
          selectedLabel,
          hoverIndex,
          query,
          inputHovering,
          currentPlaceholder,
          menuVisibleOnFocus,
          isOnComposition,
          options,
          cachedOptions,
          optionsCount,
          prefixWidth
        } = toRefs(states);
        const wrapperKls = computed(() => {
          const classList = [nsSelect.b()];
          const _selectSize = unref(selectSize);
          if (_selectSize) {
            classList.push(nsSelect.m(_selectSize));
          }
          if (props.disabled) {
            classList.push(nsSelect.m("disabled"));
          }
          return classList;
        });
        const tagsKls = computed(() => [
          nsSelect.e("tags"),
          nsSelect.is("disabled", unref(selectDisabled))
        ]);
        const tagWrapperKls = computed(() => [
          nsSelect.b("tags-wrapper"),
          { "has-prefix": unref(prefixWidth) && unref(selected).length }
        ]);
        const inputKls = computed(() => [
          nsSelect.e("input"),
          nsSelect.is(unref(selectSize)),
          nsSelect.is("disabled", unref(selectDisabled))
        ]);
        const iOSInputKls = computed(() => [
          nsSelect.e("input"),
          nsSelect.is(unref(selectSize)),
          nsSelect.em("input", "iOS")
        ]);
        const scrollbarKls = computed(() => [
          nsSelect.is("empty", !props.allowCreate && Boolean(unref(query)) && unref(filteredOptionsCount) === 0)
        ]);
        const tagTextStyle = computed(() => {
          const maxWidth = unref(inputWidth) > 123 && unref(selected).length > props.maxCollapseTags ? unref(inputWidth) - 123 : unref(inputWidth) - 75;
          return { maxWidth: `${maxWidth}px` };
        });
        const inputStyle = computed(() => ({
          marginLeft: `${unref(prefixWidth)}px`,
          flexGrow: 1,
          width: `${unref(inputLength) / (unref(inputWidth) - 32)}%`,
          maxWidth: `${unref(inputWidth) - 42}px`
        }));
        provide(selectKey, reactive({
          props,
          options,
          optionsArray,
          cachedOptions,
          optionsCount,
          filteredOptionsCount,
          hoverIndex,
          handleOptionSelect,
          onOptionCreate,
          onOptionDestroy,
          selectWrapper,
          selected,
          setSelected,
          queryChange,
          groupQueryChange
        }));
        onMounted(() => {
          states.cachedPlaceHolder = currentPlaceholder.value = props.placeholder || (() => t("el.select.placeholder"));
          if (props.multiple && Array.isArray(props.modelValue) && props.modelValue.length > 0) {
            currentPlaceholder.value = "";
          }
          useResizeObserver(selectWrapper, handleResize);
          if (props.remote && props.multiple) {
            resetInputHeight();
          }
          nextTick(() => {
            const refEl = reference.value && reference.value.$el;
            if (!refEl)
              return;
            inputWidth.value = refEl.getBoundingClientRect().width;
            if (ctx.slots.prefix) {
              const prefix = refEl.querySelector(`.${nsInput.e("prefix")}`);
              prefixWidth.value = Math.max(prefix.getBoundingClientRect().width + 11, 30);
            }
          });
          setSelected();
        });
        if (props.multiple && !Array.isArray(props.modelValue)) {
          ctx.emit(UPDATE_MODEL_EVENT, []);
        }
        if (!props.multiple && Array.isArray(props.modelValue)) {
          ctx.emit(UPDATE_MODEL_EVENT, "");
        }
        const popperPaneRef = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
        });
        const onOptionsRendered = (v2) => {
          optionList.value = v2;
        };
        return {
          isIOS,
          onOptionsRendered,
          prefixWidth,
          selectSize,
          readonly: readonly2,
          handleResize,
          collapseTagSize,
          debouncedOnInputChange,
          debouncedQueryChange,
          deletePrevTag,
          deleteTag,
          handleDeleteTooltipTag,
          deleteSelected,
          handleOptionSelect,
          scrollToOption,
          inputWidth,
          selected,
          inputLength,
          filteredOptionsCount,
          visible,
          selectedLabel,
          hoverIndex,
          query,
          inputHovering,
          currentPlaceholder,
          menuVisibleOnFocus,
          isOnComposition,
          options,
          resetInputHeight,
          managePlaceholder,
          showClose,
          selectDisabled,
          iconComponent,
          iconReverse,
          showNewOption,
          emptyText,
          toggleLastOptionHitState,
          resetInputState,
          handleComposition,
          handleMenuEnter,
          handleFocus,
          focus,
          blur,
          handleBlur,
          handleClearClick,
          handleClose,
          handleKeydownEscape,
          toggleMenu,
          selectOption,
          getValueKey,
          navigateOptions,
          dropMenuVisible,
          reference,
          input,
          iOSInput,
          tooltipRef,
          popperPaneRef,
          tags,
          selectWrapper,
          scrollbar,
          wrapperKls,
          tagsKls,
          tagWrapperKls,
          inputKls,
          iOSInputKls,
          scrollbarKls,
          selectTagsStyle,
          nsSelect,
          tagTextStyle,
          inputStyle,
          handleMouseEnter,
          handleMouseLeave,
          showTagList,
          collapseTagList,
          tagTooltipRef,
          contentId,
          hoverOption
        };
      }
    });
    const _hoisted_1$p = ["disabled", "autocomplete", "aria-activedescendant", "aria-controls", "aria-expanded", "aria-label"];
    const _hoisted_2$g = ["disabled"];
    const _hoisted_3$8 = { style: { "height": "100%", "display": "flex", "justify-content": "center", "align-items": "center" } };
    function _sfc_render$9(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_tag = resolveComponent("el-tag");
      const _component_el_tooltip = resolveComponent("el-tooltip");
      const _component_el_icon = resolveComponent("el-icon");
      const _component_el_input = resolveComponent("el-input");
      const _component_el_option = resolveComponent("el-option");
      const _component_el_options = resolveComponent("el-options");
      const _component_el_scrollbar = resolveComponent("el-scrollbar");
      const _component_el_select_menu = resolveComponent("el-select-menu");
      const _directive_click_outside = resolveDirective("click-outside");
      return withDirectives((openBlock(), createElementBlock("div", {
        ref: "selectWrapper",
        class: normalizeClass(_ctx.wrapperKls),
        onMouseenter: _cache[22] || (_cache[22] = (...args) => _ctx.handleMouseEnter && _ctx.handleMouseEnter(...args)),
        onMouseleave: _cache[23] || (_cache[23] = (...args) => _ctx.handleMouseLeave && _ctx.handleMouseLeave(...args)),
        onClick: _cache[24] || (_cache[24] = withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"]))
      }, [
        createVNode(_component_el_tooltip, {
          ref: "tooltipRef",
          visible: _ctx.dropMenuVisible,
          placement: _ctx.placement,
          teleported: _ctx.teleported,
          "popper-class": [_ctx.nsSelect.e("popper"), _ctx.popperClass],
          "popper-options": _ctx.popperOptions,
          "fallback-placements": ["bottom-start", "top-start", "right", "left"],
          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,
          onShow: _ctx.handleMenuEnter
        }, {
          default: withCtx(() => {
            var _a2, _b;
            return [
              createBaseVNode("div", {
                class: "select-trigger",
                onMouseenter: _cache[20] || (_cache[20] = ($event) => _ctx.inputHovering = true),
                onMouseleave: _cache[21] || (_cache[21] = ($event) => _ctx.inputHovering = false)
              }, [
                _ctx.multiple ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  ref: "tags",
                  tabindex: "-1",
                  class: normalizeClass(_ctx.tagsKls),
                  style: normalizeStyle(_ctx.selectTagsStyle),
                  onClick: _cache[15] || (_cache[15] = (...args) => _ctx.focus && _ctx.focus(...args))
                }, [
                  _ctx.collapseTags && _ctx.selected.length ? (openBlock(), createBlock(Transition, {
                    key: 0,
                    onAfterLeave: _ctx.resetInputHeight
                  }, {
                    default: withCtx(() => [
                      createBaseVNode("span", {
                        class: normalizeClass(_ctx.tagWrapperKls)
                      }, [
                        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.showTagList, (item) => {
                          return openBlock(), createBlock(_component_el_tag, {
                            key: _ctx.getValueKey(item),
                            closable: !_ctx.selectDisabled && !item.isDisabled,
                            size: _ctx.collapseTagSize,
                            hit: item.hitState,
                            type: _ctx.tagType,
                            "disable-transitions": "",
                            onClose: ($event) => _ctx.deleteTag($event, item)
                          }, {
                            default: withCtx(() => [
                              createBaseVNode("span", {
                                class: normalizeClass(_ctx.nsSelect.e("tags-text")),
                                style: normalizeStyle(_ctx.tagTextStyle)
                              }, toDisplayString(item.currentLabel), 7)
                            ]),
                            _: 2
                          }, 1032, ["closable", "size", "hit", "type", "onClose"]);
                        }), 128)),
                        _ctx.selected.length > _ctx.maxCollapseTags ? (openBlock(), createBlock(_component_el_tag, {
                          key: 0,
                          closable: false,
                          size: _ctx.collapseTagSize,
                          type: _ctx.tagType,
                          "disable-transitions": ""
                        }, {
                          default: withCtx(() => [
                            _ctx.collapseTagsTooltip ? (openBlock(), createBlock(_component_el_tooltip, {
                              key: 0,
                              ref: "tagTooltipRef",
                              disabled: _ctx.dropMenuVisible,
                              "fallback-placements": ["bottom", "top", "right", "left"],
                              effect: _ctx.effect,
                              placement: "bottom",
                              teleported: _ctx.teleported
                            }, {
                              default: withCtx(() => [
                                createBaseVNode("span", {
                                  class: normalizeClass(_ctx.nsSelect.e("tags-text"))
                                }, "+ " + toDisplayString(_ctx.selected.length - _ctx.maxCollapseTags), 3)
                              ]),
                              content: withCtx(() => [
                                createBaseVNode("div", {
                                  class: normalizeClass(_ctx.nsSelect.e("collapse-tags"))
                                }, [
                                  (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.collapseTagList, (item) => {
                                    return openBlock(), createElementBlock("div", {
                                      key: _ctx.getValueKey(item),
                                      class: normalizeClass(_ctx.nsSelect.e("collapse-tag"))
                                    }, [
                                      createVNode(_component_el_tag, {
                                        class: "in-tooltip",
                                        closable: !_ctx.selectDisabled && !item.isDisabled,
                                        size: _ctx.collapseTagSize,
                                        hit: item.hitState,
                                        type: _ctx.tagType,
                                        "disable-transitions": "",
                                        style: { margin: "2px" },
                                        onClose: ($event) => _ctx.handleDeleteTooltipTag($event, item)
                                      }, {
                                        default: withCtx(() => [
                                          createBaseVNode("span", {
                                            class: normalizeClass(_ctx.nsSelect.e("tags-text")),
                                            style: normalizeStyle({
                                              maxWidth: _ctx.inputWidth - 75 + "px"
                                            })
                                          }, toDisplayString(item.currentLabel), 7)
                                        ]),
                                        _: 2
                                      }, 1032, ["closable", "size", "hit", "type", "onClose"])
                                    ], 2);
                                  }), 128))
                                ], 2)
                              ]),
                              _: 1
                            }, 8, ["disabled", "effect", "teleported"])) : (openBlock(), createElementBlock("span", {
                              key: 1,
                              class: normalizeClass(_ctx.nsSelect.e("tags-text"))
                            }, "+ " + toDisplayString(_ctx.selected.length - _ctx.maxCollapseTags), 3))
                          ]),
                          _: 1
                        }, 8, ["size", "type"])) : createCommentVNode("v-if", true)
                      ], 2)
                    ]),
                    _: 1
                  }, 8, ["onAfterLeave"])) : createCommentVNode("v-if", true),
                  !_ctx.collapseTags ? (openBlock(), createBlock(Transition, {
                    key: 1,
                    onAfterLeave: _ctx.resetInputHeight
                  }, {
                    default: withCtx(() => [
                      createBaseVNode("span", {
                        class: normalizeClass(_ctx.tagWrapperKls),
                        style: normalizeStyle(_ctx.prefixWidth && _ctx.selected.length ? { marginLeft: `${_ctx.prefixWidth}px` } : "")
                      }, [
                        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.selected, (item) => {
                          return openBlock(), createBlock(_component_el_tag, {
                            key: _ctx.getValueKey(item),
                            closable: !_ctx.selectDisabled && !item.isDisabled,
                            size: _ctx.collapseTagSize,
                            hit: item.hitState,
                            type: _ctx.tagType,
                            "disable-transitions": "",
                            onClose: ($event) => _ctx.deleteTag($event, item)
                          }, {
                            default: withCtx(() => [
                              createBaseVNode("span", {
                                class: normalizeClass(_ctx.nsSelect.e("tags-text")),
                                style: normalizeStyle({ maxWidth: _ctx.inputWidth - 75 + "px" })
                              }, toDisplayString(item.currentLabel), 7)
                            ]),
                            _: 2
                          }, 1032, ["closable", "size", "hit", "type", "onClose"]);
                        }), 128))
                      ], 6)
                    ]),
                    _: 1
                  }, 8, ["onAfterLeave"])) : createCommentVNode("v-if", true),
                  _ctx.filterable && !_ctx.selectDisabled ? withDirectives((openBlock(), createElementBlock("input", {
                    key: 2,
                    ref: "input",
                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.query = $event),
                    type: "text",
                    class: normalizeClass(_ctx.inputKls),
                    disabled: _ctx.selectDisabled,
                    autocomplete: _ctx.autocomplete,
                    style: normalizeStyle(_ctx.inputStyle),
                    role: "combobox",
                    "aria-activedescendant": ((_a2 = _ctx.hoverOption) == null ? void 0 : _a2.id) || "",
                    "aria-controls": _ctx.contentId,
                    "aria-expanded": _ctx.dropMenuVisible,
                    "aria-label": _ctx.ariaLabel,
                    "aria-autocomplete": "none",
                    "aria-haspopup": "listbox",
                    onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
                    onBlur: _cache[2] || (_cache[2] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
                    onKeyup: _cache[3] || (_cache[3] = (...args) => _ctx.managePlaceholder && _ctx.managePlaceholder(...args)),
                    onKeydown: [
                      _cache[4] || (_cache[4] = (...args) => _ctx.resetInputState && _ctx.resetInputState(...args)),
                      _cache[5] || (_cache[5] = withKeys(withModifiers(($event) => _ctx.navigateOptions("next"), ["prevent"]), ["down"])),
                      _cache[6] || (_cache[6] = withKeys(withModifiers(($event) => _ctx.navigateOptions("prev"), ["prevent"]), ["up"])),
                      _cache[7] || (_cache[7] = withKeys((...args) => _ctx.handleKeydownEscape && _ctx.handleKeydownEscape(...args), ["esc"])),
                      _cache[8] || (_cache[8] = withKeys(withModifiers((...args) => _ctx.selectOption && _ctx.selectOption(...args), ["stop", "prevent"]), ["enter"])),
                      _cache[9] || (_cache[9] = withKeys((...args) => _ctx.deletePrevTag && _ctx.deletePrevTag(...args), ["delete"])),
                      _cache[10] || (_cache[10] = withKeys(($event) => _ctx.visible = false, ["tab"]))
                    ],
                    onCompositionstart: _cache[11] || (_cache[11] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                    onCompositionupdate: _cache[12] || (_cache[12] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                    onCompositionend: _cache[13] || (_cache[13] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                    onInput: _cache[14] || (_cache[14] = (...args) => _ctx.debouncedQueryChange && _ctx.debouncedQueryChange(...args))
                  }, null, 46, _hoisted_1$p)), [
                    [vModelText, _ctx.query]
                  ]) : createCommentVNode("v-if", true)
                ], 6)) : createCommentVNode("v-if", true),
                _ctx.isIOS && !_ctx.multiple && _ctx.filterable && _ctx.readonly ? (openBlock(), createElementBlock("input", {
                  key: 1,
                  ref: "iOSInput",
                  class: normalizeClass(_ctx.iOSInputKls),
                  disabled: _ctx.selectDisabled,
                  type: "text"
                }, null, 10, _hoisted_2$g)) : createCommentVNode("v-if", true),
                createVNode(_component_el_input, {
                  id: _ctx.id,
                  ref: "reference",
                  modelValue: _ctx.selectedLabel,
                  "onUpdate:modelValue": _cache[16] || (_cache[16] = ($event) => _ctx.selectedLabel = $event),
                  type: "text",
                  placeholder: typeof _ctx.currentPlaceholder === "function" ? _ctx.currentPlaceholder() : _ctx.currentPlaceholder,
                  name: _ctx.name,
                  autocomplete: _ctx.autocomplete,
                  size: _ctx.selectSize,
                  disabled: _ctx.selectDisabled,
                  readonly: _ctx.readonly,
                  "validate-event": false,
                  class: normalizeClass([_ctx.nsSelect.is("focus", _ctx.visible)]),
                  tabindex: _ctx.multiple && _ctx.filterable ? -1 : void 0,
                  role: "combobox",
                  "aria-activedescendant": ((_b = _ctx.hoverOption) == null ? void 0 : _b.id) || "",
                  "aria-controls": _ctx.contentId,
                  "aria-expanded": _ctx.dropMenuVisible,
                  label: _ctx.ariaLabel,
                  "aria-autocomplete": "none",
                  "aria-haspopup": "listbox",
                  onFocus: _ctx.handleFocus,
                  onBlur: _ctx.handleBlur,
                  onInput: _ctx.debouncedOnInputChange,
                  onPaste: _ctx.debouncedOnInputChange,
                  onCompositionstart: _ctx.handleComposition,
                  onCompositionupdate: _ctx.handleComposition,
                  onCompositionend: _ctx.handleComposition,
                  onKeydown: [
                    _cache[17] || (_cache[17] = withKeys(withModifiers(($event) => _ctx.navigateOptions("next"), ["stop", "prevent"]), ["down"])),
                    _cache[18] || (_cache[18] = withKeys(withModifiers(($event) => _ctx.navigateOptions("prev"), ["stop", "prevent"]), ["up"])),
                    withKeys(withModifiers(_ctx.selectOption, ["stop", "prevent"]), ["enter"]),
                    withKeys(_ctx.handleKeydownEscape, ["esc"]),
                    _cache[19] || (_cache[19] = withKeys(($event) => _ctx.visible = false, ["tab"]))
                  ]
                }, createSlots({
                  suffix: withCtx(() => [
                    _ctx.iconComponent && !_ctx.showClose ? (openBlock(), createBlock(_component_el_icon, {
                      key: 0,
                      class: normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsSelect.e("icon"), _ctx.iconReverse])
                    }, {
                      default: withCtx(() => [
                        (openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
                      ]),
                      _: 1
                    }, 8, ["class"])) : createCommentVNode("v-if", true),
                    _ctx.showClose && _ctx.clearIcon ? (openBlock(), createBlock(_component_el_icon, {
                      key: 1,
                      class: normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsSelect.e("icon")]),
                      onClick: _ctx.handleClearClick
                    }, {
                      default: withCtx(() => [
                        (openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
                      ]),
                      _: 1
                    }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
                  ]),
                  _: 2
                }, [
                  _ctx.$slots.prefix ? {
                    name: "prefix",
                    fn: withCtx(() => [
                      createBaseVNode("div", _hoisted_3$8, [
                        renderSlot(_ctx.$slots, "prefix")
                      ])
                    ])
                  } : void 0
                ]), 1032, ["id", "modelValue", "placeholder", "name", "autocomplete", "size", "disabled", "readonly", "class", "tabindex", "aria-activedescendant", "aria-controls", "aria-expanded", "label", "onFocus", "onBlur", "onInput", "onPaste", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onKeydown"])
              ], 32)
            ];
          }),
          content: withCtx(() => [
            createVNode(_component_el_select_menu, null, createSlots({
              default: withCtx(() => [
                withDirectives(createVNode(_component_el_scrollbar, {
                  id: _ctx.contentId,
                  ref: "scrollbar",
                  tag: "ul",
                  "wrap-class": _ctx.nsSelect.be("dropdown", "wrap"),
                  "view-class": _ctx.nsSelect.be("dropdown", "list"),
                  class: normalizeClass(_ctx.scrollbarKls),
                  role: "listbox",
                  "aria-label": _ctx.ariaLabel,
                  "aria-orientation": "vertical"
                }, {
                  default: withCtx(() => [
                    _ctx.showNewOption ? (openBlock(), createBlock(_component_el_option, {
                      key: 0,
                      value: _ctx.query,
                      created: true
                    }, null, 8, ["value"])) : createCommentVNode("v-if", true),
                    createVNode(_component_el_options, { onUpdateOptions: _ctx.onOptionsRendered }, {
                      default: withCtx(() => [
                        renderSlot(_ctx.$slots, "default")
                      ]),
                      _: 3
                    }, 8, ["onUpdateOptions"])
                  ]),
                  _: 3
                }, 8, ["id", "wrap-class", "view-class", "class", "aria-label"]), [
                  [vShow, _ctx.options.size > 0 && !_ctx.loading]
                ]),
                _ctx.emptyText && (!_ctx.allowCreate || _ctx.loading || _ctx.allowCreate && _ctx.options.size === 0) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                  _ctx.$slots.empty ? renderSlot(_ctx.$slots, "empty", { key: 0 }) : (openBlock(), createElementBlock("p", {
                    key: 1,
                    class: normalizeClass(_ctx.nsSelect.be("dropdown", "empty"))
                  }, toDisplayString(_ctx.emptyText), 3))
                ], 64)) : createCommentVNode("v-if", true)
              ]),
              _: 2
            }, [
              _ctx.$slots.header ? {
                name: "header",
                fn: withCtx(() => [
                  renderSlot(_ctx.$slots, "header")
                ])
              } : void 0,
              _ctx.$slots.footer ? {
                name: "footer",
                fn: withCtx(() => [
                  renderSlot(_ctx.$slots, "footer")
                ])
              } : void 0
            ]), 1024)
          ]),
          _: 3
        }, 8, ["visible", "placement", "teleported", "popper-class", "popper-options", "effect", "transition", "persistent", "onShow"])
      ], 34)), [
        [_directive_click_outside, _ctx.handleClose, _ctx.popperPaneRef]
      ]);
    }
    var Select$1 = /* @__PURE__ */ _export_sfc$1(_sfc_main$T, [["render", _sfc_render$9], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/select/src/select.vue"]]);
    const _sfc_main$S = /* @__PURE__ */ defineComponent({
      name: "ElOptionGroup",
      componentName: "ElOptionGroup",
      props: {
        label: String,
        disabled: Boolean
      },
      setup(props) {
        const ns = useNamespace("select");
        const visible = ref(true);
        const instance = getCurrentInstance();
        const children = ref([]);
        provide(selectGroupKey, reactive({
          ...toRefs(props)
        }));
        const select = inject(selectKey);
        onMounted(() => {
          children.value = flattedChildren2(instance.subTree);
        });
        const flattedChildren2 = (node) => {
          const children2 = [];
          if (Array.isArray(node.children)) {
            node.children.forEach((child) => {
              var _a2;
              if (child.type && child.type.name === "ElOption" && child.component && child.component.proxy) {
                children2.push(child.component.proxy);
              } else if ((_a2 = child.children) == null ? void 0 : _a2.length) {
                children2.push(...flattedChildren2(child));
              }
            });
          }
          return children2;
        };
        const { groupQueryChange } = toRaw(select);
        watch(groupQueryChange, () => {
          visible.value = children.value.some((option) => option.visible === true);
        }, { flush: "post" });
        return {
          visible,
          ns
        };
      }
    });
    function _sfc_render$8(_ctx, _cache, $props, $setup, $data, $options) {
      return withDirectives((openBlock(), createElementBlock("ul", {
        class: normalizeClass(_ctx.ns.be("group", "wrap"))
      }, [
        createBaseVNode("li", {
          class: normalizeClass(_ctx.ns.be("group", "title"))
        }, toDisplayString(_ctx.label), 3),
        createBaseVNode("li", null, [
          createBaseVNode("ul", {
            class: normalizeClass(_ctx.ns.b("group"))
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2)
        ])
      ], 2)), [
        [vShow, _ctx.visible]
      ]);
    }
    var OptionGroup = /* @__PURE__ */ _export_sfc$1(_sfc_main$S, [["render", _sfc_render$8], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/select/src/option-group.vue"]]);
    const ElSelect = withInstall(Select$1, {
      Option,
      OptionGroup
    });
    const ElOption = withNoopInstall(Option);
    const ElOptionGroup = withNoopInstall(OptionGroup);
    const usePagination = () => 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
      },
      disabled: Boolean,
      teleported: Boolean,
      size: {
        type: String,
        values: componentSizes
      }
    });
    const __default__$D = /* @__PURE__ */ defineComponent({
      name: "ElPaginationSizes"
    });
    const _sfc_main$R = /* @__PURE__ */ defineComponent({
      ...__default__$D,
      props: paginationSizesProps,
      emits: ["page-size-change"],
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const pagination = usePagination();
        const innerPageSize = ref(props.pageSize);
        watch(() => props.pageSizes, (newVal, oldVal) => {
          if (isEqual$1(newVal, oldVal))
            return;
          if (Array.isArray(newVal)) {
            const pageSize = newVal.includes(props.pageSize) ? props.pageSize : props.pageSizes[0];
            emit2("page-size-change", pageSize);
          }
        });
        watch(() => props.pageSize, (newVal) => {
          innerPageSize.value = newVal;
        });
        const innerPageSizes = computed(() => props.pageSizes);
        function handleChange(val) {
          var _a2;
          if (val !== innerPageSize.value) {
            innerPageSize.value = val;
            (_a2 = pagination.handleSizeChange) == null ? void 0 : _a2.call(pagination, Number(val));
          }
        }
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("span", {
            class: normalizeClass(unref(ns).e("sizes"))
          }, [
            createVNode(unref(ElSelect), {
              "model-value": innerPageSize.value,
              disabled: _ctx.disabled,
              "popper-class": _ctx.popperClass,
              size: _ctx.size,
              teleported: _ctx.teleported,
              "validate-event": false,
              onChange: handleChange
            }, {
              default: withCtx(() => [
                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(innerPageSizes), (item) => {
                  return openBlock(), createBlock(unref(ElOption), {
                    key: item,
                    value: item,
                    label: item + unref(t)("el.pagination.pagesize")
                  }, null, 8, ["value", "label"]);
                }), 128))
              ]),
              _: 1
            }, 8, ["model-value", "disabled", "popper-class", "size", "teleported"])
          ], 2);
        };
      }
    });
    var Sizes = /* @__PURE__ */ _export_sfc$1(_sfc_main$R, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/pagination/src/components/sizes.vue"]]);
    const paginationJumperProps = buildProps({
      size: {
        type: String,
        values: componentSizes
      }
    });
    const _hoisted_1$o = ["disabled"];
    const __default__$C = /* @__PURE__ */ defineComponent({
      name: "ElPaginationJumper"
    });
    const _sfc_main$Q = /* @__PURE__ */ defineComponent({
      ...__default__$C,
      props: paginationJumperProps,
      setup(__props) {
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const { pageCount, disabled, currentPage, changeEvent } = usePagination();
        const userInput = ref();
        const innerValue = computed(() => {
          var _a2;
          return (_a2 = userInput.value) != null ? _a2 : 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 openBlock(), createElementBlock("span", {
            class: normalizeClass(unref(ns).e("jump")),
            disabled: unref(disabled)
          }, [
            createBaseVNode("span", {
              class: normalizeClass([unref(ns).e("goto")])
            }, toDisplayString(unref(t)("el.pagination.goto")), 3),
            createVNode(unref(ElInput), {
              size: _ctx.size,
              class: normalizeClass([unref(ns).e("editor"), unref(ns).is("in-pagination")]),
              min: 1,
              max: unref(pageCount),
              disabled: unref(disabled),
              "model-value": unref(innerValue),
              "validate-event": false,
              label: unref(t)("el.pagination.page"),
              type: "number",
              "onUpdate:modelValue": handleInput,
              onChange: handleChange
            }, null, 8, ["size", "class", "max", "disabled", "model-value", "label"]),
            createBaseVNode("span", {
              class: normalizeClass([unref(ns).e("classifier")])
            }, toDisplayString(unref(t)("el.pagination.pageClassifier")), 3)
          ], 10, _hoisted_1$o);
        };
      }
    });
    var Jumper = /* @__PURE__ */ _export_sfc$1(_sfc_main$Q, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/pagination/src/components/jumper.vue"]]);
    const paginationTotalProps = buildProps({
      total: {
        type: Number,
        default: 1e3
      }
    });
    const _hoisted_1$n = ["disabled"];
    const __default__$B = /* @__PURE__ */ defineComponent({
      name: "ElPaginationTotal"
    });
    const _sfc_main$P = /* @__PURE__ */ defineComponent({
      ...__default__$B,
      props: paginationTotalProps,
      setup(__props) {
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const { disabled } = usePagination();
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("span", {
            class: normalizeClass(unref(ns).e("total")),
            disabled: unref(disabled)
          }, toDisplayString(unref(t)("el.pagination.total", {
            total: _ctx.total
          })), 11, _hoisted_1$n);
        };
      }
    });
    var Total = /* @__PURE__ */ _export_sfc$1(_sfc_main$P, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/pagination/src/components/total.vue"]]);
    const paginationPagerProps = buildProps({
      currentPage: {
        type: Number,
        default: 1
      },
      pageCount: {
        type: Number,
        required: true
      },
      pagerCount: {
        type: Number,
        default: 7
      },
      disabled: Boolean
    });
    const _hoisted_1$m = ["onKeyup"];
    const _hoisted_2$f = ["aria-current", "aria-label", "tabindex"];
    const _hoisted_3$7 = ["tabindex", "aria-label"];
    const _hoisted_4$5 = ["aria-current", "aria-label", "tabindex"];
    const _hoisted_5$4 = ["tabindex", "aria-label"];
    const _hoisted_6$1 = ["aria-current", "aria-label", "tabindex"];
    const __default__$A = /* @__PURE__ */ defineComponent({
      name: "ElPaginationPager"
    });
    const _sfc_main$O = /* @__PURE__ */ defineComponent({
      ...__default__$A,
      props: paginationPagerProps,
      emits: ["change"],
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const nsPager = useNamespace("pager");
        const nsIcon = useNamespace("icon");
        const { t } = useLocale();
        const showPrevMore = ref(false);
        const showNextMore = ref(false);
        const quickPrevHover = ref(false);
        const quickNextHover = ref(false);
        const quickPrevFocus = ref(false);
        const quickNextFocus = ref(false);
        const pagers = 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 array2 = [];
          if (showPrevMore2 && !showNextMore2) {
            const startPage = pageCount - (pagerCount - 2);
            for (let i = startPage; i < pageCount; i++) {
              array2.push(i);
            }
          } else if (!showPrevMore2 && showNextMore2) {
            for (let i = 2; i < pagerCount; i++) {
              array2.push(i);
            }
          } else if (showPrevMore2 && showNextMore2) {
            const offset2 = Math.floor(pagerCount / 2) - 1;
            for (let i = currentPage - offset2; i <= currentPage + offset2; i++) {
              array2.push(i);
            }
          } else {
            for (let i = 2; i < pageCount; i++) {
              array2.push(i);
            }
          }
          return array2;
        });
        const prevMoreKls = computed(() => [
          "more",
          "btn-quickprev",
          nsIcon.b(),
          nsPager.is("disabled", props.disabled)
        ]);
        const nextMoreKls = computed(() => [
          "more",
          "btn-quicknext",
          nsIcon.b(),
          nsPager.is("disabled", props.disabled)
        ]);
        const tabindex = computed(() => props.disabled ? -1 : 0);
        watchEffect(() => {
          const halfPagerCount = (props.pagerCount - 1) / 2;
          showPrevMore.value = false;
          showNextMore.value = false;
          if (props.pageCount > props.pagerCount) {
            if (props.currentPage > props.pagerCount - halfPagerCount) {
              showPrevMore.value = true;
            }
            if (props.currentPage < props.pageCount - halfPagerCount) {
              showNextMore.value = 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) {
              emit2("change", 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) {
            emit2("change", newPage);
          }
        }
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("ul", {
            class: normalizeClass(unref(nsPager).b()),
            onClick: onPagerClick,
            onKeyup: withKeys(onEnter, ["enter"])
          }, [
            _ctx.pageCount > 0 ? (openBlock(), createElementBlock("li", {
              key: 0,
              class: normalizeClass([[
                unref(nsPager).is("active", _ctx.currentPage === 1),
                unref(nsPager).is("disabled", _ctx.disabled)
              ], "number"]),
              "aria-current": _ctx.currentPage === 1,
              "aria-label": unref(t)("el.pagination.currentPage", { pager: 1 }),
              tabindex: unref(tabindex)
            }, " 1 ", 10, _hoisted_2$f)) : createCommentVNode("v-if", true),
            showPrevMore.value ? (openBlock(), createElementBlock("li", {
              key: 1,
              class: normalizeClass(unref(prevMoreKls)),
              tabindex: unref(tabindex),
              "aria-label": unref(t)("el.pagination.prevPages", { pager: _ctx.pagerCount - 2 }),
              onMouseenter: _cache[0] || (_cache[0] = ($event) => onMouseEnter(true)),
              onMouseleave: _cache[1] || (_cache[1] = ($event) => quickPrevHover.value = false),
              onFocus: _cache[2] || (_cache[2] = ($event) => onFocus(true)),
              onBlur: _cache[3] || (_cache[3] = ($event) => quickPrevFocus.value = false)
            }, [
              (quickPrevHover.value || quickPrevFocus.value) && !_ctx.disabled ? (openBlock(), createBlock(unref(d_arrow_left_default), { key: 0 })) : (openBlock(), createBlock(unref(more_filled_default), { key: 1 }))
            ], 42, _hoisted_3$7)) : createCommentVNode("v-if", true),
            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(pagers), (pager) => {
              return openBlock(), createElementBlock("li", {
                key: pager,
                class: normalizeClass([[
                  unref(nsPager).is("active", _ctx.currentPage === pager),
                  unref(nsPager).is("disabled", _ctx.disabled)
                ], "number"]),
                "aria-current": _ctx.currentPage === pager,
                "aria-label": unref(t)("el.pagination.currentPage", { pager }),
                tabindex: unref(tabindex)
              }, toDisplayString(pager), 11, _hoisted_4$5);
            }), 128)),
            showNextMore.value ? (openBlock(), createElementBlock("li", {
              key: 2,
              class: normalizeClass(unref(nextMoreKls)),
              tabindex: unref(tabindex),
              "aria-label": unref(t)("el.pagination.nextPages", { pager: _ctx.pagerCount - 2 }),
              onMouseenter: _cache[4] || (_cache[4] = ($event) => onMouseEnter()),
              onMouseleave: _cache[5] || (_cache[5] = ($event) => quickNextHover.value = false),
              onFocus: _cache[6] || (_cache[6] = ($event) => onFocus()),
              onBlur: _cache[7] || (_cache[7] = ($event) => quickNextFocus.value = false)
            }, [
              (quickNextHover.value || quickNextFocus.value) && !_ctx.disabled ? (openBlock(), createBlock(unref(d_arrow_right_default), { key: 0 })) : (openBlock(), createBlock(unref(more_filled_default), { key: 1 }))
            ], 42, _hoisted_5$4)) : createCommentVNode("v-if", true),
            _ctx.pageCount > 1 ? (openBlock(), createElementBlock("li", {
              key: 3,
              class: normalizeClass([[
                unref(nsPager).is("active", _ctx.currentPage === _ctx.pageCount),
                unref(nsPager).is("disabled", _ctx.disabled)
              ], "number"]),
              "aria-current": _ctx.currentPage === _ctx.pageCount,
              "aria-label": unref(t)("el.pagination.currentPage", { pager: _ctx.pageCount }),
              tabindex: unref(tabindex)
            }, toDisplayString(_ctx.pageCount), 11, _hoisted_6$1)) : createCommentVNode("v-if", true)
          ], 42, _hoisted_1$m);
        };
      }
    });
    var Pager = /* @__PURE__ */ _export_sfc$1(_sfc_main$O, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/pagination/src/components/pager.vue"]]);
    const isAbsent = (v2) => typeof v2 !== "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: ""
      },
      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,
      background: Boolean,
      disabled: Boolean,
      hideOnSinglePage: Boolean
    });
    const paginationEmits = {
      "update:current-page": (val) => isNumber(val),
      "update:page-size": (val) => isNumber(val),
      "size-change": (val) => isNumber(val),
      "current-change": (val) => isNumber(val),
      "prev-click": (val) => isNumber(val),
      "next-click": (val) => isNumber(val)
    };
    const componentName = "ElPagination";
    var Pagination = /* @__PURE__ */ defineComponent({
      name: componentName,
      props: paginationProps,
      emits: paginationEmits,
      setup(props, { emit: emit2, slots }) {
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const vnodeProps = getCurrentInstance().vnode.props || {};
        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 = 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 = ref(isAbsent(props.defaultPageSize) ? 10 : props.defaultPageSize);
        const innerCurrentPage = ref(isAbsent(props.defaultCurrentPage) ? 1 : props.defaultCurrentPage);
        const pageSizeBridge = computed({
          get() {
            return isAbsent(props.pageSize) ? innerPageSize.value : props.pageSize;
          },
          set(v2) {
            if (isAbsent(props.pageSize)) {
              innerPageSize.value = v2;
            }
            if (hasPageSizeListener) {
              emit2("update:page-size", v2);
              emit2("size-change", v2);
            }
          }
        });
        const pageCountBridge = 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 = computed({
          get() {
            return isAbsent(props.currentPage) ? innerCurrentPage.value : props.currentPage;
          },
          set(v2) {
            let newCurrentPage = v2;
            if (v2 < 1) {
              newCurrentPage = 1;
            } else if (v2 > pageCountBridge.value) {
              newCurrentPage = pageCountBridge.value;
            }
            if (isAbsent(props.currentPage)) {
              innerCurrentPage.value = newCurrentPage;
            }
            if (hasCurrentPageListener) {
              emit2("update:current-page", newCurrentPage);
              emit2("current-change", newCurrentPage);
            }
          }
        });
        watch(pageCountBridge, (val) => {
          if (currentPageBridge.value > val)
            currentPageBridge.value = val;
        });
        function handleCurrentChange2(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;
          emit2("prev-click", currentPageBridge.value);
        }
        function next() {
          if (props.disabled)
            return;
          currentPageBridge.value += 1;
          emit2("next-click", currentPageBridge.value);
        }
        function addClass2(element, cls) {
          if (element) {
            if (!element.props) {
              element.props = {};
            }
            element.props.class = [element.props.class, cls].join(" ");
          }
        }
        provide(elPaginationKey, {
          pageCount: pageCountBridge,
          disabled: computed(() => props.disabled),
          currentPage: currentPageBridge,
          changeEvent: handleCurrentChange2,
          handleSizeChange
        });
        return () => {
          var _a2, _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 = h$1("div", { class: ns.e("rightwrapper") }, rightWrapperChildren);
          const TEMPLATE_MAP = {
            prev: h$1(Prev, {
              disabled: props.disabled,
              currentPage: currentPageBridge.value,
              prevText: props.prevText,
              prevIcon: props.prevIcon,
              onClick: prev
            }),
            jumper: h$1(Jumper, {
              size: props.small ? "small" : "default"
            }),
            pager: h$1(Pager, {
              currentPage: currentPageBridge.value,
              pageCount: pageCountBridge.value,
              pagerCount: props.pagerCount,
              onChange: handleCurrentChange2,
              disabled: props.disabled
            }),
            next: h$1(Next, {
              disabled: props.disabled,
              currentPage: currentPageBridge.value,
              pageCount: pageCountBridge.value,
              nextText: props.nextText,
              nextIcon: props.nextIcon,
              onClick: next
            }),
            sizes: h$1(Sizes, {
              pageSize: pageSizeBridge.value,
              pageSizes: props.pageSizes,
              popperClass: props.popperClass,
              disabled: props.disabled,
              teleported: props.teleported,
              size: props.small ? "small" : "default"
            }),
            slot: (_b = (_a2 = slots == null ? void 0 : slots.default) == null ? void 0 : _a2.call(slots)) != null ? _b : null,
            total: h$1(Total, { total: isAbsent(props.total) ? 0 : props.total })
          };
          const components = props.layout.split(",").map((item) => item.trim());
          let haveRightWrapper = false;
          components.forEach((c2) => {
            if (c2 === "->") {
              haveRightWrapper = true;
              return;
            }
            if (!haveRightWrapper) {
              rootChildren.push(TEMPLATE_MAP[c2]);
            } else {
              rightWrapperChildren.push(TEMPLATE_MAP[c2]);
            }
          });
          addClass2(rootChildren[0], ns.is("first"));
          addClass2(rootChildren[rootChildren.length - 1], ns.is("last"));
          if (haveRightWrapper && rightWrapperChildren.length > 0) {
            addClass2(rightWrapperChildren[0], ns.is("first"));
            addClass2(rightWrapperChildren[rightWrapperChildren.length - 1], ns.is("last"));
            rootChildren.push(rightWrapperRoot);
          }
          return h$1("div", {
            class: [
              ns.b(),
              ns.is("background", props.background),
              {
                [ns.m("small")]: props.small
              }
            ]
          }, 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: {
        type: Boolean,
        default: false
      },
      hideAfter: {
        type: Number,
        default: 200
      },
      teleported: useTooltipContentProps.teleported,
      persistent: useTooltipContentProps.persistent,
      width: {
        type: [String, Number],
        default: 150
      }
    });
    const popconfirmEmits = {
      confirm: (e) => e instanceof MouseEvent,
      cancel: (e) => e instanceof MouseEvent
    };
    const __default__$z = /* @__PURE__ */ defineComponent({
      name: "ElPopconfirm"
    });
    const _sfc_main$N = /* @__PURE__ */ defineComponent({
      ...__default__$z,
      props: popconfirmProps,
      emits: popconfirmEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("popconfirm");
        const tooltipRef = ref();
        const hidePopper = () => {
          var _a2, _b;
          (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.onClose) == null ? void 0 : _b.call(_a2);
        };
        const style = computed(() => {
          return {
            width: addUnit(props.width)
          };
        });
        const confirm = (e) => {
          emit2("confirm", e);
          hidePopper();
        };
        const cancel = (e) => {
          emit2("cancel", e);
          hidePopper();
        };
        const finalConfirmButtonText = computed(() => props.confirmButtonText || t("el.popconfirm.confirmButtonText"));
        const finalCancelButtonText = computed(() => props.cancelButtonText || t("el.popconfirm.cancelButtonText"));
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElTooltip), mergeProps({
            ref_key: "tooltipRef",
            ref: tooltipRef,
            trigger: "click",
            effect: "light"
          }, _ctx.$attrs, {
            "popper-class": `${unref(ns).namespace.value}-popover`,
            "popper-style": unref(style),
            teleported: _ctx.teleported,
            "fallback-placements": ["bottom", "top", "right", "left"],
            "hide-after": _ctx.hideAfter,
            persistent: _ctx.persistent
          }), {
            content: withCtx(() => [
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).b())
              }, [
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("main"))
                }, [
                  !_ctx.hideIcon && _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), {
                    key: 0,
                    class: normalizeClass(unref(ns).e("icon")),
                    style: normalizeStyle({ color: _ctx.iconColor })
                  }, {
                    default: withCtx(() => [
                      (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
                    ]),
                    _: 1
                  }, 8, ["class", "style"])) : createCommentVNode("v-if", true),
                  createTextVNode(" " + toDisplayString(_ctx.title), 1)
                ], 2),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("action"))
                }, [
                  createVNode(unref(ElButton), {
                    size: "small",
                    type: _ctx.cancelButtonType === "text" ? "" : _ctx.cancelButtonType,
                    text: _ctx.cancelButtonType === "text",
                    onClick: cancel
                  }, {
                    default: withCtx(() => [
                      createTextVNode(toDisplayString(unref(finalCancelButtonText)), 1)
                    ]),
                    _: 1
                  }, 8, ["type", "text"]),
                  createVNode(unref(ElButton), {
                    size: "small",
                    type: _ctx.confirmButtonType === "text" ? "" : _ctx.confirmButtonType,
                    text: _ctx.confirmButtonType === "text",
                    onClick: confirm
                  }, {
                    default: withCtx(() => [
                      createTextVNode(toDisplayString(unref(finalConfirmButtonText)), 1)
                    ]),
                    _: 1
                  }, 8, ["type", "text"])
                ], 2)
              ], 2)
            ]),
            default: withCtx(() => [
              _ctx.$slots.reference ? renderSlot(_ctx.$slots, "reference", { key: 0 }) : createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 16, ["popper-class", "popper-style", "teleported", "hide-after", "persistent"]);
        };
      }
    });
    var Popconfirm = /* @__PURE__ */ _export_sfc$1(_sfc_main$N, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popconfirm/src/popconfirm.vue"]]);
    const ElPopconfirm = withInstall(Popconfirm);
    const popoverProps = buildProps({
      trigger: useTooltipTriggerProps.trigger,
      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,
      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__$y = /* @__PURE__ */ defineComponent({
      name: "ElPopover"
    });
    const _sfc_main$M = /* @__PURE__ */ defineComponent({
      ...__default__$y,
      props: popoverProps,
      emits: popoverEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const onUpdateVisible = computed(() => {
          return props[updateEventKeyRaw];
        });
        const ns = useNamespace("popover");
        const tooltipRef = ref();
        const popperRef = computed(() => {
          var _a2;
          return (_a2 = unref(tooltipRef)) == null ? void 0 : _a2.popperRef;
        });
        const style = computed(() => {
          return [
            {
              width: addUnit(props.width)
            },
            props.popperStyle
          ];
        });
        const kls = computed(() => {
          return [ns.b(), props.popperClass, { [ns.m("plain")]: !!props.content }];
        });
        const gpuAcceleration = computed(() => {
          return props.transition === `${ns.namespace.value}-fade-in-linear`;
        });
        const hide = () => {
          var _a2;
          (_a2 = tooltipRef.value) == null ? void 0 : _a2.hide();
        };
        const beforeEnter = () => {
          emit2("before-enter");
        };
        const beforeLeave = () => {
          emit2("before-leave");
        };
        const afterEnter = () => {
          emit2("after-enter");
        };
        const afterLeave = () => {
          emit2("update:visible", false);
          emit2("after-leave");
        };
        expose({
          popperRef,
          hide
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElTooltip), mergeProps({
            ref_key: "tooltipRef",
            ref: tooltipRef
          }, _ctx.$attrs, {
            trigger: _ctx.trigger,
            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": unref(kls),
            "popper-style": unref(style),
            teleported: _ctx.teleported,
            persistent: _ctx.persistent,
            "gpu-acceleration": unref(gpuAcceleration),
            "onUpdate:visible": unref(onUpdateVisible),
            onBeforeShow: beforeEnter,
            onBeforeHide: beforeLeave,
            onShow: afterEnter,
            onHide: afterLeave
          }), {
            content: withCtx(() => [
              _ctx.title ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ns).e("title")),
                role: "title"
              }, toDisplayString(_ctx.title), 3)) : createCommentVNode("v-if", true),
              renderSlot(_ctx.$slots, "default", {}, () => [
                createTextVNode(toDisplayString(_ctx.content), 1)
              ])
            ]),
            default: withCtx(() => [
              _ctx.$slots.reference ? renderSlot(_ctx.$slots, "reference", { key: 0 }) : createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 16, ["trigger", "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", "persistent", "gpu-acceleration", "onUpdate:visible"]);
        };
      }
    });
    var Popover = /* @__PURE__ */ _export_sfc$1(_sfc_main$M, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popover/src/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: {
        type: Boolean,
        default: false
      },
      duration: {
        type: Number,
        default: 3
      },
      strokeWidth: {
        type: Number,
        default: 6
      },
      strokeLinecap: {
        type: definePropType(String),
        default: "round"
      },
      textInside: {
        type: Boolean,
        default: false
      },
      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 _hoisted_1$l = ["aria-valuenow"];
    const _hoisted_2$e = { viewBox: "0 0 100 100" };
    const _hoisted_3$6 = ["d", "stroke", "stroke-linecap", "stroke-width"];
    const _hoisted_4$4 = ["d", "stroke", "opacity", "stroke-linecap", "stroke-width"];
    const _hoisted_5$3 = { key: 0 };
    const __default__$x = /* @__PURE__ */ defineComponent({
      name: "ElProgress"
    });
    const _sfc_main$L = /* @__PURE__ */ defineComponent({
      ...__default__$x,
      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 = computed(() => ({
          width: `${props.percentage}%`,
          animationDuration: `${props.duration}s`,
          backgroundColor: getCurrentColor(props.percentage)
        }));
        const relativeStrokeWidth = computed(() => (props.strokeWidth / props.width * 100).toFixed(1));
        const radius = computed(() => {
          if (["circle", "dashboard"].includes(props.type)) {
            return Number.parseInt(`${50 - Number.parseFloat(relativeStrokeWidth.value) / 2}`, 10);
          }
          return 0;
        });
        const trackPath = 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 = computed(() => 2 * Math.PI * radius.value);
        const rate = computed(() => props.type === "dashboard" ? 0.75 : 1);
        const strokeDashoffset = computed(() => {
          const offset2 = -1 * perimeter.value * (1 - rate.value) / 2;
          return `${offset2}px`;
        });
        const trailPathStyle = computed(() => ({
          strokeDasharray: `${perimeter.value * rate.value}px, ${perimeter.value}px`,
          strokeDashoffset: strokeDashoffset.value
        }));
        const circlePathStyle = 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 = 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 = 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 = computed(() => {
          return props.type === "line" ? 12 + props.strokeWidth * 0.4 : props.width * 0.111111 + 2;
        });
        const content = computed(() => props.format(props.percentage));
        function getColors(color) {
          const span = 100 / color.length;
          const seriesColors = color.map((seriesColor, index2) => {
            if (isString$1(seriesColor)) {
              return {
                color: seriesColor,
                percentage: (index2 + 1) * span
              };
            }
            return seriesColor;
          });
          return seriesColors.sort((a2, b2) => a2.percentage - b2.percentage);
        }
        const getCurrentColor = (percentage) => {
          var _a2;
          const { color } = props;
          if (isFunction$2(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 (_a2 = colors[colors.length - 1]) == null ? void 0 : _a2.color;
          }
        };
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([
              unref(ns).b(),
              unref(ns).m(_ctx.type),
              unref(ns).is(_ctx.status),
              {
                [unref(ns).m("without-text")]: !_ctx.showText,
                [unref(ns).m("text-inside")]: _ctx.textInside
              }
            ]),
            role: "progressbar",
            "aria-valuenow": _ctx.percentage,
            "aria-valuemin": "0",
            "aria-valuemax": "100"
          }, [
            _ctx.type === "line" ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).b("bar"))
            }, [
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).be("bar", "outer")),
                style: normalizeStyle({ height: `${_ctx.strokeWidth}px` })
              }, [
                createBaseVNode("div", {
                  class: normalizeClass([
                    unref(ns).be("bar", "inner"),
                    { [unref(ns).bem("bar", "inner", "indeterminate")]: _ctx.indeterminate },
                    { [unref(ns).bem("bar", "inner", "striped")]: _ctx.striped },
                    { [unref(ns).bem("bar", "inner", "striped-flow")]: _ctx.stripedFlow }
                  ]),
                  style: normalizeStyle(unref(barStyle))
                }, [
                  (_ctx.showText || _ctx.$slots.default) && _ctx.textInside ? (openBlock(), createElementBlock("div", {
                    key: 0,
                    class: normalizeClass(unref(ns).be("bar", "innerText"))
                  }, [
                    renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
                      createBaseVNode("span", null, toDisplayString(unref(content)), 1)
                    ])
                  ], 2)) : createCommentVNode("v-if", true)
                ], 6)
              ], 6)
            ], 2)) : (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(unref(ns).b("circle")),
              style: normalizeStyle({ height: `${_ctx.width}px`, width: `${_ctx.width}px` })
            }, [
              (openBlock(), createElementBlock("svg", _hoisted_2$e, [
                createBaseVNode("path", {
                  class: normalizeClass(unref(ns).be("circle", "track")),
                  d: unref(trackPath),
                  stroke: `var(${unref(ns).cssVarName("fill-color-light")}, #e5e9f2)`,
                  "stroke-linecap": _ctx.strokeLinecap,
                  "stroke-width": unref(relativeStrokeWidth),
                  fill: "none",
                  style: normalizeStyle(unref(trailPathStyle))
                }, null, 14, _hoisted_3$6),
                createBaseVNode("path", {
                  class: normalizeClass(unref(ns).be("circle", "path")),
                  d: unref(trackPath),
                  stroke: unref(stroke),
                  fill: "none",
                  opacity: _ctx.percentage ? 1 : 0,
                  "stroke-linecap": _ctx.strokeLinecap,
                  "stroke-width": unref(relativeStrokeWidth),
                  style: normalizeStyle(unref(circlePathStyle))
                }, null, 14, _hoisted_4$4)
              ]))
            ], 6)),
            (_ctx.showText || _ctx.$slots.default) && !_ctx.textInside ? (openBlock(), createElementBlock("div", {
              key: 2,
              class: normalizeClass(unref(ns).e("text")),
              style: normalizeStyle({ fontSize: `${unref(progressTextSize)}px` })
            }, [
              renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
                !_ctx.status ? (openBlock(), createElementBlock("span", _hoisted_5$3, toDisplayString(unref(content)), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(unref(statusIcon))))
                  ]),
                  _: 1
                }))
              ])
            ], 6)) : createCommentVNode("v-if", true)
          ], 10, _hoisted_1$l);
        };
      }
    });
    var Progress = /* @__PURE__ */ _export_sfc$1(_sfc_main$L, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/progress/src/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,
      label: {
        type: String,
        default: void 0
      },
      clearable: {
        type: Boolean,
        default: false
      }
    });
    const rateEmits = {
      [CHANGE_EVENT]: (value) => isNumber(value),
      [UPDATE_MODEL_EVENT]: (value) => isNumber(value)
    };
    const _hoisted_1$k = ["id", "aria-label", "aria-labelledby", "aria-valuenow", "aria-valuetext", "aria-valuemax"];
    const _hoisted_2$d = ["onMousemove", "onClick"];
    const __default__$w = /* @__PURE__ */ defineComponent({
      name: "ElRate"
    });
    const _sfc_main$K = /* @__PURE__ */ defineComponent({
      ...__default__$w,
      props: rateProps,
      emits: rateEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        function getValueFromMap(value, map2) {
          const isExcludedObject = (val) => isObject$1(val);
          const matchedKeys = Object.keys(map2).map((key) => +key).filter((key) => {
            const val = map2[key];
            const excluded = isExcludedObject(val) ? val.excluded : false;
            return excluded ? value < key : value <= key;
          }).sort((a2, b2) => a2 - b2);
          const matchedValue = map2[matchedKeys[0]];
          return isExcludedObject(matchedValue) && matchedValue.value || matchedValue;
        }
        const formContext = inject(formContextKey, void 0);
        const formItemContext = inject(formItemContextKey, void 0);
        const rateSize = useFormSize();
        const ns = useNamespace("rate");
        const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext
        });
        const currentValue = ref(props.modelValue);
        const hoverIndex = ref(-1);
        const pointerAtLeftHalf = ref(true);
        const rateClasses = computed(() => [ns.b(), ns.m(rateSize.value)]);
        const rateDisabled = computed(() => props.disabled || (formContext == null ? void 0 : formContext.disabled));
        const rateStyles = computed(() => {
          return ns.cssVarBlock({
            "void-color": props.voidColor,
            "disabled-void-color": props.disabledVoidColor,
            "fill-color": activeColor.value
          });
        });
        const text = 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 = computed(() => props.modelValue * 100 - Math.floor(props.modelValue) * 100);
        const colorMap = computed(() => isArray$3(props.colors) ? {
          [props.lowThreshold]: props.colors[0],
          [props.highThreshold]: { value: props.colors[1], excluded: true },
          [props.max]: props.colors[2]
        } : props.colors);
        const activeColor = computed(() => {
          const color = getValueFromMap(currentValue.value, colorMap.value);
          return isObject$1(color) ? "" : color;
        });
        const decimalStyle = computed(() => {
          let width = "";
          if (rateDisabled.value) {
            width = `${valueDecimal.value}%`;
          } else if (props.allowHalf) {
            width = "50%";
          }
          return {
            color: activeColor.value,
            width
          };
        });
        const componentMap = computed(() => {
          let icons = isArray$3(props.icons) ? [...props.icons] : { ...props.icons };
          icons = markRaw(icons);
          return isArray$3(icons) ? {
            [props.lowThreshold]: icons[0],
            [props.highThreshold]: {
              value: icons[1],
              excluded: true
            },
            [props.max]: icons[2]
          } : icons;
        });
        const decimalIconComponent = computed(() => getValueFromMap(props.modelValue, componentMap.value));
        const voidComponent = computed(() => rateDisabled.value ? isString$1(props.disabledVoidIcon) ? props.disabledVoidIcon : markRaw(props.disabledVoidIcon) : isString$1(props.voidIcon) ? props.voidIcon : markRaw(props.voidIcon));
        const activeComponent = 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;
          }
          emit2(UPDATE_MODEL_EVENT, value);
          if (props.modelValue !== value) {
            emit2("change", 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;
          }
          let _currentValue = currentValue.value;
          const code = e.code;
          if (code === EVENT_CODE.up || code === EVENT_CODE.right) {
            if (props.allowHalf) {
              _currentValue += 0.5;
            } else {
              _currentValue += 1;
            }
            e.stopPropagation();
            e.preventDefault();
          } else if (code === EVENT_CODE.left || code === EVENT_CODE.down) {
            if (props.allowHalf) {
              _currentValue -= 0.5;
            } else {
              _currentValue -= 1;
            }
            e.stopPropagation();
            e.preventDefault();
          }
          _currentValue = _currentValue < 0 ? 0 : _currentValue;
          _currentValue = _currentValue > props.max ? props.max : _currentValue;
          emit2(UPDATE_MODEL_EVENT, _currentValue);
          emit2("change", _currentValue);
          return _currentValue;
        }
        function setCurrentValue(value, event) {
          if (rateDisabled.value) {
            return;
          }
          if (props.allowHalf && event) {
            let target = event.target;
            if (hasClass(target, ns.e("item"))) {
              target = target.querySelector(`.${ns.e("icon")}`);
            }
            if (target.clientWidth === 0 || hasClass(target, ns.e("decimal"))) {
              target = target.parentNode;
            }
            pointerAtLeftHalf.value = event.offsetX * 2 <= target.clientWidth;
            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;
        }
        watch(() => props.modelValue, (val) => {
          currentValue.value = val;
          pointerAtLeftHalf.value = props.modelValue !== Math.floor(props.modelValue);
        });
        if (!props.modelValue) {
          emit2(UPDATE_MODEL_EVENT, 0);
        }
        expose({
          setCurrentValue,
          resetCurrentValue
        });
        return (_ctx, _cache) => {
          var _a2;
          return openBlock(), createElementBlock("div", {
            id: unref(inputId),
            class: normalizeClass([unref(rateClasses), unref(ns).is("disabled", unref(rateDisabled))]),
            role: "slider",
            "aria-label": !unref(isLabeledByFormItem) ? _ctx.label || "rating" : void 0,
            "aria-labelledby": unref(isLabeledByFormItem) ? (_a2 = unref(formItemContext)) == null ? void 0 : _a2.labelId : void 0,
            "aria-valuenow": currentValue.value,
            "aria-valuetext": unref(text) || void 0,
            "aria-valuemin": "0",
            "aria-valuemax": _ctx.max,
            tabindex: "0",
            style: normalizeStyle(unref(rateStyles)),
            onKeydown: handleKey
          }, [
            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.max, (item, key) => {
              return openBlock(), createElementBlock("span", {
                key,
                class: normalizeClass(unref(ns).e("item")),
                onMousemove: ($event) => setCurrentValue(item, $event),
                onMouseleave: resetCurrentValue,
                onClick: ($event) => selectValue(item)
              }, [
                createVNode(unref(ElIcon), {
                  class: normalizeClass([
                    unref(ns).e("icon"),
                    { hover: hoverIndex.value === item },
                    unref(ns).is("active", item <= currentValue.value)
                  ])
                }, {
                  default: withCtx(() => [
                    !showDecimalIcon(item) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                      withDirectives((openBlock(), createBlock(resolveDynamicComponent(unref(activeComponent)), null, null, 512)), [
                        [vShow, item <= currentValue.value]
                      ]),
                      withDirectives((openBlock(), createBlock(resolveDynamicComponent(unref(voidComponent)), null, null, 512)), [
                        [vShow, !(item <= currentValue.value)]
                      ])
                    ], 64)) : createCommentVNode("v-if", true),
                    showDecimalIcon(item) ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
                      (openBlock(), createBlock(resolveDynamicComponent(unref(voidComponent)), {
                        class: normalizeClass([unref(ns).em("decimal", "box")])
                      }, null, 8, ["class"])),
                      createVNode(unref(ElIcon), {
                        style: normalizeStyle(unref(decimalStyle)),
                        class: normalizeClass([unref(ns).e("icon"), unref(ns).e("decimal")])
                      }, {
                        default: withCtx(() => [
                          (openBlock(), createBlock(resolveDynamicComponent(unref(decimalIconComponent))))
                        ]),
                        _: 1
                      }, 8, ["style", "class"])
                    ], 64)) : createCommentVNode("v-if", true)
                  ]),
                  _: 2
                }, 1032, ["class"])
              ], 42, _hoisted_2$d);
            }), 128)),
            _ctx.showText || _ctx.showScore ? (openBlock(), createElementBlock("span", {
              key: 0,
              class: normalizeClass(unref(ns).e("text")),
              style: normalizeStyle({ color: _ctx.textColor })
            }, toDisplayString(unref(text)), 7)) : createCommentVNode("v-if", true)
          ], 46, _hoisted_1$k);
        };
      }
    });
    var Rate = /* @__PURE__ */ _export_sfc$1(_sfc_main$K, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/rate/src/rate.vue"]]);
    const ElRate = withInstall(Rate);
    const IconMap = {
      success: "icon-success",
      warning: "icon-warning",
      error: "icon-error",
      info: "icon-info"
    };
    const IconComponentMap = {
      [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: ["success", "warning", "info", "error"],
        default: "info"
      }
    });
    const __default__$v = /* @__PURE__ */ defineComponent({
      name: "ElResult"
    });
    const _sfc_main$J = /* @__PURE__ */ defineComponent({
      ...__default__$v,
      props: resultProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("result");
        const resultIcon = 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 openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(ns).b())
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("icon"))
            }, [
              renderSlot(_ctx.$slots, "icon", {}, () => [
                unref(resultIcon).component ? (openBlock(), createBlock(resolveDynamicComponent(unref(resultIcon).component), {
                  key: 0,
                  class: normalizeClass(unref(resultIcon).class)
                }, null, 8, ["class"])) : createCommentVNode("v-if", true)
              ])
            ], 2),
            _ctx.title || _ctx.$slots.title ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("title"))
            }, [
              renderSlot(_ctx.$slots, "title", {}, () => [
                createBaseVNode("p", null, toDisplayString(_ctx.title), 1)
              ])
            ], 2)) : createCommentVNode("v-if", true),
            _ctx.subTitle || _ctx.$slots["sub-title"] ? (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(unref(ns).e("subtitle"))
            }, [
              renderSlot(_ctx.$slots, "sub-title", {}, () => [
                createBaseVNode("p", null, toDisplayString(_ctx.subTitle), 1)
              ])
            ], 2)) : createCommentVNode("v-if", true),
            _ctx.$slots.extra ? (openBlock(), createElementBlock("div", {
              key: 2,
              class: normalizeClass(unref(ns).e("extra"))
            }, [
              renderSlot(_ctx.$slots, "extra")
            ], 2)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var Result = /* @__PURE__ */ _export_sfc$1(_sfc_main$J, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/result/src/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 cache2 = null;
      function memoized() {
        var newArgs = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          newArgs[_i] = arguments[_i];
        }
        if (cache2 && cache2.lastThis === this && isEqual2(newArgs, cache2.lastArgs)) {
          return cache2.lastResult;
        }
        var lastResult = resultFn.apply(this, newArgs);
        cache2 = {
          lastResult,
          lastArgs: newArgs,
          lastThis: this
        };
        return lastResult;
      }
      memoized.clear = function clear2() {
        cache2 = null;
      };
      return memoized;
    }
    const useCache = () => {
      const vm = getCurrentInstance();
      const props = vm.proxy.$props;
      return computed(() => {
        const _getItemStyleCache = (_2, __, ___) => ({});
        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: layout2 }, onWheelDelta) => {
      let frameHandle;
      let offset2 = 0;
      const hasReachedEdge = (offset22) => {
        const edgeReached = offset22 < 0 && atStartEdge.value || offset22 > 0 && atEndEdge.value;
        return edgeReached;
      };
      const onWheel = (e) => {
        cAF(frameHandle);
        const newOffset = e[LayoutKeys[layout2.value]];
        if (hasReachedEdge(offset2) && hasReachedEdge(offset2 + newOffset))
          return;
        offset2 += newOffset;
        if (!isFirefox()) {
          e.preventDefault();
        }
        frameHandle = rAF(() => {
          onWheelDelta(offset2);
          offset2 = 0;
        });
      };
      return {
        hasReachedEdge,
        onWheel
      };
    };
    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"
      },
      style: {
        type: definePropType([Object, String, Array])
      },
      useIsScrolling: {
        type: Boolean,
        default: false
      },
      width: {
        type: [Number, String],
        required: false
      },
      perfMode: {
        type: Boolean,
        default: true
      },
      scrollbarAlwaysOn: {
        type: Boolean,
        default: false
      }
    });
    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: size2, bar }, layout2) {
      const style = {};
      const translate2 = `translate${bar.axis}(${move}px)`;
      style[bar.size] = size2;
      style.transform = translate2;
      style.msTransform = translate2;
      style.webkitTransform = translate2;
      if (layout2 === "horizontal") {
        style.height = "100%";
      } else {
        style.width = "100%";
      }
      return style;
    }
    const ScrollBar = /* @__PURE__ */ defineComponent({
      name: "ElVirtualScrollBar",
      props: virtualizedScrollbarProps,
      emits: ["scroll", "start-move", "stop-move"],
      setup(props, { emit: emit2 }) {
        const GAP2 = computed(() => props.startGap + props.endGap);
        const nsVirtualScrollbar = useNamespace("virtual-scrollbar");
        const nsScrollbar = useNamespace("scrollbar");
        const trackRef = ref();
        const thumbRef = ref();
        let frameHandle = null;
        let onselectstartStore = null;
        const state = reactive({
          isDragging: false,
          traveled: 0
        });
        const bar = computed(() => BAR_MAP[props.layout]);
        const trackSize = computed(() => props.clientSize - unref(GAP2));
        const trackStyle = 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 = computed(() => {
          const ratio = props.ratio;
          const clientSize = props.clientSize;
          if (ratio >= 100) {
            return Number.POSITIVE_INFINITY;
          }
          if (ratio >= 50) {
            return ratio * clientSize / 100;
          }
          const SCROLLBAR_MAX_SIZE = clientSize / 3;
          return Math.floor(Math.min(Math.max(ratio * clientSize, SCROLLBAR_MIN_SIZE), SCROLLBAR_MAX_SIZE));
        });
        const thumbStyle = 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 = computed(() => Math.floor(props.clientSize - thumbSize.value - unref(GAP2)));
        const attachEvents2 = () => {
          window.addEventListener("mousemove", onMouseMove);
          window.addEventListener("mouseup", onMouseUp);
          const thumbEl = unref(thumbRef);
          if (!thumbEl)
            return;
          onselectstartStore = document.onselectstart;
          document.onselectstart = () => false;
          thumbEl.addEventListener("touchmove", onMouseMove);
          thumbEl.addEventListener("touchend", onMouseUp);
        };
        const detachEvents = () => {
          window.removeEventListener("mousemove", onMouseMove);
          window.removeEventListener("mouseup", onMouseUp);
          document.onselectstart = onselectstartStore;
          onselectstartStore = null;
          const thumbEl = 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]);
          emit2("start-move");
          attachEvents2();
        };
        const onMouseUp = () => {
          state.isDragging = false;
          state[bar.value.axis] = 0;
          emit2("stop-move");
          detachEvents();
        };
        const onMouseMove = (e) => {
          const { isDragging: isDragging2 } = state;
          if (!isDragging2)
            return;
          if (!thumbRef.value || !trackRef.value)
            return;
          const prevPage = state[bar.value.axis];
          if (!prevPage)
            return;
          cAF(frameHandle);
          const offset2 = (trackRef.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
          const thumbClickPosition = thumbRef.value[bar.value.offset] - prevPage;
          const distance = offset2 - thumbClickPosition;
          frameHandle = rAF(() => {
            state.traveled = Math.max(props.startGap, Math.min(distance, totalSteps.value));
            emit2("scroll", distance, totalSteps.value);
          });
        };
        const clickTrackHandler = (e) => {
          const offset2 = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
          const thumbHalf = thumbRef.value[bar.value.offset] / 2;
          const distance = offset2 - thumbHalf;
          state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
          emit2("scroll", distance, totalSteps.value);
        };
        watch(() => props.scrollFrom, (v2) => {
          if (state.isDragging)
            return;
          state.traveled = Math.ceil(v2 * totalSteps.value);
        });
        onBeforeUnmount(() => {
          detachEvents();
        });
        return () => {
          return h$1("div", {
            role: "presentation",
            ref: trackRef,
            class: [
              nsVirtualScrollbar.b(),
              props.class,
              (props.alwaysOn || state.isDragging) && "always-on"
            ],
            style: trackStyle.value,
            onMousedown: withModifiers(clickTrackHandler, ["stop", "prevent"]),
            onTouchstartPrevent: onThumbMouseDown
          }, h$1("div", {
            ref: thumbRef,
            class: nsScrollbar.e("thumb"),
            style: thumbStyle.value,
            onMousedown: onThumbMouseDown
          }, []));
        };
      }
    });
    const createList = ({
      name,
      getOffset: getOffset2,
      getItemSize,
      getItemOffset,
      getEstimatedTotalSize: getEstimatedTotalSize2,
      getStartIndexForOffset,
      getStopIndexForStartIndex,
      initCache,
      clearCache,
      validateProps
    }) => {
      return /* @__PURE__ */ defineComponent({
        name: name != null ? name : "ElVirtualList",
        props: virtualizedListProps,
        emits: [ITEM_RENDER_EVT, SCROLL_EVT],
        setup(props, { emit: emit2, expose }) {
          validateProps(props);
          const instance = getCurrentInstance();
          const ns = useNamespace("vl");
          const dynamicSizeCache = ref(initCache(props, instance));
          const getItemStyleCache = useCache();
          const windowRef = ref();
          const innerRef = ref();
          const scrollbarRef = ref();
          const states = ref({
            isScrolling: false,
            scrollDir: "forward",
            scrollOffset: isNumber(props.initScrollOffset) ? props.initScrollOffset : 0,
            updateRequested: false,
            isScrollbarDragging: false,
            scrollbarAlwaysOn: props.scrollbarAlwaysOn
          });
          const itemsToRender = computed(() => {
            const { total: total2, cache: cache2 } = props;
            const { isScrolling, scrollDir, scrollOffset } = unref(states);
            if (total2 === 0) {
              return [0, 0, 0, 0];
            }
            const startIndex = getStartIndexForOffset(props, scrollOffset, unref(dynamicSizeCache));
            const stopIndex = getStopIndexForStartIndex(props, startIndex, scrollOffset, unref(dynamicSizeCache));
            const cacheBackward = !isScrolling || scrollDir === BACKWARD ? Math.max(1, cache2) : 1;
            const cacheForward = !isScrolling || scrollDir === FORWARD ? Math.max(1, cache2) : 1;
            return [
              Math.max(0, startIndex - cacheBackward),
              Math.max(0, Math.min(total2 - 1, stopIndex + cacheForward)),
              startIndex,
              stopIndex
            ];
          });
          const estimatedTotalSize = computed(() => getEstimatedTotalSize2(props, unref(dynamicSizeCache)));
          const _isHorizontal = computed(() => isHorizontal(props.layout));
          const windowStyle = 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 = computed(() => {
            const size2 = unref(estimatedTotalSize);
            const horizontal = unref(_isHorizontal);
            return {
              height: horizontal ? "100%" : `${size2}px`,
              pointerEvents: unref(states).isScrolling ? "none" : void 0,
              width: horizontal ? `${size2}px` : "100%"
            };
          });
          const clientSize = computed(() => _isHorizontal.value ? props.width : props.height);
          const { onWheel } = useWheel({
            atStartEdge: computed(() => states.value.scrollOffset <= 0),
            atEndEdge: computed(() => states.value.scrollOffset >= estimatedTotalSize.value),
            layout: computed(() => props.layout)
          }, (offset2) => {
            var _a2, _b;
            (_b = (_a2 = scrollbarRef.value).onMouseUp) == null ? void 0 : _b.call(_a2);
            scrollTo(Math.min(states.value.scrollOffset + offset2, estimatedTotalSize.value - clientSize.value));
          });
          const emitEvents = () => {
            const { total: total2 } = props;
            if (total2 > 0) {
              const [cacheStart, cacheEnd, visibleStart, visibleEnd] = unref(itemsToRender);
              emit2(ITEM_RENDER_EVT, cacheStart, cacheEnd, visibleStart, visibleEnd);
            }
            const { scrollDir, scrollOffset, updateRequested } = unref(states);
            emit2(SCROLL_EVT, scrollDir, scrollOffset, updateRequested);
          };
          const scrollVertically = (e) => {
            const { clientHeight, scrollHeight, scrollTop } = e.currentTarget;
            const _states = 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
            };
            nextTick(resetIsScrolling);
          };
          const scrollHorizontally = (e) => {
            const { clientWidth, scrollLeft, scrollWidth } = e.currentTarget;
            const _states = unref(states);
            if (_states.scrollOffset === scrollLeft) {
              return;
            }
            const { direction: direction2 } = props;
            let scrollOffset = scrollLeft;
            if (direction2 === 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
            };
            nextTick(resetIsScrolling);
          };
          const onScroll = (e) => {
            unref(_isHorizontal) ? scrollHorizontally(e) : scrollVertically(e);
            emitEvents();
          };
          const onScrollbarScroll = (distanceToGo, totalSteps) => {
            const offset2 = (estimatedTotalSize.value - clientSize.value) / totalSteps * distanceToGo;
            scrollTo(Math.min(estimatedTotalSize.value - clientSize.value, offset2));
          };
          const scrollTo = (offset2) => {
            offset2 = Math.max(offset2, 0);
            if (offset2 === unref(states).scrollOffset) {
              return;
            }
            states.value = {
              ...unref(states),
              scrollOffset: offset2,
              scrollDir: getScrollDir(unref(states).scrollOffset, offset2),
              updateRequested: true
            };
            nextTick(resetIsScrolling);
          };
          const scrollToItem = (idx, alignment = AUTO_ALIGNMENT) => {
            const { scrollOffset } = unref(states);
            idx = Math.max(0, Math.min(idx, props.total - 1));
            scrollTo(getOffset2(props, idx, alignment, scrollOffset, unref(dynamicSizeCache)));
          };
          const getItemStyle = (idx) => {
            const { direction: direction2, itemSize: itemSize2, layout: layout2 } = props;
            const itemStyleCache = getItemStyleCache.value(clearCache && itemSize2, clearCache && layout2, clearCache && direction2);
            let style;
            if (hasOwn(itemStyleCache, String(idx))) {
              style = itemStyleCache[idx];
            } else {
              const offset2 = getItemOffset(props, idx, unref(dynamicSizeCache));
              const size2 = getItemSize(props, idx, unref(dynamicSizeCache));
              const horizontal = unref(_isHorizontal);
              const isRtl = direction2 === RTL;
              const offsetHorizontal = horizontal ? offset2 : 0;
              itemStyleCache[idx] = style = {
                position: "absolute",
                left: isRtl ? void 0 : `${offsetHorizontal}px`,
                right: isRtl ? `${offsetHorizontal}px` : void 0,
                top: !horizontal ? `${offset2}px` : 0,
                height: !horizontal ? `${size2}px` : "100%",
                width: horizontal ? `${size2}px` : "100%"
              };
            }
            return style;
          };
          const resetIsScrolling = () => {
            states.value.isScrolling = false;
            nextTick(() => {
              getItemStyleCache.value(-1, null, null);
            });
          };
          const resetScrollTop = () => {
            const window2 = windowRef.value;
            if (window2) {
              window2.scrollTop = 0;
            }
          };
          onMounted(() => {
            if (!isClient)
              return;
            const { initScrollOffset: initScrollOffset2 } = props;
            const windowElement = unref(windowRef);
            if (isNumber(initScrollOffset2) && windowElement) {
              if (unref(_isHorizontal)) {
                windowElement.scrollLeft = initScrollOffset2;
              } else {
                windowElement.scrollTop = initScrollOffset2;
              }
            }
            emitEvents();
          });
          onUpdated(() => {
            const { direction: direction2, layout: layout2 } = props;
            const { scrollOffset, updateRequested } = unref(states);
            const windowElement = unref(windowRef);
            if (updateRequested && windowElement) {
              if (layout2 === HORIZONTAL) {
                if (direction2 === 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;
              }
            }
          });
          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 _a2;
          const {
            $slots,
            className,
            clientSize,
            containerElement,
            data,
            getItemStyle,
            innerElement,
            itemsToRender,
            innerStyle,
            layout: layout2,
            total: total2,
            onScroll,
            onScrollbarScroll,
            onWheel,
            states,
            useIsScrolling,
            windowStyle,
            ns
          } = ctx;
          const [start, end2] = itemsToRender;
          const Container2 = resolveDynamicComponent(containerElement);
          const Inner = resolveDynamicComponent(innerElement);
          const children = [];
          if (total2 > 0) {
            for (let i = start; i <= end2; i++) {
              children.push((_a2 = $slots.default) == null ? void 0 : _a2.call($slots, {
                data,
                key: i,
                index: i,
                isScrolling: useIsScrolling ? states.isScrolling : void 0,
                style: getItemStyle(i)
              }));
            }
          }
          const InnerNode = [
            h$1(Inner, {
              style: innerStyle,
              ref: "innerRef"
            }, !isString$1(Inner) ? {
              default: () => children
            } : children)
          ];
          const scrollbar = h$1(ScrollBar, {
            ref: "scrollbarRef",
            clientSize,
            layout: layout2,
            onScroll: onScrollbarScroll,
            ratio: clientSize * 100 / this.estimatedTotalSize,
            scrollFrom: states.scrollOffset / (this.estimatedTotalSize - clientSize),
            total: total2
          });
          const listContainer = h$1(Container2, {
            class: [ns.e("window"), className],
            style: windowStyle,
            onScroll,
            onWheel,
            ref: "windowRef",
            key: 0
          }, !isString$1(Container2) ? { default: () => [InnerNode] } : [InnerNode]);
          return h$1("div", {
            key: 0,
            class: [ns.e("wrapper"), states.scrollbarAlwaysOn ? "always-on" : ""]
          }, [listContainer, scrollbar]);
        }
      });
    };
    const FixedSizeList = createList({
      name: "ElFixedSizeList",
      getItemOffset: ({ itemSize: itemSize2 }, index2) => index2 * itemSize2,
      getItemSize: ({ itemSize: itemSize2 }) => itemSize2,
      getEstimatedTotalSize: ({ total: total2, itemSize: itemSize2 }) => itemSize2 * total2,
      getOffset: ({ height, total: total2, itemSize: itemSize2, layout: layout2, width }, index2, alignment, scrollOffset) => {
        const size2 = isHorizontal(layout2) ? width : height;
        const lastItemOffset = Math.max(0, total2 * itemSize2 - size2);
        const maxOffset = Math.min(lastItemOffset, index2 * itemSize2);
        const minOffset = Math.max(0, (index2 + 1) * itemSize2 - size2);
        if (alignment === SMART_ALIGNMENT) {
          if (scrollOffset >= minOffset - size2 && scrollOffset <= maxOffset + size2) {
            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(size2 / 2)) {
              return 0;
            } else if (middleOffset > lastItemOffset + Math.floor(size2 / 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: total2, itemSize: itemSize2 }, offset2) => Math.max(0, Math.min(total2 - 1, Math.floor(offset2 / itemSize2))),
      getStopIndexForStartIndex: ({ height, total: total2, itemSize: itemSize2, layout: layout2, width }, startIndex, scrollOffset) => {
        const offset2 = startIndex * itemSize2;
        const size2 = isHorizontal(layout2) ? width : height;
        const numVisibleItems = Math.ceil((size2 + scrollOffset - offset2) / itemSize2);
        return Math.max(0, Math.min(total2 - 1, startIndex + numVisibleItems - 1));
      },
      initCache() {
        return void 0;
      },
      clearCache: true,
      validateProps() {
      }
    });
    const getItemFromCache$1 = (props, index2, listCache) => {
      const { itemSize: itemSize2 } = props;
      const { items, lastVisitedIndex } = listCache;
      if (index2 > lastVisitedIndex) {
        let offset2 = 0;
        if (lastVisitedIndex >= 0) {
          const item = items[lastVisitedIndex];
          offset2 = item.offset + item.size;
        }
        for (let i = lastVisitedIndex + 1; i <= index2; i++) {
          const size2 = itemSize2(i);
          items[i] = {
            offset: offset2,
            size: size2
          };
          offset2 += size2;
        }
        listCache.lastVisitedIndex = index2;
      }
      return items[index2];
    };
    const findItem$1 = (props, listCache, offset2) => {
      const { items, lastVisitedIndex } = listCache;
      const lastVisitedOffset = lastVisitedIndex > 0 ? items[lastVisitedIndex].offset : 0;
      if (lastVisitedOffset >= offset2) {
        return bs$1(props, listCache, 0, lastVisitedIndex, offset2);
      }
      return es$1(props, listCache, Math.max(0, lastVisitedIndex), offset2);
    };
    const bs$1 = (props, listCache, low, high, offset2) => {
      while (low <= high) {
        const mid = low + Math.floor((high - low) / 2);
        const currentOffset = getItemFromCache$1(props, mid, listCache).offset;
        if (currentOffset === offset2) {
          return mid;
        } else if (currentOffset < offset2) {
          low = mid + 1;
        } else if (currentOffset > offset2) {
          high = mid - 1;
        }
      }
      return Math.max(0, low - 1);
    };
    const es$1 = (props, listCache, index2, offset2) => {
      const { total: total2 } = props;
      let exponent = 1;
      while (index2 < total2 && getItemFromCache$1(props, index2, listCache).offset < offset2) {
        index2 += exponent;
        exponent *= 2;
      }
      return bs$1(props, listCache, Math.floor(index2 / 2), Math.min(index2, total2 - 1), offset2);
    };
    const getEstimatedTotalSize = ({ total: total2 }, { items, estimatedItemSize: estimatedItemSize2, lastVisitedIndex }) => {
      let totalSizeOfMeasuredItems = 0;
      if (lastVisitedIndex >= total2) {
        lastVisitedIndex = total2 - 1;
      }
      if (lastVisitedIndex >= 0) {
        const item = items[lastVisitedIndex];
        totalSizeOfMeasuredItems = item.offset + item.size;
      }
      const numUnmeasuredItems = total2 - lastVisitedIndex - 1;
      const totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize2;
      return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
    };
    const DynamicSizeList = createList({
      name: "ElDynamicSizeList",
      getItemOffset: (props, index2, listCache) => getItemFromCache$1(props, index2, listCache).offset,
      getItemSize: (_2, index2, { items }) => items[index2].size,
      getEstimatedTotalSize,
      getOffset: (props, index2, alignment, scrollOffset, listCache) => {
        const { height, layout: layout2, width } = props;
        const size2 = isHorizontal(layout2) ? width : height;
        const item = getItemFromCache$1(props, index2, listCache);
        const estimatedTotalSize = getEstimatedTotalSize(props, listCache);
        const maxOffset = Math.max(0, Math.min(estimatedTotalSize - size2, item.offset));
        const minOffset = Math.max(0, item.offset - size2 + item.size);
        if (alignment === SMART_ALIGNMENT) {
          if (scrollOffset >= minOffset - size2 && scrollOffset <= maxOffset + size2) {
            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, offset2, listCache) => findItem$1(props, listCache, offset2),
      getStopIndexForStartIndex: (props, startIndex, scrollOffset, listCache) => {
        const { height, total: total2, layout: layout2, width } = props;
        const size2 = isHorizontal(layout2) ? width : height;
        const item = getItemFromCache$1(props, startIndex, listCache);
        const maxOffset = scrollOffset + size2;
        let offset2 = item.offset + item.size;
        let stopIndex = startIndex;
        while (stopIndex < total2 - 1 && offset2 < maxOffset) {
          stopIndex++;
          offset2 += getItemFromCache$1(props, stopIndex, listCache).size;
        }
        return stopIndex;
      },
      initCache({ estimatedItemSize: estimatedItemSize2 = DEFAULT_DYNAMIC_LIST_ITEM_SIZE }, instance) {
        const cache2 = {
          items: {},
          estimatedItemSize: estimatedItemSize2,
          lastVisitedIndex: -1
        };
        cache2.clearCacheAfterIndex = (index2, forceUpdate = true) => {
          var _a2, _b;
          cache2.lastVisitedIndex = Math.min(cache2.lastVisitedIndex, index2 - 1);
          (_a2 = instance.exposed) == null ? void 0 : _a2.getItemStyleCache(-1);
          if (forceUpdate) {
            (_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
          }
        };
        return cache2;
      },
      clearCache: false,
      validateProps: ({ itemSize: itemSize2 }) => {
      }
    });
    const useGridWheel = ({ atXEndEdge, atXStartEdge, atYEndEdge, atYStartEdge }, onWheelDelta) => {
      let frameHandle = null;
      let xOffset = 0;
      let yOffset = 0;
      const hasReachedEdge = (x2, y) => {
        const xEdgeReached = x2 <= 0 && atXStartEdge.value || x2 >= 0 && atXEndEdge.value;
        const yEdgeReached = y <= 0 && atYStartEdge.value || y >= 0 && atYEndEdge.value;
        return xEdgeReached && yEdgeReached;
      };
      const onWheel = (e) => {
        cAF(frameHandle);
        let x2 = e.deltaX;
        let y = e.deltaY;
        if (Math.abs(x2) > Math.abs(y)) {
          y = 0;
        } else {
          x2 = 0;
        }
        if (e.shiftKey && y !== 0) {
          x2 = y;
          y = 0;
        }
        if (hasReachedEdge(xOffset, yOffset) && hasReachedEdge(xOffset + x2, yOffset + y))
          return;
        xOffset += x2;
        yOffset += y;
        e.preventDefault();
        frameHandle = rAF(() => {
          onWheelDelta(xOffset, yOffset);
          xOffset = 0;
          yOffset = 0;
        });
      };
      return {
        hasReachedEdge,
        onWheel
      };
    };
    const createGrid = ({
      name,
      clearCache,
      getColumnPosition,
      getColumnStartIndexForOffset,
      getColumnStopIndexForStartIndex,
      getEstimatedTotalHeight: getEstimatedTotalHeight2,
      getEstimatedTotalWidth: getEstimatedTotalWidth2,
      getColumnOffset,
      getRowOffset,
      getRowPosition,
      getRowStartIndexForOffset,
      getRowStopIndexForStartIndex,
      initCache,
      injectToInstance,
      validateProps
    }) => {
      return /* @__PURE__ */ defineComponent({
        name: name != null ? name : "ElVirtualList",
        props: virtualizedGridProps,
        emits: [ITEM_RENDER_EVT, SCROLL_EVT],
        setup(props, { emit: emit2, expose, slots }) {
          const ns = useNamespace("vl");
          validateProps(props);
          const instance = getCurrentInstance();
          const cache2 = ref(initCache(props, instance));
          injectToInstance == null ? void 0 : injectToInstance(instance, cache2);
          const windowRef = ref();
          const hScrollbar = ref();
          const vScrollbar = ref();
          const innerRef = ref(null);
          const states = 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 = computed(() => Number.parseInt(`${props.height}`, 10));
          const parsedWidth = computed(() => Number.parseInt(`${props.width}`, 10));
          const columnsToRender = computed(() => {
            const { totalColumn, totalRow, columnCache } = props;
            const { isScrolling, xAxisScrollDir, scrollLeft } = unref(states);
            if (totalColumn === 0 || totalRow === 0) {
              return [0, 0, 0, 0];
            }
            const startIndex = getColumnStartIndexForOffset(props, scrollLeft, unref(cache2));
            const stopIndex = getColumnStopIndexForStartIndex(props, startIndex, scrollLeft, unref(cache2));
            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 = computed(() => {
            const { totalColumn, totalRow, rowCache } = props;
            const { isScrolling, yAxisScrollDir, scrollTop } = unref(states);
            if (totalColumn === 0 || totalRow === 0) {
              return [0, 0, 0, 0];
            }
            const startIndex = getRowStartIndexForOffset(props, scrollTop, unref(cache2));
            const stopIndex = getRowStopIndexForStartIndex(props, startIndex, scrollTop, unref(cache2));
            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 = computed(() => getEstimatedTotalHeight2(props, unref(cache2)));
          const estimatedTotalWidth = computed(() => getEstimatedTotalWidth2(props, unref(cache2)));
          const windowStyle = computed(() => {
            var _a2;
            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
              },
              (_a2 = props.style) != null ? _a2 : {}
            ];
          });
          const innerStyle = computed(() => {
            const width = `${unref(estimatedTotalWidth)}px`;
            const height = `${unref(estimatedTotalHeight)}px`;
            return {
              height,
              pointerEvents: unref(states).isScrolling ? "none" : void 0,
              width
            };
          });
          const emitEvents = () => {
            const { totalColumn, totalRow } = props;
            if (totalColumn > 0 && totalRow > 0) {
              const [
                columnCacheStart,
                columnCacheEnd,
                columnVisibleStart,
                columnVisibleEnd
              ] = unref(columnsToRender);
              const [rowCacheStart, rowCacheEnd, rowVisibleStart, rowVisibleEnd] = unref(rowsToRender);
              emit2(ITEM_RENDER_EVT, {
                columnCacheStart,
                columnCacheEnd,
                rowCacheStart,
                rowCacheEnd,
                columnVisibleStart,
                columnVisibleEnd,
                rowVisibleStart,
                rowVisibleEnd
              });
            }
            const {
              scrollLeft,
              scrollTop,
              updateRequested,
              xAxisScrollDir,
              yAxisScrollDir
            } = unref(states);
            emit2(SCROLL_EVT, {
              xAxisScrollDir,
              scrollLeft,
              yAxisScrollDir,
              scrollTop,
              updateRequested
            });
          };
          const onScroll = (e) => {
            const {
              clientHeight,
              clientWidth,
              scrollHeight,
              scrollLeft,
              scrollTop,
              scrollWidth
            } = e.currentTarget;
            const _states = 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)
            };
            nextTick(() => resetIsScrolling());
            onUpdated2();
            emitEvents();
          };
          const onVerticalScroll = (distance, totalSteps) => {
            const height = unref(parsedHeight);
            const offset2 = (estimatedTotalHeight.value - height) / totalSteps * distance;
            scrollTo({
              scrollTop: Math.min(estimatedTotalHeight.value - height, offset2)
            });
          };
          const onHorizontalScroll = (distance, totalSteps) => {
            const width = unref(parsedWidth);
            const offset2 = (estimatedTotalWidth.value - width) / totalSteps * distance;
            scrollTo({
              scrollLeft: Math.min(estimatedTotalWidth.value - width, offset2)
            });
          };
          const { onWheel } = useGridWheel({
            atXStartEdge: computed(() => states.value.scrollLeft <= 0),
            atXEndEdge: computed(() => states.value.scrollLeft >= estimatedTotalWidth.value - unref(parsedWidth)),
            atYStartEdge: computed(() => states.value.scrollTop <= 0),
            atYEndEdge: computed(() => states.value.scrollTop >= estimatedTotalHeight.value - unref(parsedHeight))
          }, (x2, y) => {
            var _a2, _b, _c, _d;
            (_b = (_a2 = hScrollbar.value) == null ? void 0 : _a2.onMouseUp) == null ? void 0 : _b.call(_a2);
            (_d = (_c = vScrollbar.value) == null ? void 0 : _c.onMouseUp) == null ? void 0 : _d.call(_c);
            const width = unref(parsedWidth);
            const height = unref(parsedHeight);
            scrollTo({
              scrollLeft: Math.min(states.value.scrollLeft + x2, estimatedTotalWidth.value - width),
              scrollTop: Math.min(states.value.scrollTop + y, estimatedTotalHeight.value - height)
            });
          });
          const scrollTo = ({
            scrollLeft = states.value.scrollLeft,
            scrollTop = states.value.scrollTop
          }) => {
            scrollLeft = Math.max(scrollLeft, 0);
            scrollTop = Math.max(scrollTop, 0);
            const _states = 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
            };
            nextTick(() => resetIsScrolling());
            onUpdated2();
            emitEvents();
          };
          const scrollToItem = (rowIndex = 0, columnIdx = 0, alignment = AUTO_ALIGNMENT) => {
            const _states = unref(states);
            columnIdx = Math.max(0, Math.min(columnIdx, props.totalColumn - 1));
            rowIndex = Math.max(0, Math.min(rowIndex, props.totalRow - 1));
            const scrollBarWidth2 = getScrollBarWidth(ns.namespace.value);
            const _cache = unref(cache2);
            const estimatedHeight = getEstimatedTotalHeight2(props, _cache);
            const estimatedWidth = getEstimatedTotalWidth2(props, _cache);
            scrollTo({
              scrollLeft: getColumnOffset(props, columnIdx, alignment, _states.scrollLeft, _cache, estimatedWidth > props.width ? scrollBarWidth2 : 0),
              scrollTop: getRowOffset(props, rowIndex, alignment, _states.scrollTop, _cache, estimatedHeight > props.height ? scrollBarWidth2 : 0)
            });
          };
          const getItemStyle = (rowIndex, columnIndex) => {
            const { columnWidth, direction: direction2, rowHeight } = props;
            const itemStyleCache = getItemStyleCache.value(clearCache && columnWidth, clearCache && rowHeight, clearCache && direction2);
            const key = `${rowIndex},${columnIndex}`;
            if (hasOwn(itemStyleCache, key)) {
              return itemStyleCache[key];
            } else {
              const [, left2] = getColumnPosition(props, columnIndex, unref(cache2));
              const _cache = unref(cache2);
              const rtl = isRTL(direction2);
              const [height, top] = getRowPosition(props, rowIndex, _cache);
              const [width] = getColumnPosition(props, columnIndex, _cache);
              itemStyleCache[key] = {
                position: "absolute",
                left: rtl ? void 0 : `${left2}px`,
                right: rtl ? `${left2}px` : void 0,
                top: `${top}px`,
                height: `${height}px`,
                width: `${width}px`
              };
              return itemStyleCache[key];
            }
          };
          const resetIsScrolling = () => {
            states.value.isScrolling = false;
            nextTick(() => {
              getItemStyleCache.value(-1, null, null);
            });
          };
          onMounted(() => {
            if (!isClient)
              return;
            const { initScrollLeft, initScrollTop } = props;
            const windowElement = unref(windowRef);
            if (windowElement) {
              if (isNumber(initScrollLeft)) {
                windowElement.scrollLeft = initScrollLeft;
              }
              if (isNumber(initScrollTop)) {
                windowElement.scrollTop = initScrollTop;
              }
            }
            emitEvents();
          });
          const onUpdated2 = () => {
            const { direction: direction2 } = props;
            const { scrollLeft, scrollTop, updateRequested } = unref(states);
            const windowElement = unref(windowRef);
            if (updateRequested && windowElement) {
              if (direction2 === 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 = unref(parsedWidth);
            const height = unref(parsedHeight);
            const estimatedWidth = unref(estimatedTotalWidth);
            const estimatedHeight = unref(estimatedTotalHeight);
            const { scrollLeft, scrollTop } = unref(states);
            const horizontalScrollbar = h$1(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 = h$1(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 _a2;
            const [columnStart, columnEnd] = unref(columnsToRender);
            const [rowStart, rowEnd] = 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++) {
                  children.push((_a2 = slots.default) == null ? void 0 : _a2.call(slots, {
                    columnIndex: column,
                    data,
                    key: itemKey({ columnIndex: column, data, rowIndex: row }),
                    isScrolling: useIsScrolling ? unref(states).isScrolling : void 0,
                    style: getItemStyle(row, column),
                    rowIndex: row
                  }));
                }
              }
            }
            return children;
          };
          const renderInner = () => {
            const Inner = resolveDynamicComponent(props.innerElement);
            const children = renderItems();
            return [
              h$1(Inner, {
                style: unref(innerStyle),
                ref: innerRef
              }, !isString$1(Inner) ? {
                default: () => children
              } : children)
            ];
          };
          const renderWindow = () => {
            const Container2 = resolveDynamicComponent(props.containerElement);
            const { horizontalScrollbar, verticalScrollbar } = renderScrollbars();
            const Inner = renderInner();
            return h$1("div", {
              key: 0,
              class: ns.e("wrapper"),
              role: props.role
            }, [
              h$1(Container2, {
                class: props.className,
                style: unref(windowStyle),
                onScroll,
                onWheel,
                ref: windowRef
              }, !isString$1(Container2) ? { default: () => Inner } : Inner),
              horizontalScrollbar,
              verticalScrollbar
            ]);
          };
          return renderWindow;
        }
      });
    };
    const FixedSizeGrid = createGrid({
      name: "ElFixedSizeGrid",
      getColumnPosition: ({ columnWidth }, index2) => [
        columnWidth,
        index2 * columnWidth
      ],
      getRowPosition: ({ rowHeight }, index2) => [
        rowHeight,
        index2 * rowHeight
      ],
      getEstimatedTotalHeight: ({ totalRow, rowHeight }) => rowHeight * totalRow,
      getEstimatedTotalWidth: ({ totalColumn, columnWidth }) => columnWidth * totalColumn,
      getColumnOffset: ({ totalColumn, columnWidth, width }, columnIndex, alignment, scrollLeft, _2, scrollBarWidth2) => {
        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 + scrollBarWidth2 + 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, _2, scrollBarWidth2) => {
        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 + scrollBarWidth2 + 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 left2 = startIndex * columnWidth;
        const visibleColumnsCount = Math.ceil((width + scrollLeft - left2) / 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 }) => {
      }
    });
    const { max, min, floor } = Math;
    const ACCESS_SIZER_KEY_MAP = {
      column: "columnWidth",
      row: "rowHeight"
    };
    const ACCESS_LAST_VISITED_KEY_MAP = {
      column: "lastVisitedColumnIndex",
      row: "lastVisitedRowIndex"
    };
    const getItemFromCache = (props, index2, gridCache, type2) => {
      const [cachedItems, sizer, lastVisited] = [
        gridCache[type2],
        props[ACCESS_SIZER_KEY_MAP[type2]],
        gridCache[ACCESS_LAST_VISITED_KEY_MAP[type2]]
      ];
      if (index2 > lastVisited) {
        let offset2 = 0;
        if (lastVisited >= 0) {
          const item = cachedItems[lastVisited];
          offset2 = item.offset + item.size;
        }
        for (let i = lastVisited + 1; i <= index2; i++) {
          const size2 = sizer(i);
          cachedItems[i] = {
            offset: offset2,
            size: size2
          };
          offset2 += size2;
        }
        gridCache[ACCESS_LAST_VISITED_KEY_MAP[type2]] = index2;
      }
      return cachedItems[index2];
    };
    const bs = (props, gridCache, low, high, offset2, type2) => {
      while (low <= high) {
        const mid = low + floor((high - low) / 2);
        const currentOffset = getItemFromCache(props, mid, gridCache, type2).offset;
        if (currentOffset === offset2) {
          return mid;
        } else if (currentOffset < offset2) {
          low = mid + 1;
        } else {
          high = mid - 1;
        }
      }
      return max(0, low - 1);
    };
    const es = (props, gridCache, idx, offset2, type2) => {
      const total2 = type2 === "column" ? props.totalColumn : props.totalRow;
      let exponent = 1;
      while (idx < total2 && getItemFromCache(props, idx, gridCache, type2).offset < offset2) {
        idx += exponent;
        exponent *= 2;
      }
      return bs(props, gridCache, floor(idx / 2), min(idx, total2 - 1), offset2, type2);
    };
    const findItem = (props, gridCache, offset2, type2) => {
      const [cache2, lastVisitedIndex] = [
        gridCache[type2],
        gridCache[ACCESS_LAST_VISITED_KEY_MAP[type2]]
      ];
      const lastVisitedItemOffset = lastVisitedIndex > 0 ? cache2[lastVisitedIndex].offset : 0;
      if (lastVisitedItemOffset >= offset2) {
        return bs(props, gridCache, 0, lastVisitedIndex, offset2, type2);
      }
      return es(props, gridCache, max(0, lastVisitedIndex), offset2, type2);
    };
    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, index2, alignment, scrollOffset, cache2, type2, scrollBarWidth2) => {
      const [size2, estimatedSizeAssociates] = [
        type2 === "row" ? props.height : props.width,
        ACCESS_ESTIMATED_SIZE_KEY_MAP[type2]
      ];
      const item = getItemFromCache(props, index2, cache2, type2);
      const estimatedSize = estimatedSizeAssociates(props, cache2);
      const maxOffset = max(0, min(estimatedSize - size2, item.offset));
      const minOffset = max(0, item.offset - size2 + scrollBarWidth2 + item.size);
      if (alignment === SMART_ALIGNMENT) {
        if (scrollOffset >= minOffset - size2 && scrollOffset <= maxOffset + size2) {
          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({
      name: "ElDynamicSizeGrid",
      getColumnPosition: (props, idx, cache2) => {
        const item = getItemFromCache(props, idx, cache2, "column");
        return [item.size, item.offset];
      },
      getRowPosition: (props, idx, cache2) => {
        const item = getItemFromCache(props, idx, cache2, "row");
        return [item.size, item.offset];
      },
      getColumnOffset: (props, columnIndex, alignment, scrollLeft, cache2, scrollBarWidth2) => getOffset$1(props, columnIndex, alignment, scrollLeft, cache2, "column", scrollBarWidth2),
      getRowOffset: (props, rowIndex, alignment, scrollTop, cache2, scrollBarWidth2) => getOffset$1(props, rowIndex, alignment, scrollTop, cache2, "row", scrollBarWidth2),
      getColumnStartIndexForOffset: (props, scrollLeft, cache2) => findItem(props, cache2, scrollLeft, "column"),
      getColumnStopIndexForStartIndex: (props, startIndex, scrollLeft, cache2) => {
        const item = getItemFromCache(props, startIndex, cache2, "column");
        const maxOffset = scrollLeft + props.width;
        let offset2 = item.offset + item.size;
        let stopIndex = startIndex;
        while (stopIndex < props.totalColumn - 1 && offset2 < maxOffset) {
          stopIndex++;
          offset2 += getItemFromCache(props, startIndex, cache2, "column").size;
        }
        return stopIndex;
      },
      getEstimatedTotalHeight,
      getEstimatedTotalWidth,
      getRowStartIndexForOffset: (props, scrollTop, cache2) => findItem(props, cache2, scrollTop, "row"),
      getRowStopIndexForStartIndex: (props, startIndex, scrollTop, cache2) => {
        const { totalRow, height } = props;
        const item = getItemFromCache(props, startIndex, cache2, "row");
        const maxOffset = scrollTop + height;
        let offset2 = item.size + item.offset;
        let stopIndex = startIndex;
        while (stopIndex < totalRow - 1 && offset2 < maxOffset) {
          stopIndex++;
          offset2 += getItemFromCache(props, stopIndex, cache2, "row").size;
        }
        return stopIndex;
      },
      injectToInstance: (instance, cache2) => {
        const resetAfter = ({ columnIndex, rowIndex }, forceUpdate) => {
          var _a2, _b;
          forceUpdate = isUndefined(forceUpdate) ? true : forceUpdate;
          if (isNumber(columnIndex)) {
            cache2.value.lastVisitedColumnIndex = Math.min(cache2.value.lastVisitedColumnIndex, columnIndex - 1);
          }
          if (isNumber(rowIndex)) {
            cache2.value.lastVisitedRowIndex = Math.min(cache2.value.lastVisitedRowIndex, rowIndex - 1);
          }
          (_a2 = instance.exposed) == null ? void 0 : _a2.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 cache2 = {
          column: {},
          estimatedColumnWidth,
          estimatedRowHeight,
          lastVisitedColumnIndex: -1,
          lastVisitedRowIndex: -1,
          row: {}
        };
        return cache2;
      },
      clearCache: false,
      validateProps: ({ columnWidth, rowHeight }) => {
      }
    });
    const _sfc_main$I = /* @__PURE__ */ defineComponent({
      props: {
        item: {
          type: Object,
          required: true
        },
        style: Object,
        height: Number
      },
      setup() {
        const ns = useNamespace("select");
        return {
          ns
        };
      }
    });
    function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) {
      return _ctx.item.isTitle ? (openBlock(), createElementBlock("div", {
        key: 0,
        class: normalizeClass(_ctx.ns.be("group", "title")),
        style: normalizeStyle([_ctx.style, { lineHeight: `${_ctx.height}px` }])
      }, toDisplayString(_ctx.item.label), 7)) : (openBlock(), createElementBlock("div", {
        key: 1,
        class: normalizeClass(_ctx.ns.be("group", "split")),
        style: normalizeStyle(_ctx.style)
      }, [
        createBaseVNode("span", {
          class: normalizeClass(_ctx.ns.be("group", "split-dash")),
          style: normalizeStyle({ top: `${_ctx.height / 2}px` })
        }, null, 6)
      ], 6));
    }
    var GroupItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$I, [["render", _sfc_render$7], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/select-v2/src/group-item.vue"]]);
    function useOption(props, { emit: emit2 }) {
      return {
        hoverItem: () => {
          if (!props.disabled) {
            emit2("hover", props.index);
          }
        },
        selectOptionClick: () => {
          if (!props.disabled) {
            emit2("select", props.item, props.index);
          }
        }
      };
    }
    const defaultProps$3 = {
      label: "label",
      value: "value",
      disabled: "disabled",
      options: "options"
    };
    function useProps(props) {
      const aliasProps = computed(() => ({ ...defaultProps$3, ...props.props }));
      const getLabel = (option) => get(option, aliasProps.value.label);
      const getValue2 = (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: getValue2,
        getDisabled,
        getOptions
      };
    }
    const SelectProps = 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: {
        type: Boolean,
        default: false
      },
      maxCollapseTags: {
        type: Number,
        default: 1
      },
      defaultFirstOption: Boolean,
      disabled: Boolean,
      estimatedOptionHeight: {
        type: Number,
        default: void 0
      },
      filterable: Boolean,
      filterMethod: Function,
      height: {
        type: Number,
        default: 170
      },
      itemHeight: {
        type: Number,
        default: 34
      },
      id: String,
      loading: Boolean,
      loadingText: String,
      label: String,
      modelValue: {
        type: definePropType([Array, String, Number, Boolean, Object])
      },
      multiple: Boolean,
      multipleLimit: {
        type: Number,
        default: 0
      },
      name: String,
      noDataText: String,
      noMatchText: String,
      remoteMethod: Function,
      reserveKeyword: {
        type: Boolean,
        default: true
      },
      options: {
        type: definePropType(Array),
        required: true
      },
      placeholder: {
        type: String
      },
      teleported: useTooltipContentProps.teleported,
      persistent: {
        type: Boolean,
        default: true
      },
      popperClass: {
        type: String,
        default: ""
      },
      popperOptions: {
        type: definePropType(Object),
        default: () => ({})
      },
      remote: Boolean,
      size: useSizeProp,
      props: {
        type: definePropType(Object),
        default: () => defaultProps$3
      },
      valueKey: {
        type: String,
        default: "value"
      },
      scrollbarAlwaysOn: {
        type: Boolean,
        default: false
      },
      validateEvent: {
        type: Boolean,
        default: true
      },
      placement: {
        type: definePropType(String),
        values: Ee,
        default: "bottom-start"
      }
    });
    const OptionProps = buildProps({
      data: Array,
      disabled: Boolean,
      hovering: Boolean,
      item: {
        type: definePropType(Object),
        required: true
      },
      index: Number,
      style: Object,
      selected: Boolean,
      created: Boolean
    });
    const selectV2InjectionKey = Symbol("ElSelectV2Injection");
    const _sfc_main$H = /* @__PURE__ */ defineComponent({
      props: OptionProps,
      emits: ["select", "hover"],
      setup(props, { emit: emit2 }) {
        const select = inject(selectV2InjectionKey);
        const ns = useNamespace("select");
        const { hoverItem, selectOptionClick } = useOption(props, { emit: emit2 });
        const { getLabel } = useProps(select.props);
        return {
          ns,
          hoverItem,
          selectOptionClick,
          getLabel
        };
      }
    });
    const _hoisted_1$j = ["aria-selected"];
    function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) {
      return openBlock(), createElementBlock("li", {
        "aria-selected": _ctx.selected,
        style: normalizeStyle(_ctx.style),
        class: normalizeClass([
          _ctx.ns.be("dropdown", "option-item"),
          _ctx.ns.is("selected", _ctx.selected),
          _ctx.ns.is("disabled", _ctx.disabled),
          _ctx.ns.is("created", _ctx.created),
          { hover: _ctx.hovering }
        ]),
        onMouseenter: _cache[0] || (_cache[0] = (...args) => _ctx.hoverItem && _ctx.hoverItem(...args)),
        onClick: _cache[1] || (_cache[1] = withModifiers((...args) => _ctx.selectOptionClick && _ctx.selectOptionClick(...args), ["stop"]))
      }, [
        renderSlot(_ctx.$slots, "default", {
          item: _ctx.item,
          index: _ctx.index,
          disabled: _ctx.disabled
        }, () => [
          createBaseVNode("span", null, toDisplayString(_ctx.getLabel(_ctx.item)), 1)
        ])
      ], 46, _hoisted_1$j);
    }
    var OptionItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$H, [["render", _sfc_render$6], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/select-v2/src/option-item.vue"]]);
    var ElSelectMenu = /* @__PURE__ */ defineComponent({
      name: "ElSelectDropdown",
      props: {
        data: {
          type: Array,
          required: true
        },
        hoveringIndex: Number,
        width: Number
      },
      setup(props, {
        slots,
        expose
      }) {
        const select = inject(selectV2InjectionKey);
        const ns = useNamespace("select");
        const {
          getLabel,
          getValue: getValue2,
          getDisabled
        } = useProps(select.props);
        const cachedHeights = ref([]);
        const listRef = ref();
        const size2 = computed(() => props.data.length);
        watch(() => size2.value, () => {
          var _a2, _b;
          (_b = (_a2 = select.popper.value).updatePopper) == null ? void 0 : _b.call(_a2);
        });
        const isSized = computed(() => isUndefined(select.props.estimatedOptionHeight));
        const listProps = 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 toRaw(get(item, valueKey)) === get(target, valueKey);
          });
        };
        const isEqual2 = (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, getValue2(target));
          }
          return isEqual2(modelValue, getValue2(target));
        };
        const isItemDisabled = (modelValue, selected) => {
          const {
            disabled,
            multiple,
            multipleLimit
          } = select.props;
          return disabled || !selected && (multiple ? multipleLimit > 0 && modelValue.length >= multipleLimit : false);
        };
        const isItemHovering = (target) => props.hoveringIndex === target;
        const scrollToItem = (index2) => {
          const list = listRef.value;
          if (list) {
            list.scrollToItem(index2);
          }
        };
        const resetScrollTop = () => {
          const list = listRef.value;
          if (list) {
            list.resetScrollTop();
          }
        };
        expose({
          listRef,
          isSized,
          isItemDisabled,
          isItemHovering,
          isItemSelected,
          scrollToItem,
          resetScrollTop
        });
        const Item = (itemProps) => {
          const {
            index: index2,
            data,
            style
          } = itemProps;
          const sized = unref(isSized);
          const {
            itemSize: itemSize2,
            estimatedSize
          } = unref(listProps);
          const {
            modelValue
          } = select.props;
          const {
            onSelect,
            onHover
          } = select;
          const item = data[index2];
          if (item.type === "Group") {
            return createVNode(GroupItem, {
              "item": item,
              "style": style,
              "height": sized ? itemSize2 : estimatedSize
            }, null);
          }
          const isSelected = isItemSelected(modelValue, item);
          const isDisabled = isItemDisabled(modelValue, isSelected);
          const isHovering = isItemHovering(index2);
          return createVNode(OptionItem, mergeProps(itemProps, {
            "selected": isSelected,
            "disabled": getDisabled(item) || isDisabled,
            "created": !!item.created,
            "hovering": isHovering,
            "item": item,
            "onSelect": onSelect,
            "onHover": onHover
          }), {
            default: (props2) => {
              var _a2;
              return ((_a2 = slots.default) == null ? void 0 : _a2.call(slots, props2)) || createVNode("span", null, [getLabel(item)]);
            }
          });
        };
        const {
          onKeyboardNavigate,
          onKeyboardSelect
        } = select;
        const onForward = () => {
          onKeyboardNavigate("forward");
        };
        const onBackward = () => {
          onKeyboardNavigate("backward");
        };
        const onEscOrTab = () => {
          select.expanded = false;
        };
        const onKeydown = (e) => {
          const {
            code
          } = e;
          const {
            tab,
            esc,
            down: down2,
            up: up2,
            enter
          } = EVENT_CODE;
          if (code !== tab) {
            e.preventDefault();
            e.stopPropagation();
          }
          switch (code) {
            case tab:
            case esc: {
              onEscOrTab();
              break;
            }
            case down2: {
              onForward();
              break;
            }
            case up2: {
              onBackward();
              break;
            }
            case enter: {
              onKeyboardSelect();
              break;
            }
          }
        };
        return () => {
          var _a2;
          const {
            data,
            width
          } = props;
          const {
            height,
            multiple,
            scrollbarAlwaysOn
          } = select.props;
          if (data.length === 0) {
            return createVNode("div", {
              "class": ns.b("dropdown"),
              "style": {
                width: `${width}px`
              }
            }, [(_a2 = slots.empty) == null ? void 0 : _a2.call(slots)]);
          }
          const List = unref(isSized) ? FixedSizeList : DynamicSizeList;
          return createVNode("div", {
            "class": [ns.b("dropdown"), ns.is("multiple", multiple)]
          }, [createVNode(List, mergeProps({
            "ref": listRef
          }, unref(listProps), {
            "className": ns.be("dropdown", "list"),
            "scrollbarAlwaysOn": scrollbarAlwaysOn,
            "data": data,
            "height": height,
            "width": width,
            "total": data.length,
            "onKeydown": onKeydown
          }), {
            default: (props2) => createVNode(Item, props2, null)
          })]);
        };
      }
    });
    function useAllowCreate(props, states) {
      const { aliasProps, getLabel, getValue: getValue2 } = useProps(props);
      const createOptionCount = ref(0);
      const cachedSelectedOption = ref(null);
      const enableAllowCreateMode = computed(() => {
        return props.allowCreate && props.filterable;
      });
      function hasExistingOption(query) {
        const hasValue = (option) => getValue2(option) === query;
        return props.options && props.options.some(hasValue) || states.createdOptions.some(hasValue);
      }
      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 && !hasExistingOption(query)) {
            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((it2) => getValue2(it2) === getValue2(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
      };
    }
    function useInput(handleInput) {
      const isComposing = ref(false);
      const handleCompositionStart = () => {
        isComposing.value = true;
      };
      const handleCompositionUpdate = (event) => {
        const text = event.target.value;
        const lastCharacter = text[text.length - 1] || "";
        isComposing.value = !isKorean(lastCharacter);
      };
      const handleCompositionEnd = (event) => {
        if (isComposing.value) {
          isComposing.value = false;
          if (isFunction$2(handleInput)) {
            handleInput(event);
          }
        }
      };
      return {
        handleCompositionStart,
        handleCompositionUpdate,
        handleCompositionEnd
      };
    }
    const DEFAULT_INPUT_PLACEHOLDER = "";
    const MINIMUM_INPUT_WIDTH = 11;
    const TAG_BASE_WIDTH = {
      larget: 51,
      default: 42,
      small: 33
    };
    const useSelect$1 = (props, emit2) => {
      const { t } = useLocale();
      const nsSelectV2 = useNamespace("select-v2");
      const nsInput = useNamespace("input");
      const { form: elForm, formItem: elFormItem } = useFormItem();
      const { getLabel, getValue: getValue2, getDisabled, getOptions } = useProps(props);
      const states = reactive({
        inputValue: DEFAULT_INPUT_PLACEHOLDER,
        displayInputValue: DEFAULT_INPUT_PLACEHOLDER,
        calculatedWidth: 0,
        cachedPlaceholder: "",
        cachedOptions: [],
        createdOptions: [],
        createdLabel: "",
        createdSelected: false,
        currentPlaceholder: "",
        hoveringIndex: -1,
        comboBoxHovering: false,
        isOnComposition: false,
        isSilentBlur: false,
        isComposing: false,
        inputLength: 20,
        selectWidth: 200,
        initialInputHeight: 0,
        previousQuery: null,
        previousValue: void 0,
        query: "",
        selectedLabel: "",
        softFocus: false,
        tagInMultiLine: false
      });
      const selectedIndex = ref(-1);
      const popperSize = ref(-1);
      const controlRef = ref(null);
      const inputRef = ref(null);
      const menuRef = ref(null);
      const popper = ref(null);
      const selectRef = ref(null);
      const selectionRef = ref(null);
      const calculatorRef = ref(null);
      const expanded = ref(false);
      const selectDisabled = computed(() => props.disabled || (elForm == null ? void 0 : elForm.disabled));
      const popupHeight = computed(() => {
        const totalHeight = filteredOptions.value.length * 34;
        return totalHeight > props.height ? props.height : totalHeight;
      });
      const hasModelValue = computed(() => {
        return !isNil(props.modelValue);
      });
      const showClearBtn = computed(() => {
        const hasValue = props.multiple ? Array.isArray(props.modelValue) && props.modelValue.length > 0 : hasModelValue.value;
        const criteria = props.clearable && !selectDisabled.value && states.comboBoxHovering && hasValue;
        return criteria;
      });
      const iconComponent = computed(() => props.remote && props.filterable ? "" : arrow_up_default);
      const iconReverse = computed(() => iconComponent.value && nsSelectV2.is("reverse", expanded.value));
      const validateState = computed(() => (elFormItem == null ? void 0 : elFormItem.validateState) || "");
      const validateIcon = computed(() => ValidateComponentsMap[validateState.value]);
      const debounce$1 = computed(() => props.remote ? 300 : 0);
      const emptyText = computed(() => {
        const options = filteredOptions.value;
        if (props.loading) {
          return props.loadingText || t("el.select.loading");
        } else {
          if (props.remote && states.inputValue === "" && options.length === 0)
            return false;
          if (props.filterable && states.inputValue && options.length > 0) {
            return props.noMatchText || t("el.select.noMatch");
          }
          if (options.length === 0) {
            return props.noDataText || t("el.select.noData");
          }
        }
        return null;
      });
      const filteredOptions = computed(() => {
        const isValidOption = (o2) => {
          const query = states.inputValue;
          const regexp2 = new RegExp(escapeStringRegexp(query), "i");
          const containsQueryString = query ? regexp2.test(getLabel(o2) || "") : true;
          return containsQueryString;
        };
        if (props.loading) {
          return [];
        }
        return [...props.options, ...states.createdOptions].reduce((all, item) => {
          const options = getOptions(item);
          if (isArray$3(options)) {
            const filtered = options.filter(isValidOption);
            if (filtered.length > 0) {
              all.push({
                label: getLabel(item),
                isTitle: true,
                type: "Group"
              }, ...filtered, { type: "Group" });
            }
          } else if (props.remote || isValidOption(item)) {
            all.push(item);
          }
          return all;
        }, []);
      });
      const filteredOptionsValueMap = computed(() => {
        const valueMap = /* @__PURE__ */ new Map();
        filteredOptions.value.forEach((option, index2) => {
          valueMap.set(getValueKey(getValue2(option)), { option, index: index2 });
        });
        return valueMap;
      });
      const optionsAllDisabled = computed(() => filteredOptions.value.every((option) => getDisabled(option)));
      const selectSize = useFormSize();
      const collapseTagSize = computed(() => selectSize.value === "small" ? "small" : "default");
      const tagMaxWidth = computed(() => {
        const select = selectionRef.value;
        const size2 = collapseTagSize.value || "default";
        const paddingLeft = select ? Number.parseInt(getComputedStyle(select).paddingLeft) : 0;
        const paddingRight = select ? Number.parseInt(getComputedStyle(select).paddingRight) : 0;
        return states.selectWidth - paddingRight - paddingLeft - TAG_BASE_WIDTH[size2];
      });
      const calculatePopperSize = () => {
        var _a2;
        popperSize.value = ((_a2 = selectRef.value) == null ? void 0 : _a2.offsetWidth) || 200;
      };
      const inputWrapperStyle = computed(() => {
        return {
          width: `${states.calculatedWidth === 0 ? MINIMUM_INPUT_WIDTH : Math.ceil(states.calculatedWidth) + MINIMUM_INPUT_WIDTH}px`
        };
      });
      const shouldShowPlaceholder = computed(() => {
        if (isArray$3(props.modelValue)) {
          return props.modelValue.length === 0 && !states.displayInputValue;
        }
        return props.filterable ? states.displayInputValue.length === 0 : true;
      });
      const currentPlaceholder = computed(() => {
        const _placeholder = props.placeholder || t("el.select.placeholder");
        return props.multiple || isNil(props.modelValue) ? _placeholder : states.selectedLabel;
      });
      const popperRef = computed(() => {
        var _a2, _b;
        return (_b = (_a2 = popper.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
      });
      const indexRef = computed(() => {
        if (props.multiple) {
          const len = props.modelValue.length;
          if (props.modelValue.length > 0 && filteredOptionsValueMap.value.has(props.modelValue[len - 1])) {
            const { index: index2 } = filteredOptionsValueMap.value.get(props.modelValue[len - 1]);
            return index2;
          }
        } else {
          if (props.modelValue && filteredOptionsValueMap.value.has(props.modelValue)) {
            const { index: index2 } = filteredOptionsValueMap.value.get(props.modelValue);
            return index2;
          }
        }
        return -1;
      });
      const dropdownMenuVisible = computed({
        get() {
          return expanded.value && emptyText.value !== false;
        },
        set(val) {
          expanded.value = val;
        }
      });
      const showTagList = computed(() => states.cachedOptions.slice(0, props.maxCollapseTags));
      const collapseTagList = computed(() => states.cachedOptions.slice(props.maxCollapseTags));
      const {
        createNewOption,
        removeNewOption,
        selectNewOption,
        clearAllNewOption
      } = useAllowCreate(props, states);
      const {
        handleCompositionStart,
        handleCompositionUpdate,
        handleCompositionEnd
      } = useInput((e) => onInput(e));
      const focusAndUpdatePopup = () => {
        var _a2, _b, _c;
        (_b = (_a2 = inputRef.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
        (_c = popper.value) == null ? void 0 : _c.updatePopper();
      };
      const toggleMenu = () => {
        if (props.automaticDropdown)
          return;
        if (!selectDisabled.value) {
          if (states.isComposing)
            states.softFocus = true;
          return nextTick(() => {
            var _a2, _b;
            expanded.value = !expanded.value;
            (_b = (_a2 = inputRef.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
          });
        }
      };
      const onInputChange = () => {
        if (props.filterable && states.inputValue !== states.selectedLabel) {
          states.query = states.selectedLabel;
        }
        handleQueryChange(states.inputValue);
        return nextTick(() => {
          createNewOption(states.inputValue);
        });
      };
      const debouncedOnInputChange = debounce(onInputChange, debounce$1.value);
      const handleQueryChange = (val) => {
        if (states.previousQuery === val) {
          return;
        }
        states.previousQuery = val;
        if (props.filterable && isFunction$2(props.filterMethod)) {
          props.filterMethod(val);
        } else if (props.filterable && props.remote && isFunction$2(props.remoteMethod)) {
          props.remoteMethod(val);
        }
      };
      const emitChange = (val) => {
        if (!isEqual$1(props.modelValue, val)) {
          emit2(CHANGE_EVENT, val);
        }
      };
      const update = (val) => {
        emit2(UPDATE_MODEL_EVENT, val);
        emitChange(val);
        states.previousValue = String(val);
      };
      const getValueIndex = (arr = [], value) => {
        if (!isObject$1(value)) {
          return arr.indexOf(value);
        }
        const valueKey = props.valueKey;
        let index2 = -1;
        arr.some((item, i) => {
          if (get(item, valueKey) === get(value, valueKey)) {
            index2 = i;
            return true;
          }
          return false;
        });
        return index2;
      };
      const getValueKey = (item) => {
        return isObject$1(item) ? get(item, props.valueKey) : item;
      };
      const resetInputHeight = () => {
        return nextTick(() => {
          var _a2, _b;
          if (!inputRef.value)
            return;
          const selection = selectionRef.value;
          selectRef.value.height = selection.offsetHeight;
          if (expanded.value && emptyText.value !== false) {
            (_b = (_a2 = popper.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
          }
        });
      };
      const handleResize = () => {
        var _a2, _b;
        resetInputWidth();
        calculatePopperSize();
        (_b = (_a2 = popper.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
        if (props.multiple) {
          return resetInputHeight();
        }
      };
      const resetInputWidth = () => {
        const select = selectionRef.value;
        if (select) {
          states.selectWidth = select.getBoundingClientRect().width;
        }
      };
      const onSelect = (option, idx, byClick = true) => {
        var _a2, _b;
        if (props.multiple) {
          let selectedOptions = props.modelValue.slice();
          const index2 = getValueIndex(selectedOptions, getValue2(option));
          if (index2 > -1) {
            selectedOptions = [
              ...selectedOptions.slice(0, index2),
              ...selectedOptions.slice(index2 + 1)
            ];
            states.cachedOptions.splice(index2, 1);
            removeNewOption(option);
          } else if (props.multipleLimit <= 0 || selectedOptions.length < props.multipleLimit) {
            selectedOptions = [...selectedOptions, getValue2(option)];
            states.cachedOptions.push(option);
            selectNewOption(option);
            updateHoveringIndex(idx);
          }
          update(selectedOptions);
          if (option.created) {
            states.query = "";
            handleQueryChange("");
            states.inputLength = 20;
          }
          if (props.filterable && !props.reserveKeyword) {
            (_b = (_a2 = inputRef.value).focus) == null ? void 0 : _b.call(_a2);
            onUpdateInputValue("");
          }
          if (props.filterable) {
            states.calculatedWidth = calculatorRef.value.getBoundingClientRect().width;
          }
          resetInputHeight();
          setSoftFocus();
        } else {
          selectedIndex.value = idx;
          states.selectedLabel = getLabel(option);
          update(getValue2(option));
          expanded.value = false;
          states.isComposing = false;
          states.isSilentBlur = byClick;
          selectNewOption(option);
          if (!option.created) {
            clearAllNewOption();
          }
          updateHoveringIndex(idx);
        }
      };
      const deleteTag = (event, option) => {
        let selectedOptions = props.modelValue.slice();
        const index2 = getValueIndex(selectedOptions, getValue2(option));
        if (index2 > -1 && !selectDisabled.value) {
          selectedOptions = [
            ...props.modelValue.slice(0, index2),
            ...props.modelValue.slice(index2 + 1)
          ];
          states.cachedOptions.splice(index2, 1);
          update(selectedOptions);
          emit2("remove-tag", getValue2(option));
          states.softFocus = true;
          removeNewOption(option);
          return nextTick(focusAndUpdatePopup);
        }
        event.stopPropagation();
      };
      const handleFocus = (event) => {
        const focused = states.isComposing;
        states.isComposing = true;
        if (!states.softFocus) {
          if (!focused)
            emit2("focus", event);
        } else {
          states.softFocus = false;
        }
      };
      const handleBlur = (event) => {
        states.softFocus = false;
        return nextTick(() => {
          var _a2, _b;
          (_b = (_a2 = inputRef.value) == null ? void 0 : _a2.blur) == null ? void 0 : _b.call(_a2);
          if (calculatorRef.value) {
            states.calculatedWidth = calculatorRef.value.getBoundingClientRect().width;
          }
          if (states.isSilentBlur) {
            states.isSilentBlur = false;
          } else {
            if (states.isComposing) {
              emit2("blur", event);
            }
          }
          states.isComposing = false;
        });
      };
      const handleEsc = () => {
        if (states.displayInputValue.length > 0) {
          onUpdateInputValue("");
        } else {
          expanded.value = false;
        }
      };
      const handleDel = (e) => {
        if (states.displayInputValue.length === 0) {
          e.preventDefault();
          const selected = props.modelValue.slice();
          selected.pop();
          removeNewOption(states.cachedOptions.pop());
          update(selected);
        }
      };
      const handleClear = () => {
        let emptyValue;
        if (isArray$3(props.modelValue)) {
          emptyValue = [];
        } else {
          emptyValue = void 0;
        }
        states.softFocus = true;
        if (props.multiple) {
          states.cachedOptions = [];
        } else {
          states.selectedLabel = "";
        }
        expanded.value = false;
        update(emptyValue);
        emit2("clear");
        clearAllNewOption();
        return nextTick(focusAndUpdatePopup);
      };
      const onUpdateInputValue = (val) => {
        states.displayInputValue = val;
        states.inputValue = val;
      };
      const onKeyboardNavigate = (direction2, hoveringIndex = void 0) => {
        const options = filteredOptions.value;
        if (!["forward", "backward"].includes(direction2) || selectDisabled.value || options.length <= 0 || optionsAllDisabled.value) {
          return;
        }
        if (!expanded.value) {
          return toggleMenu();
        }
        if (hoveringIndex === void 0) {
          hoveringIndex = states.hoveringIndex;
        }
        let newIndex = -1;
        if (direction2 === "forward") {
          newIndex = hoveringIndex + 1;
          if (newIndex >= options.length) {
            newIndex = 0;
          }
        } else if (direction2 === "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(direction2, newIndex);
        } else {
          updateHoveringIndex(newIndex);
          scrollToItem(newIndex);
        }
      };
      const onKeyboardSelect = () => {
        if (!expanded.value) {
          return toggleMenu();
        } else if (~states.hoveringIndex && filteredOptions.value[states.hoveringIndex]) {
          onSelect(filteredOptions.value[states.hoveringIndex], states.hoveringIndex, false);
        }
      };
      const updateHoveringIndex = (idx) => {
        states.hoveringIndex = idx;
      };
      const resetHoveringIndex = () => {
        states.hoveringIndex = -1;
      };
      const setSoftFocus = () => {
        var _a2;
        const _input = inputRef.value;
        if (_input) {
          (_a2 = _input.focus) == null ? void 0 : _a2.call(_input);
        }
      };
      const onInput = (event) => {
        const value = event.target.value;
        onUpdateInputValue(value);
        if (states.displayInputValue.length > 0 && !expanded.value) {
          expanded.value = true;
        }
        states.calculatedWidth = calculatorRef.value.getBoundingClientRect().width;
        if (props.multiple) {
          resetInputHeight();
        }
        if (props.remote) {
          debouncedOnInputChange();
        } else {
          return onInputChange();
        }
      };
      const handleClickOutside = () => {
        expanded.value = false;
        return handleBlur();
      };
      const handleMenuEnter = () => {
        states.inputValue = states.displayInputValue;
        return nextTick(() => {
          if (~indexRef.value) {
            updateHoveringIndex(indexRef.value);
            scrollToItem(states.hoveringIndex);
          }
        });
      };
      const scrollToItem = (index2) => {
        menuRef.value.scrollToItem(index2);
      };
      const initStates = () => {
        resetHoveringIndex();
        if (props.multiple) {
          if (props.modelValue.length > 0) {
            let initHovering = false;
            states.cachedOptions.length = 0;
            states.previousValue = props.modelValue.toString();
            for (const value of props.modelValue) {
              const selectValue = getValueKey(value);
              if (filteredOptionsValueMap.value.has(selectValue)) {
                const { index: index2, option } = filteredOptionsValueMap.value.get(selectValue);
                states.cachedOptions.push(option);
                if (!initHovering) {
                  updateHoveringIndex(index2);
                }
                initHovering = true;
              }
            }
          } 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(getValue2(option)) === getValueKey(props.modelValue));
            if (~selectedItemIndex) {
              states.selectedLabel = getLabel(options[selectedItemIndex]);
              updateHoveringIndex(selectedItemIndex);
            } else {
              states.selectedLabel = getValueKey(props.modelValue);
            }
          } else {
            states.selectedLabel = "";
            states.previousValue = void 0;
          }
        }
        clearAllNewOption();
        calculatePopperSize();
      };
      watch(expanded, (val) => {
        var _a2, _b;
        emit2("visible-change", val);
        if (val) {
          (_b = (_a2 = popper.value).update) == null ? void 0 : _b.call(_a2);
        } else {
          states.displayInputValue = "";
          states.previousQuery = null;
          createNewOption("");
        }
      });
      watch(() => props.modelValue, (val, oldVal) => {
        var _a2;
        if (!val || val.toString() !== states.previousValue) {
          initStates();
        }
        if (!isEqual$1(val, oldVal) && props.validateEvent) {
          (_a2 = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a2.call(elFormItem, "change").catch((err) => debugWarn());
        }
      }, {
        deep: true
      });
      watch(() => props.options, () => {
        const input = inputRef.value;
        if (!input || input && document.activeElement !== input) {
          initStates();
        }
      }, {
        deep: true
      });
      watch(filteredOptions, () => {
        return menuRef.value && nextTick(menuRef.value.resetScrollTop);
      });
      watch(() => dropdownMenuVisible.value, (val) => {
        if (!val) {
          resetHoveringIndex();
        }
      });
      onMounted(() => {
        initStates();
      });
      useResizeObserver(selectRef, handleResize);
      return {
        collapseTagSize,
        currentPlaceholder,
        expanded,
        emptyText,
        popupHeight,
        debounce: debounce$1,
        filteredOptions,
        iconComponent,
        iconReverse,
        inputWrapperStyle,
        popperSize,
        dropdownMenuVisible,
        hasModelValue,
        shouldShowPlaceholder,
        selectDisabled,
        selectSize,
        showClearBtn,
        states,
        tagMaxWidth,
        nsSelectV2,
        nsInput,
        calculatorRef,
        controlRef,
        inputRef,
        menuRef,
        popper,
        selectRef,
        selectionRef,
        popperRef,
        validateState,
        validateIcon,
        showTagList,
        collapseTagList,
        debouncedOnInputChange,
        deleteTag,
        getLabel,
        getValue: getValue2,
        getDisabled,
        getValueKey,
        handleBlur,
        handleClear,
        handleClickOutside,
        handleDel,
        handleEsc,
        handleFocus,
        handleMenuEnter,
        handleResize,
        toggleMenu,
        scrollTo: scrollToItem,
        onInput,
        onKeyboardNavigate,
        onKeyboardSelect,
        onSelect,
        onHover: updateHoveringIndex,
        onUpdateInputValue,
        handleCompositionStart,
        handleCompositionEnd,
        handleCompositionUpdate
      };
    };
    const _sfc_main$G = /* @__PURE__ */ defineComponent({
      name: "ElSelectV2",
      components: {
        ElSelectMenu,
        ElTag,
        ElTooltip,
        ElIcon
      },
      directives: { ClickOutside, ModelText: vModelText },
      props: SelectProps,
      emits: [
        UPDATE_MODEL_EVENT,
        CHANGE_EVENT,
        "remove-tag",
        "clear",
        "visible-change",
        "focus",
        "blur"
      ],
      setup(props, { emit: emit2 }) {
        const modelValue = computed(() => {
          const { modelValue: rawModelValue, multiple } = props;
          const fallback = multiple ? [] : void 0;
          if (isArray$3(rawModelValue)) {
            return multiple ? rawModelValue : fallback;
          }
          return multiple ? fallback : rawModelValue;
        });
        const API = useSelect$1(reactive({
          ...toRefs(props),
          modelValue
        }), emit2);
        provide(selectV2InjectionKey, {
          props: reactive({
            ...toRefs(props),
            height: API.popupHeight,
            modelValue
          }),
          popper: API.popper,
          onSelect: API.onSelect,
          onHover: API.onHover,
          onKeyboardNavigate: API.onKeyboardNavigate,
          onKeyboardSelect: API.onKeyboardSelect
        });
        return {
          ...API,
          modelValue
        };
      }
    });
    const _hoisted_1$i = { key: 0 };
    const _hoisted_2$c = ["id", "autocomplete", "aria-expanded", "aria-labelledby", "disabled", "readonly", "name", "unselectable"];
    const _hoisted_3$5 = ["textContent"];
    const _hoisted_4$3 = ["id", "aria-labelledby", "aria-expanded", "autocomplete", "disabled", "name", "readonly", "unselectable"];
    const _hoisted_5$2 = ["textContent"];
    function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_tag = resolveComponent("el-tag");
      const _component_el_tooltip = resolveComponent("el-tooltip");
      const _component_el_icon = resolveComponent("el-icon");
      const _component_el_select_menu = resolveComponent("el-select-menu");
      const _directive_model_text = resolveDirective("model-text");
      const _directive_click_outside = resolveDirective("click-outside");
      return withDirectives((openBlock(), createElementBlock("div", {
        ref: "selectRef",
        class: normalizeClass([_ctx.nsSelectV2.b(), _ctx.nsSelectV2.m(_ctx.selectSize)]),
        onClick: _cache[24] || (_cache[24] = withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"])),
        onMouseenter: _cache[25] || (_cache[25] = ($event) => _ctx.states.comboBoxHovering = true),
        onMouseleave: _cache[26] || (_cache[26] = ($event) => _ctx.states.comboBoxHovering = false)
      }, [
        createVNode(_component_el_tooltip, {
          ref: "popper",
          visible: _ctx.dropdownMenuVisible,
          teleported: _ctx.teleported,
          "popper-class": [_ctx.nsSelectV2.e("popper"), _ctx.popperClass],
          "gpu-acceleration": false,
          "stop-popper-mouse-event": false,
          "popper-options": _ctx.popperOptions,
          "fallback-placements": ["bottom-start", "top-start", "right", "left"],
          effect: _ctx.effect,
          placement: _ctx.placement,
          pure: "",
          transition: `${_ctx.nsSelectV2.namespace.value}-zoom-in-top`,
          trigger: "click",
          persistent: _ctx.persistent,
          onBeforeShow: _ctx.handleMenuEnter,
          onHide: _cache[23] || (_cache[23] = ($event) => _ctx.states.inputValue = _ctx.states.displayInputValue)
        }, {
          default: withCtx(() => [
            createBaseVNode("div", {
              ref: "selectionRef",
              class: normalizeClass([
                _ctx.nsSelectV2.e("wrapper"),
                _ctx.nsSelectV2.is("focused", _ctx.states.isComposing || _ctx.expanded),
                _ctx.nsSelectV2.is("hovering", _ctx.states.comboBoxHovering),
                _ctx.nsSelectV2.is("filterable", _ctx.filterable),
                _ctx.nsSelectV2.is("disabled", _ctx.selectDisabled)
              ])
            }, [
              _ctx.$slots.prefix ? (openBlock(), createElementBlock("div", _hoisted_1$i, [
                renderSlot(_ctx.$slots, "prefix")
              ])) : createCommentVNode("v-if", true),
              _ctx.multiple ? (openBlock(), createElementBlock("div", {
                key: 1,
                class: normalizeClass(_ctx.nsSelectV2.e("selection"))
              }, [
                _ctx.collapseTags && _ctx.modelValue.length > 0 ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.showTagList, (item) => {
                    return openBlock(), createElementBlock("div", {
                      key: _ctx.getValueKey(_ctx.getValue(item)),
                      class: normalizeClass(_ctx.nsSelectV2.e("selected-item"))
                    }, [
                      createVNode(_component_el_tag, {
                        closable: !_ctx.selectDisabled && !_ctx.getDisabled(item),
                        size: _ctx.collapseTagSize,
                        type: "info",
                        "disable-transitions": "",
                        onClose: ($event) => _ctx.deleteTag($event, item)
                      }, {
                        default: withCtx(() => [
                          createBaseVNode("span", {
                            class: normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                            style: normalizeStyle({
                              maxWidth: `${_ctx.tagMaxWidth}px`
                            })
                          }, toDisplayString(_ctx.getLabel(item)), 7)
                        ]),
                        _: 2
                      }, 1032, ["closable", "size", "onClose"])
                    ], 2);
                  }), 128)),
                  createBaseVNode("div", {
                    class: normalizeClass(_ctx.nsSelectV2.e("selected-item"))
                  }, [
                    _ctx.modelValue.length > _ctx.maxCollapseTags ? (openBlock(), createBlock(_component_el_tag, {
                      key: 0,
                      closable: false,
                      size: _ctx.collapseTagSize,
                      type: "info",
                      "disable-transitions": ""
                    }, {
                      default: withCtx(() => [
                        _ctx.collapseTagsTooltip ? (openBlock(), createBlock(_component_el_tooltip, {
                          key: 0,
                          disabled: _ctx.dropdownMenuVisible,
                          "fallback-placements": ["bottom", "top", "right", "left"],
                          effect: _ctx.effect,
                          placement: "bottom",
                          teleported: false
                        }, {
                          default: withCtx(() => [
                            createBaseVNode("span", {
                              class: normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                              style: normalizeStyle({
                                maxWidth: `${_ctx.tagMaxWidth}px`
                              })
                            }, " + " + toDisplayString(_ctx.modelValue.length - _ctx.maxCollapseTags), 7)
                          ]),
                          content: withCtx(() => [
                            createBaseVNode("div", {
                              class: normalizeClass(_ctx.nsSelectV2.e("selection"))
                            }, [
                              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.collapseTagList, (selected) => {
                                return openBlock(), createElementBlock("div", {
                                  key: _ctx.getValueKey(_ctx.getValue(selected)),
                                  class: normalizeClass(_ctx.nsSelectV2.e("selected-item"))
                                }, [
                                  createVNode(_component_el_tag, {
                                    closable: !_ctx.selectDisabled && !_ctx.getDisabled(selected),
                                    size: _ctx.collapseTagSize,
                                    class: "in-tooltip",
                                    type: "info",
                                    "disable-transitions": "",
                                    onClose: ($event) => _ctx.deleteTag($event, selected)
                                  }, {
                                    default: withCtx(() => [
                                      createBaseVNode("span", {
                                        class: normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                                        style: normalizeStyle({
                                          maxWidth: `${_ctx.tagMaxWidth}px`
                                        })
                                      }, toDisplayString(_ctx.getLabel(selected)), 7)
                                    ]),
                                    _: 2
                                  }, 1032, ["closable", "size", "onClose"])
                                ], 2);
                              }), 128))
                            ], 2)
                          ]),
                          _: 1
                        }, 8, ["disabled", "effect"])) : (openBlock(), createElementBlock("span", {
                          key: 1,
                          class: normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                          style: normalizeStyle({
                            maxWidth: `${_ctx.tagMaxWidth}px`
                          })
                        }, " + " + toDisplayString(_ctx.modelValue.length - _ctx.maxCollapseTags), 7))
                      ]),
                      _: 1
                    }, 8, ["size"])) : createCommentVNode("v-if", true)
                  ], 2)
                ], 64)) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.states.cachedOptions, (selected) => {
                  return openBlock(), createElementBlock("div", {
                    key: _ctx.getValueKey(_ctx.getValue(selected)),
                    class: normalizeClass(_ctx.nsSelectV2.e("selected-item"))
                  }, [
                    createVNode(_component_el_tag, {
                      closable: !_ctx.selectDisabled && !_ctx.getDisabled(selected),
                      size: _ctx.collapseTagSize,
                      type: "info",
                      "disable-transitions": "",
                      onClose: ($event) => _ctx.deleteTag($event, selected)
                    }, {
                      default: withCtx(() => [
                        createBaseVNode("span", {
                          class: normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                          style: normalizeStyle({
                            maxWidth: `${_ctx.tagMaxWidth}px`
                          })
                        }, toDisplayString(_ctx.getLabel(selected)), 7)
                      ]),
                      _: 2
                    }, 1032, ["closable", "size", "onClose"])
                  ], 2);
                }), 128)),
                createBaseVNode("div", {
                  class: normalizeClass([
                    _ctx.nsSelectV2.e("selected-item"),
                    _ctx.nsSelectV2.e("input-wrapper")
                  ]),
                  style: normalizeStyle(_ctx.inputWrapperStyle)
                }, [
                  withDirectives(createBaseVNode("input", {
                    id: _ctx.id,
                    ref: "inputRef",
                    autocomplete: _ctx.autocomplete,
                    "aria-autocomplete": "list",
                    "aria-haspopup": "listbox",
                    autocapitalize: "off",
                    "aria-expanded": _ctx.expanded,
                    "aria-labelledby": _ctx.label,
                    class: normalizeClass([
                      _ctx.nsSelectV2.is(_ctx.selectSize),
                      _ctx.nsSelectV2.e("combobox-input")
                    ]),
                    disabled: _ctx.disabled,
                    role: "combobox",
                    readonly: !_ctx.filterable,
                    spellcheck: "false",
                    type: "text",
                    name: _ctx.name,
                    unselectable: _ctx.expanded ? "on" : void 0,
                    "onUpdate:modelValue": _cache[0] || (_cache[0] = (...args) => _ctx.onUpdateInputValue && _ctx.onUpdateInputValue(...args)),
                    onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
                    onBlur: _cache[2] || (_cache[2] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
                    onInput: _cache[3] || (_cache[3] = (...args) => _ctx.onInput && _ctx.onInput(...args)),
                    onCompositionstart: _cache[4] || (_cache[4] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
                    onCompositionupdate: _cache[5] || (_cache[5] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
                    onCompositionend: _cache[6] || (_cache[6] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
                    onKeydown: [
                      _cache[7] || (_cache[7] = withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"])),
                      _cache[8] || (_cache[8] = withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"])),
                      _cache[9] || (_cache[9] = withKeys(withModifiers((...args) => _ctx.onKeyboardSelect && _ctx.onKeyboardSelect(...args), ["stop", "prevent"]), ["enter"])),
                      _cache[10] || (_cache[10] = withKeys(withModifiers((...args) => _ctx.handleEsc && _ctx.handleEsc(...args), ["stop", "prevent"]), ["esc"])),
                      _cache[11] || (_cache[11] = withKeys(withModifiers((...args) => _ctx.handleDel && _ctx.handleDel(...args), ["stop"]), ["delete"]))
                    ]
                  }, null, 42, _hoisted_2$c), [
                    [_directive_model_text, _ctx.states.displayInputValue]
                  ]),
                  _ctx.filterable ? (openBlock(), createElementBlock("span", {
                    key: 0,
                    ref: "calculatorRef",
                    "aria-hidden": "true",
                    class: normalizeClass(_ctx.nsSelectV2.e("input-calculator")),
                    textContent: toDisplayString(_ctx.states.displayInputValue)
                  }, null, 10, _hoisted_3$5)) : createCommentVNode("v-if", true)
                ], 6)
              ], 2)) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [
                createBaseVNode("div", {
                  class: normalizeClass([
                    _ctx.nsSelectV2.e("selected-item"),
                    _ctx.nsSelectV2.e("input-wrapper")
                  ])
                }, [
                  withDirectives(createBaseVNode("input", {
                    id: _ctx.id,
                    ref: "inputRef",
                    "aria-autocomplete": "list",
                    "aria-haspopup": "listbox",
                    "aria-labelledby": _ctx.label,
                    "aria-expanded": _ctx.expanded,
                    autocapitalize: "off",
                    autocomplete: _ctx.autocomplete,
                    class: normalizeClass(_ctx.nsSelectV2.e("combobox-input")),
                    disabled: _ctx.disabled,
                    name: _ctx.name,
                    role: "combobox",
                    readonly: !_ctx.filterable,
                    spellcheck: "false",
                    type: "text",
                    unselectable: _ctx.expanded ? "on" : void 0,
                    onCompositionstart: _cache[12] || (_cache[12] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
                    onCompositionupdate: _cache[13] || (_cache[13] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
                    onCompositionend: _cache[14] || (_cache[14] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
                    onFocus: _cache[15] || (_cache[15] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
                    onBlur: _cache[16] || (_cache[16] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
                    onInput: _cache[17] || (_cache[17] = (...args) => _ctx.onInput && _ctx.onInput(...args)),
                    onKeydown: [
                      _cache[18] || (_cache[18] = withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"])),
                      _cache[19] || (_cache[19] = withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"])),
                      _cache[20] || (_cache[20] = withKeys(withModifiers((...args) => _ctx.onKeyboardSelect && _ctx.onKeyboardSelect(...args), ["stop", "prevent"]), ["enter"])),
                      _cache[21] || (_cache[21] = withKeys(withModifiers((...args) => _ctx.handleEsc && _ctx.handleEsc(...args), ["stop", "prevent"]), ["esc"]))
                    ],
                    "onUpdate:modelValue": _cache[22] || (_cache[22] = (...args) => _ctx.onUpdateInputValue && _ctx.onUpdateInputValue(...args))
                  }, null, 42, _hoisted_4$3), [
                    [_directive_model_text, _ctx.states.displayInputValue]
                  ])
                ], 2),
                _ctx.filterable ? (openBlock(), createElementBlock("span", {
                  key: 0,
                  ref: "calculatorRef",
                  "aria-hidden": "true",
                  class: normalizeClass([
                    _ctx.nsSelectV2.e("selected-item"),
                    _ctx.nsSelectV2.e("input-calculator")
                  ]),
                  textContent: toDisplayString(_ctx.states.displayInputValue)
                }, null, 10, _hoisted_5$2)) : createCommentVNode("v-if", true)
              ], 64)),
              _ctx.shouldShowPlaceholder ? (openBlock(), createElementBlock("span", {
                key: 3,
                class: normalizeClass([
                  _ctx.nsSelectV2.e("placeholder"),
                  _ctx.nsSelectV2.is("transparent", _ctx.multiple ? _ctx.modelValue.length === 0 : !_ctx.hasModelValue)
                ])
              }, toDisplayString(_ctx.currentPlaceholder), 3)) : createCommentVNode("v-if", true),
              createBaseVNode("span", {
                class: normalizeClass(_ctx.nsSelectV2.e("suffix"))
              }, [
                _ctx.iconComponent ? withDirectives((openBlock(), createBlock(_component_el_icon, {
                  key: 0,
                  class: normalizeClass([_ctx.nsSelectV2.e("caret"), _ctx.nsInput.e("icon"), _ctx.iconReverse])
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
                  ]),
                  _: 1
                }, 8, ["class"])), [
                  [vShow, !_ctx.showClearBtn]
                ]) : createCommentVNode("v-if", true),
                _ctx.showClearBtn && _ctx.clearIcon ? (openBlock(), createBlock(_component_el_icon, {
                  key: 1,
                  class: normalizeClass([_ctx.nsSelectV2.e("caret"), _ctx.nsInput.e("icon")]),
                  onClick: withModifiers(_ctx.handleClear, ["prevent", "stop"])
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
                _ctx.validateState && _ctx.validateIcon ? (openBlock(), createBlock(_component_el_icon, {
                  key: 2,
                  class: normalizeClass([_ctx.nsInput.e("icon"), _ctx.nsInput.e("validateIcon")])
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.validateIcon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : createCommentVNode("v-if", true)
              ], 2)
            ], 2)
          ]),
          content: withCtx(() => [
            createVNode(_component_el_select_menu, {
              ref: "menuRef",
              data: _ctx.filteredOptions,
              width: _ctx.popperSize,
              "hovering-index": _ctx.states.hoveringIndex,
              "scrollbar-always-on": _ctx.scrollbarAlwaysOn
            }, {
              default: withCtx((scope) => [
                renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(scope)))
              ]),
              empty: withCtx(() => [
                renderSlot(_ctx.$slots, "empty", {}, () => [
                  createBaseVNode("p", {
                    class: normalizeClass(_ctx.nsSelectV2.e("empty"))
                  }, toDisplayString(_ctx.emptyText ? _ctx.emptyText : ""), 3)
                ])
              ]),
              _: 3
            }, 8, ["data", "width", "hovering-index", "scrollbar-always-on"])
          ]),
          _: 3
        }, 8, ["visible", "teleported", "popper-class", "popper-options", "effect", "placement", "transition", "persistent", "onBeforeShow"])
      ], 34)), [
        [_directive_click_outside, _ctx.handleClickOutside, _ctx.popperRef]
      ]);
    }
    var Select = /* @__PURE__ */ _export_sfc$1(_sfc_main$G, [["render", _sfc_render$5], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/select-v2/src/select.vue"]]);
    Select.install = (app) => {
      app.component(Select.name, Select);
    };
    const _Select = Select;
    const ElSelectV2 = _Select;
    const skeletonProps = buildProps({
      animated: {
        type: Boolean,
        default: false
      },
      count: {
        type: Number,
        default: 1
      },
      rows: {
        type: Number,
        default: 3
      },
      loading: {
        type: Boolean,
        default: true
      },
      throttle: {
        type: Number
      }
    });
    const skeletonItemProps = buildProps({
      variant: {
        type: String,
        values: [
          "circle",
          "rect",
          "h1",
          "h3",
          "text",
          "caption",
          "p",
          "image",
          "button"
        ],
        default: "text"
      }
    });
    const __default__$u = /* @__PURE__ */ defineComponent({
      name: "ElSkeletonItem"
    });
    const _sfc_main$F = /* @__PURE__ */ defineComponent({
      ...__default__$u,
      props: skeletonItemProps,
      setup(__props) {
        const ns = useNamespace("skeleton");
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).e("item"), unref(ns).e(_ctx.variant)])
          }, [
            _ctx.variant === "image" ? (openBlock(), createBlock(unref(picture_filled_default), { key: 0 })) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var SkeletonItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$F, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/skeleton/src/skeleton-item.vue"]]);
    const __default__$t = /* @__PURE__ */ defineComponent({
      name: "ElSkeleton"
    });
    const _sfc_main$E = /* @__PURE__ */ defineComponent({
      ...__default__$t,
      props: skeletonProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("skeleton");
        const uiLoading = useThrottleRender(toRef(props, "loading"), props.throttle);
        expose({
          uiLoading
        });
        return (_ctx, _cache) => {
          return unref(uiLoading) ? (openBlock(), createElementBlock("div", mergeProps({
            key: 0,
            class: [unref(ns).b(), unref(ns).is("animated", _ctx.animated)]
          }, _ctx.$attrs), [
            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.count, (i) => {
              return openBlock(), createElementBlock(Fragment, { key: i }, [
                _ctx.loading ? renderSlot(_ctx.$slots, "template", { key: i }, () => [
                  createVNode(SkeletonItem, {
                    class: normalizeClass(unref(ns).is("first")),
                    variant: "p"
                  }, null, 8, ["class"]),
                  (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.rows, (item) => {
                    return openBlock(), createBlock(SkeletonItem, {
                      key: item,
                      class: normalizeClass([
                        unref(ns).e("paragraph"),
                        unref(ns).is("last", item === _ctx.rows && _ctx.rows > 1)
                      ]),
                      variant: "p"
                    }, null, 8, ["class"]);
                  }), 128))
                ]) : createCommentVNode("v-if", true)
              ], 64);
            }), 128))
          ], 16)) : renderSlot(_ctx.$slots, "default", normalizeProps(mergeProps({ key: 1 }, _ctx.$attrs)));
        };
      }
    });
    var Skeleton = /* @__PURE__ */ _export_sfc$1(_sfc_main$E, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/skeleton/src/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,
      debounce: {
        type: Number,
        default: 300
      },
      label: {
        type: String,
        default: void 0
      },
      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
      }
    });
    const isValidValue$1 = (value) => isNumber(value) || isArray$3(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 = ref();
      onMounted(async () => {
        if (props.range) {
          if (Array.isArray(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 (typeof props.modelValue !== "number" || 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 nextTick();
        resetSize();
      });
      return {
        sliderWrapper
      };
    };
    const useMarks = (props) => {
      return computed(() => {
        if (!props.marks) {
          return [];
        }
        const marksKeys = Object.keys(props.marks);
        return marksKeys.map(Number.parseFloat).sort((a2, b2) => a2 - b2).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, emit2) => {
      const { form: elForm, formItem: elFormItem } = useFormItem();
      const slider = shallowRef();
      const firstButton = ref();
      const secondButton = ref();
      const buttonRefs = {
        firstButton,
        secondButton
      };
      const sliderDisabled = computed(() => {
        return props.disabled || (elForm == null ? void 0 : elForm.disabled) || false;
      });
      const minValue = computed(() => {
        return Math.min(initData.firstValue, initData.secondValue);
      });
      const maxValue = computed(() => {
        return Math.max(initData.firstValue, initData.secondValue);
      });
      const barSize = computed(() => {
        return props.range ? `${100 * (maxValue.value - minValue.value) / (props.max - props.min)}%` : `${100 * (initData.firstValue - props.min) / (props.max - props.min)}%`;
      });
      const barStart = computed(() => {
        return props.range ? `${100 * (minValue.value - props.min) / (props.max - props.min)}%` : "0%";
      });
      const runwayStyle = computed(() => {
        return props.vertical ? { height: props.height } : {};
      });
      const barStyle = computed(() => {
        return props.vertical ? {
          height: barSize.value,
          bottom: barStart.value
        } : {
          width: barSize.value,
          left: barStart.value
        };
      });
      const resetSize = () => {
        if (slider.value) {
          initData.sliderSize = slider.value[`client${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;
        _emit(props.range ? [minValue.value, maxValue.value] : firstValue);
      };
      const setSecondValue = (secondValue) => {
        initData.secondValue = secondValue;
        if (props.range) {
          _emit([minValue.value, maxValue.value]);
        }
      };
      const _emit = (val) => {
        emit2(UPDATE_MODEL_EVENT, val);
        emit2(INPUT_EVENT, val);
      };
      const emitChange = async () => {
        await nextTick();
        emit2(CHANGE_EVENT, props.range ? [minValue.value, maxValue.value] : props.modelValue);
      };
      const handleSliderPointerEvent = (event) => {
        var _a2, _b, _c, _d, _e, _f;
        if (sliderDisabled.value || initData.dragging)
          return;
        resetSize();
        let newPercent = 0;
        if (props.vertical) {
          const clientY = (_c = (_b = (_a2 = event.touches) == null ? void 0 : _a2.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 _a2, _b;
        if (((_a2 = buttonRefs["firstButton"].value) == null ? void 0 : _a2.dragging) || ((_b = buttonRefs["secondButton"].value) == null ? void 0 : _b.dragging)) {
          event.preventDefault();
        }
      };
      const onSliderDown = async (event) => {
        const buttonRef = handleSliderPointerEvent(event);
        if (buttonRef) {
          await nextTick();
          buttonRef.value.onButtonDown(event);
        }
      };
      const onSliderClick = (event) => {
        const buttonRef = handleSliderPointerEvent(event);
        if (buttonRef) {
          emitChange();
        }
      };
      return {
        elFormItem,
        slider,
        firstButton,
        secondButton,
        sliderDisabled,
        minValue,
        maxValue,
        runwayStyle,
        barStyle,
        resetSize,
        setPosition,
        emitChange,
        onSliderWrapperPrevent,
        onSliderClick,
        onSliderDown,
        setFirstValue,
        setSecondValue
      };
    };
    const { left, down, right, up, home, end, pageUp, pageDown } = EVENT_CODE;
    const useTooltip = (props, formatTooltip, showTooltip) => {
      const tooltip = ref();
      const tooltipVisible = ref(false);
      const enableFormat = computed(() => {
        return formatTooltip.value instanceof Function;
      });
      const formatValue = 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, emit2) => {
      const {
        disabled,
        min: min2,
        max: max2,
        step,
        showTooltip,
        precision,
        sliderSize,
        formatTooltip,
        emitChange,
        resetSize,
        updateDragging
      } = inject(sliderContextKey);
      const { tooltip, tooltipVisible, formatValue, displayTooltip, hideTooltip } = useTooltip(props, formatTooltip, showTooltip);
      const button = ref();
      const currentPosition = computed(() => {
        return `${(props.modelValue - min2.value) / (max2.value - min2.value) * 100}%`;
      });
      const wrapperStyle = 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 / (max2.value - min2.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) => {
        let isPreventDefault = true;
        if ([left, down].includes(event.key)) {
          onLeftKeyDown();
        } else if ([right, up].includes(event.key)) {
          onRightKeyDown();
        } else if (event.key === home) {
          onHomeKeyDown();
        } else if (event.key === end) {
          onEndKeyDown();
        } else if (event.key === pageDown) {
          onPageDownKeyDown();
        } else if (event.key === pageUp) {
          onPageUpKeyDown();
        } else {
          isPreventDefault = false;
        }
        isPreventDefault && event.preventDefault();
      };
      const getClientXY2 = (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 } = getClientXY2(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 } = getClientXY2(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;
        if (newPosition < 0) {
          newPosition = 0;
        } else if (newPosition > 100) {
          newPosition = 100;
        }
        const lengthPerStep = 100 / ((max2.value - min2.value) / step.value);
        const steps = Math.round(newPosition / lengthPerStep);
        let value = steps * lengthPerStep * (max2.value - min2.value) * 0.01 + min2.value;
        value = Number.parseFloat(value.toFixed(precision.value));
        if (value !== props.modelValue) {
          emit2(UPDATE_MODEL_EVENT, value);
        }
        if (!initData.dragging && props.modelValue !== initData.oldValue) {
          initData.oldValue = props.modelValue;
        }
        await nextTick();
        initData.dragging && displayTooltip();
        tooltip.value.updatePopper();
      };
      watch(() => initData.dragging, (val) => {
        updateDragging(val);
      });
      return {
        disabled,
        button,
        tooltip,
        tooltipVisible,
        showTooltip,
        wrapperStyle,
        formatValue,
        handleMouseEnter,
        handleMouseLeave,
        onButtonDown,
        onKeyDown,
        setPosition
      };
    };
    const useStops = (props, initData, minValue, maxValue) => {
      const stops = computed(() => {
        if (!props.showStops || props.min > props.max)
          return [];
        if (props.step === 0) {
          return [];
        }
        const stopCount = (props.max - props.min) / props.step;
        const stepWidth = 100 * props.step / (props.max - props.min);
        const result = Array.from({ length: stopCount - 1 }).map((_2, index2) => (index2 + 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, emit2, elFormItem) => {
      const _emit = (val) => {
        emit2(UPDATE_MODEL_EVENT, val);
        emit2(INPUT_EVENT, val);
      };
      const valueChanged = () => {
        if (props.range) {
          return ![minValue.value, maxValue.value].every((item, index2) => item === initData.oldValue[index2]);
        } else {
          return props.modelValue !== initData.oldValue;
        }
      };
      const setValues = () => {
        var _a2, _b;
        if (props.min > props.max) {
          throwError("Slider", "min should not be greater than max.");
        }
        const val = props.modelValue;
        if (props.range && Array.isArray(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) {
                (_a2 = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a2.call(elFormItem, "change").catch((err) => debugWarn());
              }
              initData.oldValue = val.slice();
            }
          }
        } else if (!props.range && typeof val === "number" && !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());
              }
              initData.oldValue = val;
            }
          }
        }
      };
      setValues();
      watch(() => initData.dragging, (val) => {
        if (!val) {
          setValues();
        }
      });
      watch(() => props.modelValue, (val, oldVal) => {
        if (initData.dragging || Array.isArray(val) && Array.isArray(oldVal) && val.every((item, index2) => item === oldVal[index2]) && initData.firstValue === val[0] && initData.secondValue === val[1]) {
          return;
        }
        setValues();
      }, {
        deep: true
      });
      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 _hoisted_1$h = ["tabindex"];
    const __default__$s = /* @__PURE__ */ defineComponent({
      name: "ElSliderButton"
    });
    const _sfc_main$D = /* @__PURE__ */ defineComponent({
      ...__default__$s,
      props: sliderButtonProps,
      emits: sliderButtonEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("slider");
        const initData = reactive({
          hovering: false,
          dragging: false,
          isClick: false,
          startX: 0,
          currentX: 0,
          startY: 0,
          currentY: 0,
          startPosition: 0,
          newPosition: 0,
          oldValue: props.modelValue
        });
        const {
          disabled,
          button,
          tooltip,
          showTooltip,
          tooltipVisible,
          wrapperStyle,
          formatValue,
          handleMouseEnter,
          handleMouseLeave,
          onButtonDown,
          onKeyDown,
          setPosition
        } = useSliderButton(props, initData, emit2);
        const { hovering, dragging } = toRefs(initData);
        expose({
          onButtonDown,
          onKeyDown,
          setPosition,
          hovering,
          dragging
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "button",
            ref: button,
            class: normalizeClass([unref(ns).e("button-wrapper"), { hover: unref(hovering), dragging: unref(dragging) }]),
            style: normalizeStyle(unref(wrapperStyle)),
            tabindex: unref(disabled) ? -1 : 0,
            onMouseenter: _cache[0] || (_cache[0] = (...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args)),
            onMouseleave: _cache[1] || (_cache[1] = (...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args)),
            onMousedown: _cache[2] || (_cache[2] = (...args) => unref(onButtonDown) && unref(onButtonDown)(...args)),
            onTouchstart: _cache[3] || (_cache[3] = (...args) => unref(onButtonDown) && unref(onButtonDown)(...args)),
            onFocus: _cache[4] || (_cache[4] = (...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args)),
            onBlur: _cache[5] || (_cache[5] = (...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args)),
            onKeydown: _cache[6] || (_cache[6] = (...args) => unref(onKeyDown) && unref(onKeyDown)(...args))
          }, [
            createVNode(unref(ElTooltip), {
              ref_key: "tooltip",
              ref: tooltip,
              visible: unref(tooltipVisible),
              placement: _ctx.placement,
              "fallback-placements": ["top", "bottom", "right", "left"],
              "stop-popper-mouse-event": false,
              "popper-class": _ctx.tooltipClass,
              disabled: !unref(showTooltip),
              persistent: ""
            }, {
              content: withCtx(() => [
                createBaseVNode("span", null, toDisplayString(unref(formatValue)), 1)
              ]),
              default: withCtx(() => [
                createBaseVNode("div", {
                  class: normalizeClass([unref(ns).e("button"), { hover: unref(hovering), dragging: unref(dragging) }])
                }, null, 2)
              ]),
              _: 1
            }, 8, ["visible", "placement", "popper-class", "disabled"])
          ], 46, _hoisted_1$h);
        };
      }
    });
    var SliderButton = /* @__PURE__ */ _export_sfc$1(_sfc_main$D, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/slider/src/button.vue"]]);
    const sliderMarkerProps = buildProps({
      mark: {
        type: definePropType([String, Object]),
        default: void 0
      }
    });
    var SliderMarker = /* @__PURE__ */ defineComponent({
      name: "ElSliderMarker",
      props: sliderMarkerProps,
      setup(props) {
        const ns = useNamespace("slider");
        const label = computed(() => {
          return isString$1(props.mark) ? props.mark : props.mark.label;
        });
        const style = computed(() => isString$1(props.mark) ? void 0 : props.mark.style);
        return () => h$1("div", {
          class: ns.e("marks-text"),
          style: style.value
        }, label.value);
      }
    });
    const _hoisted_1$g = ["id", "role", "aria-label", "aria-labelledby"];
    const _hoisted_2$b = { key: 1 };
    const __default__$r = /* @__PURE__ */ defineComponent({
      name: "ElSlider"
    });
    const _sfc_main$C = /* @__PURE__ */ defineComponent({
      ...__default__$r,
      props: sliderProps,
      emits: sliderEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("slider");
        const { t } = useLocale();
        const initData = 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,
          setFirstValue,
          setSecondValue
        } = useSlide(props, initData, emit2);
        const { stops, getStopStyle } = useStops(props, initData, minValue, maxValue);
        const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: elFormItem
        });
        const sliderWrapperSize = useFormSize();
        const sliderInputSize = computed(() => props.inputSize || sliderWrapperSize.value);
        const groupLabel = computed(() => {
          return props.label || t("el.slider.defaultLabel", {
            min: props.min,
            max: props.max
          });
        });
        const firstButtonLabel = computed(() => {
          if (props.range) {
            return props.rangeStartLabel || t("el.slider.defaultRangeStartLabel");
          } else {
            return groupLabel.value;
          }
        });
        const firstValueText = computed(() => {
          return props.formatValueText ? props.formatValueText(firstValue.value) : `${firstValue.value}`;
        });
        const secondButtonLabel = computed(() => {
          return props.rangeEndLabel || t("el.slider.defaultRangeEndLabel");
        });
        const secondValueText = computed(() => {
          return props.formatValueText ? props.formatValueText(secondValue.value) : `${secondValue.value}`;
        });
        const sliderKls = 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, emit2, elFormItem);
        const precision = 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 } = toRefs(initData);
        const updateDragging = (val) => {
          initData.dragging = val;
        };
        provide(sliderContextKey, {
          ...toRefs(props),
          sliderSize,
          disabled: sliderDisabled,
          precision,
          emitChange,
          resetSize,
          updateDragging
        });
        expose({
          onSliderClick
        });
        return (_ctx, _cache) => {
          var _a2, _b;
          return openBlock(), createElementBlock("div", {
            id: _ctx.range ? unref(inputId) : void 0,
            ref_key: "sliderWrapper",
            ref: sliderWrapper,
            class: normalizeClass(unref(sliderKls)),
            role: _ctx.range ? "group" : void 0,
            "aria-label": _ctx.range && !unref(isLabeledByFormItem) ? unref(groupLabel) : void 0,
            "aria-labelledby": _ctx.range && unref(isLabeledByFormItem) ? (_a2 = unref(elFormItem)) == null ? void 0 : _a2.labelId : void 0,
            onTouchstart: _cache[2] || (_cache[2] = (...args) => unref(onSliderWrapperPrevent) && unref(onSliderWrapperPrevent)(...args)),
            onTouchmove: _cache[3] || (_cache[3] = (...args) => unref(onSliderWrapperPrevent) && unref(onSliderWrapperPrevent)(...args))
          }, [
            createBaseVNode("div", {
              ref_key: "slider",
              ref: slider,
              class: normalizeClass([
                unref(ns).e("runway"),
                { "show-input": _ctx.showInput && !_ctx.range },
                unref(ns).is("disabled", unref(sliderDisabled))
              ]),
              style: normalizeStyle(unref(runwayStyle)),
              onMousedown: _cache[0] || (_cache[0] = (...args) => unref(onSliderDown) && unref(onSliderDown)(...args)),
              onTouchstart: _cache[1] || (_cache[1] = (...args) => unref(onSliderDown) && unref(onSliderDown)(...args))
            }, [
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).e("bar")),
                style: normalizeStyle(unref(barStyle))
              }, null, 6),
              createVNode(SliderButton, {
                id: !_ctx.range ? unref(inputId) : void 0,
                ref_key: "firstButton",
                ref: firstButton,
                "model-value": unref(firstValue),
                vertical: _ctx.vertical,
                "tooltip-class": _ctx.tooltipClass,
                placement: _ctx.placement,
                role: "slider",
                "aria-label": _ctx.range || !unref(isLabeledByFormItem) ? unref(firstButtonLabel) : void 0,
                "aria-labelledby": !_ctx.range && unref(isLabeledByFormItem) ? (_b = unref(elFormItem)) == null ? void 0 : _b.labelId : void 0,
                "aria-valuemin": _ctx.min,
                "aria-valuemax": _ctx.range ? unref(secondValue) : _ctx.max,
                "aria-valuenow": unref(firstValue),
                "aria-valuetext": unref(firstValueText),
                "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
                "aria-disabled": unref(sliderDisabled),
                "onUpdate:modelValue": 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 ? (openBlock(), createBlock(SliderButton, {
                key: 0,
                ref_key: "secondButton",
                ref: secondButton,
                "model-value": unref(secondValue),
                vertical: _ctx.vertical,
                "tooltip-class": _ctx.tooltipClass,
                placement: _ctx.placement,
                role: "slider",
                "aria-label": unref(secondButtonLabel),
                "aria-valuemin": unref(firstValue),
                "aria-valuemax": _ctx.max,
                "aria-valuenow": unref(secondValue),
                "aria-valuetext": unref(secondValueText),
                "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
                "aria-disabled": unref(sliderDisabled),
                "onUpdate:modelValue": 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"])) : createCommentVNode("v-if", true),
              _ctx.showStops ? (openBlock(), createElementBlock("div", _hoisted_2$b, [
                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(stops), (item, key) => {
                  return openBlock(), createElementBlock("div", {
                    key,
                    class: normalizeClass(unref(ns).e("stop")),
                    style: normalizeStyle(unref(getStopStyle)(item))
                  }, null, 6);
                }), 128))
              ])) : createCommentVNode("v-if", true),
              unref(markList).length > 0 ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
                createBaseVNode("div", null, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(markList), (item, key) => {
                    return openBlock(), createElementBlock("div", {
                      key,
                      style: normalizeStyle(unref(getStopStyle)(item.position)),
                      class: normalizeClass([unref(ns).e("stop"), unref(ns).e("marks-stop")])
                    }, null, 6);
                  }), 128))
                ]),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("marks"))
                }, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(markList), (item, key) => {
                    return openBlock(), createBlock(unref(SliderMarker), {
                      key,
                      mark: item.mark,
                      style: normalizeStyle(unref(getStopStyle)(item.position))
                    }, null, 8, ["mark", "style"]);
                  }), 128))
                ], 2)
              ], 64)) : createCommentVNode("v-if", true)
            ], 38),
            _ctx.showInput && !_ctx.range ? (openBlock(), createBlock(unref(ElInputNumber), {
              key: 0,
              ref: "input",
              "model-value": unref(firstValue),
              class: normalizeClass(unref(ns).e("input")),
              step: _ctx.step,
              disabled: unref(sliderDisabled),
              controls: _ctx.showInputControls,
              min: _ctx.min,
              max: _ctx.max,
              debounce: _ctx.debounce,
              size: unref(sliderInputSize),
              "onUpdate:modelValue": unref(setFirstValue),
              onChange: unref(emitChange)
            }, null, 8, ["model-value", "class", "step", "disabled", "controls", "min", "max", "debounce", "size", "onUpdate:modelValue", "onChange"])) : createCommentVNode("v-if", true)
          ], 42, _hoisted_1$g);
        };
      }
    });
    var Slider = /* @__PURE__ */ _export_sfc$1(_sfc_main$C, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/slider/src/slider.vue"]]);
    const ElSlider = withInstall(Slider);
    const spaceItemProps = buildProps({
      prefixCls: {
        type: String
      }
    });
    const SpaceItem = /* @__PURE__ */ defineComponent({
      name: "ElSpaceItem",
      props: spaceItemProps,
      setup(props, { slots }) {
        const ns = useNamespace("space");
        const classes = computed(() => `${props.prefixCls || ns.b()}__item`);
        return () => h$1("div", { class: classes.value }, renderSlot(slots, "default"));
      }
    });
    const SIZE_MAP = {
      small: 8,
      default: 12,
      large: 16
    };
    function useSpace(props) {
      const ns = useNamespace("space");
      const classes = computed(() => [ns.b(), ns.m(props.direction), props.class]);
      const horizontalSize = ref(0);
      const verticalSize = ref(0);
      const containerStyle = computed(() => {
        const wrapKls = props.wrap || props.fill ? { flexWrap: "wrap", marginBottom: `-${verticalSize.value}px` } : {};
        const alignment = {
          alignItems: props.alignment
        };
        return [wrapKls, alignment, props.style];
      });
      const itemStyle = computed(() => {
        const itemBaseStyle = {
          paddingBottom: `${verticalSize.value}px`,
          marginRight: `${horizontalSize.value}px`
        };
        const fillStyle = props.fill ? { flexGrow: 1, minWidth: `${props.fillRatio}%` } : {};
        return [itemBaseStyle, fillStyle];
      });
      watchEffect(() => {
        const { size: size2 = "small", wrap, direction: dir, fill } = props;
        if (isArray$3(size2)) {
          const [h2 = 0, v2 = 0] = size2;
          horizontalSize.value = h2;
          verticalSize.value = v2;
        } else {
          let val;
          if (isNumber(size2)) {
            val = size2;
          } else {
            val = SIZE_MAP[size2 || "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) => 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$3(val) && val.length === 2 && val.every(isNumber);
        }
      }
    });
    const Space = /* @__PURE__ */ 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$3(child.children)) {
                child.children.forEach((nested, key) => {
                  if (isFragment(nested) && isArray$3(nested.children)) {
                    extractChildren(nested.children, `${parentKey + key}-`, extractedChildren);
                  } else {
                    extractedChildren.push(createVNode(SpaceItem, {
                      style: itemStyle.value,
                      prefixCls,
                      key: `nested-${parentKey + key}`
                    }, {
                      default: () => [nested]
                    }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
                  }
                });
              }
            } else if (isValidElementNode(child)) {
              extractedChildren.push(createVNode(SpaceItem, {
                style: itemStyle.value,
                prefixCls,
                key: `LoopKey${parentKey + loopKey}`
              }, {
                default: () => [child]
              }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
            }
          });
          return extractedChildren;
        }
        return () => {
          var _a2;
          const { spacer, direction: direction2 } = props;
          const children = renderSlot(slots, "default", { key: 0 }, () => []);
          if (((_a2 = children.children) != null ? _a2 : []).length === 0)
            return null;
          if (isArray$3(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(createVNode("span", {
                    style: [
                      itemStyle.value,
                      direction2 === "vertical" ? "width: 100%" : null
                    ],
                    key: idx
                  }, [
                    isVNode(spacer) ? spacer : createTextVNode(spacer, PatchFlags.TEXT)
                  ], PatchFlags.STYLE));
                }
                return children2;
              }, []);
            }
            return 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__$q = /* @__PURE__ */ defineComponent({
      name: "ElStatistic"
    });
    const _sfc_main$B = /* @__PURE__ */ defineComponent({
      ...__default__$q,
      props: statisticProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("statistic");
        const displayValue = computed(() => {
          const { value, formatter: formatter2, precision, decimalSeparator, groupSeparator } = props;
          if (isFunction$2(formatter2))
            return formatter2(value);
          if (!isNumber(value))
            return value;
          let [integer2, decimal = ""] = String(value).split(".");
          decimal = decimal.padEnd(precision, "0").slice(0, precision > 0 ? precision : 0);
          integer2 = integer2.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
          return [integer2, decimal].join(decimal ? decimalSeparator : "");
        });
        expose({
          displayValue
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(ns).b())
          }, [
            _ctx.$slots.title || _ctx.title ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(ns).e("head"))
            }, [
              renderSlot(_ctx.$slots, "title", {}, () => [
                createTextVNode(toDisplayString(_ctx.title), 1)
              ])
            ], 2)) : createCommentVNode("v-if", true),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("content"))
            }, [
              _ctx.$slots.prefix || _ctx.prefix ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ns).e("prefix"))
              }, [
                renderSlot(_ctx.$slots, "prefix", {}, () => [
                  createBaseVNode("span", null, toDisplayString(_ctx.prefix), 1)
                ])
              ], 2)) : createCommentVNode("v-if", true),
              createBaseVNode("span", {
                class: normalizeClass(unref(ns).e("number")),
                style: normalizeStyle(_ctx.valueStyle)
              }, toDisplayString(unref(displayValue)), 7),
              _ctx.$slots.suffix || _ctx.suffix ? (openBlock(), createElementBlock("div", {
                key: 1,
                class: normalizeClass(unref(ns).e("suffix"))
              }, [
                renderSlot(_ctx.$slots, "suffix", {}, () => [
                  createBaseVNode("span", null, toDisplayString(_ctx.suffix), 1)
                ])
              ], 2)) : createCommentVNode("v-if", true)
            ], 2)
          ], 2);
        };
      }
    });
    var Statistic = /* @__PURE__ */ _export_sfc$1(_sfc_main$B, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/statistic/src/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, format2) => {
      let timeLeft = timestamp;
      const escapeRegex = /\[([^\]]*)]/g;
      const replacedText = timeUnits.reduce((current, [name, unit2]) => {
        const replaceRegex = new RegExp(`${name}+(?![^\\[\\]]*\\])`, "g");
        if (replaceRegex.test(current)) {
          const value = Math.floor(timeLeft / unit2);
          timeLeft -= value * unit2;
          return current.replace(replaceRegex, (match) => String(value).padStart(match.length, "0"));
        }
        return current;
      }, format2);
      return replacedText.replace(escapeRegex, "$1");
    };
    const __default__$p = /* @__PURE__ */ defineComponent({
      name: "ElCountdown"
    });
    const _sfc_main$A = /* @__PURE__ */ defineComponent({
      ...__default__$p,
      props: countdownProps,
      emits: countdownEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        let timer;
        const rawValue = ref(getTime(props.value) - Date.now());
        const displayValue = computed(() => formatTime$1(rawValue.value, props.format));
        const formatter2 = (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();
            emit2("change", diff);
            if (diff <= 0) {
              diff = 0;
              stopTimer();
              emit2("finish");
            } else {
              timer = rAF(frameFunc);
            }
            rawValue.value = diff;
          };
          timer = rAF(frameFunc);
        };
        watch(() => [props.value, props.format], () => {
          stopTimer();
          startTimer();
        }, {
          immediate: true
        });
        onBeforeUnmount(() => {
          stopTimer();
        });
        expose({
          displayValue
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElStatistic), {
            value: rawValue.value,
            title: _ctx.title,
            prefix: _ctx.prefix,
            suffix: _ctx.suffix,
            "value-style": _ctx.valueStyle,
            formatter: formatter2
          }, createSlots({ _: 2 }, [
            renderList(_ctx.$slots, (_2, name) => {
              return {
                name,
                fn: withCtx(() => [
                  renderSlot(_ctx.$slots, name)
                ])
              };
            })
          ]), 1032, ["value", "title", "prefix", "suffix", "value-style"]);
        };
      }
    });
    var Countdown = /* @__PURE__ */ _export_sfc$1(_sfc_main$A, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/countdown/src/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 __default__$o = /* @__PURE__ */ defineComponent({
      name: "ElSteps"
    });
    const _sfc_main$z = /* @__PURE__ */ defineComponent({
      ...__default__$o,
      props: stepsProps,
      emits: stepsEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const ns = useNamespace("steps");
        const {
          children: steps,
          addChild: addStep,
          removeChild: removeStep
        } = useOrderedChildren(getCurrentInstance(), "ElStep");
        watch(steps, () => {
          steps.value.forEach((instance, index2) => {
            instance.setIndex(index2);
          });
        });
        provide("ElSteps", { props, steps, addStep, removeStep });
        watch(() => props.active, (newVal, oldVal) => {
          emit2(CHANGE_EVENT, newVal, oldVal);
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.simple ? "simple" : _ctx.direction)])
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Steps = /* @__PURE__ */ _export_sfc$1(_sfc_main$z, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/steps/src/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__$n = /* @__PURE__ */ defineComponent({
      name: "ElStep"
    });
    const _sfc_main$y = /* @__PURE__ */ defineComponent({
      ...__default__$n,
      props: stepProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("step");
        const index2 = ref(-1);
        const lineStyle = ref({});
        const internalStatus = ref("");
        const parent = inject("ElSteps");
        const currentInstance2 = getCurrentInstance();
        onMounted(() => {
          watch([
            () => parent.props.active,
            () => parent.props.processStatus,
            () => parent.props.finishStatus
          ], ([active]) => {
            updateStatus(active);
          }, { immediate: true });
        });
        onBeforeUnmount(() => {
          parent.removeStep(stepItemState.uid);
        });
        const currentStatus = computed(() => {
          return props.status || internalStatus.value;
        });
        const prevStatus = computed(() => {
          const prevStep = parent.steps.value[index2.value - 1];
          return prevStep ? prevStep.currentStatus : "wait";
        });
        const isCenter = computed(() => {
          return parent.props.alignCenter;
        });
        const isVertical = computed(() => {
          return parent.props.direction === "vertical";
        });
        const isSimple = computed(() => {
          return parent.props.simple;
        });
        const stepsCount = computed(() => {
          return parent.steps.value.length;
        });
        const isLast = computed(() => {
          var _a2;
          return ((_a2 = parent.steps.value[stepsCount.value - 1]) == null ? void 0 : _a2.uid) === (currentInstance2 == null ? void 0 : currentInstance2.uid);
        });
        const space = computed(() => {
          return isSimple.value ? "" : parent.props.space;
        });
        const containerKls = 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 = 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) => {
          index2.value = val;
        };
        const calcProgress = (status) => {
          const isWait = status === "wait";
          const style2 = {
            transitionDelay: `${isWait ? "-" : ""}${150 * index2.value}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 > index2.value) {
            internalStatus.value = parent.props.finishStatus;
          } else if (activeIndex === index2.value && prevStatus.value !== "error") {
            internalStatus.value = parent.props.processStatus;
          } else {
            internalStatus.value = "wait";
          }
          const prevChild = parent.steps.value[index2.value - 1];
          if (prevChild)
            prevChild.calcProgress(internalStatus.value);
        };
        const stepItemState = reactive({
          uid: currentInstance2.uid,
          currentStatus,
          setIndex,
          calcProgress
        });
        parent.addStep(stepItemState);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            style: normalizeStyle(unref(style)),
            class: normalizeClass(unref(containerKls))
          }, [
            createCommentVNode(" icon & line "),
            createBaseVNode("div", {
              class: normalizeClass([unref(ns).e("head"), unref(ns).is(unref(currentStatus))])
            }, [
              !unref(isSimple) ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ns).e("line"))
              }, [
                createBaseVNode("i", {
                  class: normalizeClass(unref(ns).e("line-inner")),
                  style: normalizeStyle(lineStyle.value)
                }, null, 6)
              ], 2)) : createCommentVNode("v-if", true),
              createBaseVNode("div", {
                class: normalizeClass([unref(ns).e("icon"), unref(ns).is(_ctx.icon || _ctx.$slots.icon ? "icon" : "text")])
              }, [
                renderSlot(_ctx.$slots, "icon", {}, () => [
                  _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), {
                    key: 0,
                    class: normalizeClass(unref(ns).e("icon-inner"))
                  }, {
                    default: withCtx(() => [
                      (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
                    ]),
                    _: 1
                  }, 8, ["class"])) : unref(currentStatus) === "success" ? (openBlock(), createBlock(unref(ElIcon), {
                    key: 1,
                    class: normalizeClass([unref(ns).e("icon-inner"), unref(ns).is("status")])
                  }, {
                    default: withCtx(() => [
                      createVNode(unref(check_default))
                    ]),
                    _: 1
                  }, 8, ["class"])) : unref(currentStatus) === "error" ? (openBlock(), createBlock(unref(ElIcon), {
                    key: 2,
                    class: normalizeClass([unref(ns).e("icon-inner"), unref(ns).is("status")])
                  }, {
                    default: withCtx(() => [
                      createVNode(unref(close_default))
                    ]),
                    _: 1
                  }, 8, ["class"])) : !unref(isSimple) ? (openBlock(), createElementBlock("div", {
                    key: 3,
                    class: normalizeClass(unref(ns).e("icon-inner"))
                  }, toDisplayString(index2.value + 1), 3)) : createCommentVNode("v-if", true)
                ])
              ], 2)
            ], 2),
            createCommentVNode(" title & description "),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("main"))
            }, [
              createBaseVNode("div", {
                class: normalizeClass([unref(ns).e("title"), unref(ns).is(unref(currentStatus))])
              }, [
                renderSlot(_ctx.$slots, "title", {}, () => [
                  createTextVNode(toDisplayString(_ctx.title), 1)
                ])
              ], 2),
              unref(isSimple) ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ns).e("arrow"))
              }, null, 2)) : (openBlock(), createElementBlock("div", {
                key: 1,
                class: normalizeClass([unref(ns).e("description"), unref(ns).is(unref(currentStatus))])
              }, [
                renderSlot(_ctx.$slots, "description", {}, () => [
                  createTextVNode(toDisplayString(_ctx.description), 1)
                ])
              ], 2))
            ], 2)
          ], 6);
        };
      }
    });
    var Step = /* @__PURE__ */ _export_sfc$1(_sfc_main$y, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/steps/src/item.vue"]]);
    const ElSteps = withInstall(Steps, {
      Step
    });
    const ElStep = withNoopInstall(Step);
    const switchProps = buildProps({
      modelValue: {
        type: [Boolean, String, Number],
        default: false
      },
      disabled: {
        type: Boolean,
        default: false
      },
      loading: {
        type: Boolean,
        default: false
      },
      size: {
        type: String,
        validator: isValidComponentSize
      },
      width: {
        type: [String, Number],
        default: ""
      },
      inlinePrompt: {
        type: Boolean,
        default: false
      },
      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
      },
      activeColor: {
        type: String,
        default: ""
      },
      inactiveColor: {
        type: String,
        default: ""
      },
      borderColor: {
        type: String,
        default: ""
      },
      name: {
        type: String,
        default: ""
      },
      validateEvent: {
        type: Boolean,
        default: true
      },
      beforeChange: {
        type: definePropType(Function)
      },
      id: String,
      tabindex: {
        type: [String, Number]
      },
      value: {
        type: [Boolean, String, Number],
        default: false
      },
      label: {
        type: String,
        default: void 0
      }
    });
    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 _hoisted_1$f = ["onClick"];
    const _hoisted_2$a = ["id", "aria-checked", "aria-disabled", "aria-label", "name", "true-value", "false-value", "disabled", "tabindex", "onKeydown"];
    const _hoisted_3$4 = ["aria-hidden"];
    const _hoisted_4$2 = ["aria-hidden"];
    const _hoisted_5$1 = ["aria-hidden"];
    const COMPONENT_NAME$8 = "ElSwitch";
    const __default__$m = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$8
    });
    const _sfc_main$x = /* @__PURE__ */ defineComponent({
      ...__default__$m,
      props: switchProps,
      emits: switchEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const vm = getCurrentInstance();
        const { formItem } = useFormItem();
        const switchSize = useFormSize();
        const ns = useNamespace("switch");
        const useBatchDeprecated = (list) => {
          list.forEach((param) => {
            useDeprecated({
              from: param[0],
              replacement: param[1],
              scope: COMPONENT_NAME$8,
              version: "2.3.0",
              ref: "https://element-plus.org/en-US/component/switch.html#attributes",
              type: "Attribute"
            }, computed(() => {
              var _a2;
              return !!((_a2 = vm.vnode.props) == null ? void 0 : _a2[param[2]]);
            }));
          });
        };
        useBatchDeprecated([
          ['"value"', '"model-value" or "v-model"', "value"],
          ['"active-color"', "CSS var `--el-switch-on-color`", "activeColor"],
          ['"inactive-color"', "CSS var `--el-switch-off-color`", "inactiveColor"],
          ['"border-color"', "CSS var `--el-switch-border-color`", "borderColor"]
        ]);
        const { inputId } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const switchDisabled = useFormDisabled(computed(() => props.loading));
        const isControlled = ref(props.modelValue !== false);
        const input = ref();
        const core = ref();
        const switchKls = computed(() => [
          ns.b(),
          ns.m(switchSize.value),
          ns.is("disabled", switchDisabled.value),
          ns.is("checked", checked.value)
        ]);
        const labelLeftKls = computed(() => [
          ns.e("label"),
          ns.em("label", "left"),
          ns.is("active", !checked.value)
        ]);
        const labelRightKls = computed(() => [
          ns.e("label"),
          ns.em("label", "right"),
          ns.is("active", checked.value)
        ]);
        const coreStyle = computed(() => ({
          width: addUnit(props.width)
        }));
        watch(() => props.modelValue, () => {
          isControlled.value = true;
        });
        watch(() => props.value, () => {
          isControlled.value = false;
        });
        const actualValue = computed(() => {
          return isControlled.value ? props.modelValue : props.value;
        });
        const checked = computed(() => actualValue.value === props.activeValue);
        if (![props.activeValue, props.inactiveValue].includes(actualValue.value)) {
          emit2(UPDATE_MODEL_EVENT, props.inactiveValue);
          emit2(CHANGE_EVENT, props.inactiveValue);
          emit2(INPUT_EVENT, props.inactiveValue);
        }
        watch(checked, (val) => {
          var _a2;
          input.value.checked = val;
          if (props.validateEvent) {
            (_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn());
          }
        });
        const handleChange = () => {
          const val = checked.value ? props.inactiveValue : props.activeValue;
          emit2(UPDATE_MODEL_EVENT, val);
          emit2(CHANGE_EVENT, val);
          emit2(INPUT_EVENT, val);
          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$8, "beforeChange must return type `Promise<boolean>` or `boolean`");
          }
          if (isPromise(shouldChange)) {
            shouldChange.then((result) => {
              if (result) {
                handleChange();
              }
            }).catch((e) => {
            });
          } else if (shouldChange) {
            handleChange();
          }
        };
        const styles = computed(() => {
          return ns.cssVarBlock({
            ...props.activeColor ? { "on-color": props.activeColor } : null,
            ...props.inactiveColor ? { "off-color": props.inactiveColor } : null,
            ...props.borderColor ? { "border-color": props.borderColor } : null
          });
        });
        const focus = () => {
          var _a2, _b;
          (_b = (_a2 = input.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
        };
        onMounted(() => {
          input.value.checked = checked.value;
        });
        expose({
          focus,
          checked
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(switchKls)),
            style: normalizeStyle(unref(styles)),
            onClick: withModifiers(switchValue, ["prevent"])
          }, [
            createBaseVNode("input", {
              id: unref(inputId),
              ref_key: "input",
              ref: input,
              class: normalizeClass(unref(ns).e("input")),
              type: "checkbox",
              role: "switch",
              "aria-checked": unref(checked),
              "aria-disabled": unref(switchDisabled),
              "aria-label": _ctx.label,
              name: _ctx.name,
              "true-value": _ctx.activeValue,
              "false-value": _ctx.inactiveValue,
              disabled: unref(switchDisabled),
              tabindex: _ctx.tabindex,
              onChange: handleChange,
              onKeydown: withKeys(switchValue, ["enter"])
            }, null, 42, _hoisted_2$a),
            !_ctx.inlinePrompt && (_ctx.inactiveIcon || _ctx.inactiveText) ? (openBlock(), createElementBlock("span", {
              key: 0,
              class: normalizeClass(unref(labelLeftKls))
            }, [
              _ctx.inactiveIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
                default: withCtx(() => [
                  (openBlock(), createBlock(resolveDynamicComponent(_ctx.inactiveIcon)))
                ]),
                _: 1
              })) : createCommentVNode("v-if", true),
              !_ctx.inactiveIcon && _ctx.inactiveText ? (openBlock(), createElementBlock("span", {
                key: 1,
                "aria-hidden": unref(checked)
              }, toDisplayString(_ctx.inactiveText), 9, _hoisted_3$4)) : createCommentVNode("v-if", true)
            ], 2)) : createCommentVNode("v-if", true),
            createBaseVNode("span", {
              ref_key: "core",
              ref: core,
              class: normalizeClass(unref(ns).e("core")),
              style: normalizeStyle(unref(coreStyle))
            }, [
              _ctx.inlinePrompt ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass(unref(ns).e("inner"))
              }, [
                _ctx.activeIcon || _ctx.inactiveIcon ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 0,
                  class: normalizeClass(unref(ns).is("icon"))
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(unref(checked) ? _ctx.activeIcon : _ctx.inactiveIcon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : _ctx.activeText || _ctx.inactiveText ? (openBlock(), createElementBlock("span", {
                  key: 1,
                  class: normalizeClass(unref(ns).is("text")),
                  "aria-hidden": !unref(checked)
                }, toDisplayString(unref(checked) ? _ctx.activeText : _ctx.inactiveText), 11, _hoisted_4$2)) : createCommentVNode("v-if", true)
              ], 2)) : createCommentVNode("v-if", true),
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).e("action"))
              }, [
                _ctx.loading ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 0,
                  class: normalizeClass(unref(ns).is("loading"))
                }, {
                  default: withCtx(() => [
                    createVNode(unref(loading_default))
                  ]),
                  _: 1
                }, 8, ["class"])) : _ctx.activeActionIcon && unref(checked) ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.activeActionIcon)))
                  ]),
                  _: 1
                })) : _ctx.inactiveActionIcon && !unref(checked) ? (openBlock(), createBlock(unref(ElIcon), { key: 2 }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.inactiveActionIcon)))
                  ]),
                  _: 1
                })) : createCommentVNode("v-if", true)
              ], 2)
            ], 6),
            !_ctx.inlinePrompt && (_ctx.activeIcon || _ctx.activeText) ? (openBlock(), createElementBlock("span", {
              key: 1,
              class: normalizeClass(unref(labelRightKls))
            }, [
              _ctx.activeIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
                default: withCtx(() => [
                  (openBlock(), createBlock(resolveDynamicComponent(_ctx.activeIcon)))
                ]),
                _: 1
              })) : createCommentVNode("v-if", true),
              !_ctx.activeIcon && _ctx.activeText ? (openBlock(), createElementBlock("span", {
                key: 1,
                "aria-hidden": !unref(checked)
              }, toDisplayString(_ctx.activeText), 9, _hoisted_5$1)) : createCommentVNode("v-if", true)
            ], 2)) : createCommentVNode("v-if", true)
          ], 14, _hoisted_1$f);
        };
      }
    });
    var Switch = /* @__PURE__ */ _export_sfc$1(_sfc_main$x, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/switch/src/switch.vue"]]);
    const ElSwitch = withInstall(Switch);
    /*!
     * escape-html
     * Copyright(c) 2012-2013 TJ Holowaychuk
     * Copyright(c) 2015 Andreas Lubbe
     * Copyright(c) 2015 Tiancheng "Timothy" Gu
     * MIT Licensed
     */
    var matchHtmlRegExp = /["'&<>]/;
    var escapeHtml_1 = escapeHtml;
    function escapeHtml(string2) {
      var str = "" + string2;
      var match = matchHtmlRegExp.exec(str);
      if (!match) {
        return str;
      }
      var escape;
      var html = "";
      var index2 = 0;
      var lastIndex = 0;
      for (index2 = match.index; index2 < str.length; index2++) {
        switch (str.charCodeAt(index2)) {
          case 34:
            escape = "&quot;";
            break;
          case 38:
            escape = "&amp;";
            break;
          case 39:
            escape = "&#39;";
            break;
          case 60:
            escape = "&lt;";
            break;
          case 62:
            escape = "&gt;";
            break;
          default:
            continue;
        }
        if (lastIndex !== index2) {
          html += str.substring(lastIndex, index2);
        }
        lastIndex = index2 + 1;
        html += escape;
      }
      return lastIndex !== index2 ? html + str.substring(lastIndex, index2) : html;
    }
    const escapeHtml$1 = /* @__PURE__ */ getDefaultExportFromCjs(escapeHtml_1);
    const getCell = function(event) {
      var _a2;
      return (_a2 = event.target) == null ? void 0 : _a2.closest("td");
    };
    const orderBy = function(array2, sortKey, reverse, sortMethod, sortBy) {
      if (!sortKey && !sortMethod && (!sortBy || Array.isArray(sortBy) && !sortBy.length)) {
        return array2;
      }
      if (typeof reverse === "string") {
        reverse = reverse === "descending" ? -1 : 1;
      } else {
        reverse = reverse && reverse < 0 ? -1 : 1;
      }
      const getKey = sortMethod ? null : function(value, index2) {
        if (sortBy) {
          if (!Array.isArray(sortBy)) {
            sortBy = [sortBy];
          }
          return sortBy.map((by) => {
            if (typeof by === "string") {
              return get(value, by);
            } else {
              return by(value, index2, array2);
            }
          });
        }
        if (sortKey !== "$key") {
          if (isObject$1(value) && "$value" in value)
            value = value.$value;
        }
        return [isObject$1(value) ? get(value, sortKey) : value];
      };
      const compare = function(a2, b2) {
        if (sortMethod) {
          return sortMethod(a2.value, b2.value);
        }
        for (let i = 0, len = a2.key.length; i < len; i++) {
          if (a2.key[i] < b2.key[i]) {
            return -1;
          }
          if (a2.key[i] > b2.key[i]) {
            return 1;
          }
        }
        return 0;
      };
      return array2.map((value, index2) => {
        return {
          value,
          index: index2,
          key: getKey ? getKey(value, index2) : null
        };
      }).sort((a2, b2) => {
        let order = compare(a2, b2);
        if (!order) {
          order = a2.index - b2.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, rowKey2) => {
      if (!row)
        throw new Error("Row is required when get row identity");
      if (typeof rowKey2 === "string") {
        if (!rowKey2.includes(".")) {
          return `${row[rowKey2]}`;
        }
        const key = rowKey2.split(".");
        let current = row;
        for (const element of key) {
          current = current[element];
        }
        return `${current}`;
      } else if (typeof rowKey2 === "function") {
        return rowKey2.call(null, row);
      }
    };
    const getKeysMap = function(array2, rowKey2) {
      const arrayMap2 = {};
      (array2 || []).forEach((row, index2) => {
        arrayMap2[getRowIdentity(row, rowKey2)] = { row, index: index2 };
      });
      return arrayMap2;
    };
    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 (typeof value !== "undefined") {
            options[key] = value;
          }
        }
      }
      return options;
    }
    function parseWidth(width) {
      if (width === "")
        return width;
      if (width !== void 0) {
        width = Number.parseInt(width, 10);
        if (Number.isNaN(width)) {
          width = "";
        }
      }
      return width;
    }
    function parseMinWidth(minWidth) {
      if (minWidth === "")
        return minWidth;
      if (minWidth !== void 0) {
        minWidth = parseWidth(minWidth);
        if (Number.isNaN(minWidth)) {
          minWidth = 80;
        }
      }
      return minWidth;
    }
    function parseHeight(height) {
      if (typeof height === "number") {
        return height;
      }
      if (typeof height === "string") {
        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((a2, b2) => (...args) => a2(b2(...args)));
    }
    function toggleRowStatus(statusArr, row, newVal) {
      let changed = false;
      const index2 = statusArr.indexOf(row);
      const included = index2 !== -1;
      const toggleStatus = (type2) => {
        if (type2 === "add") {
          statusArr.push(row);
        } else {
          statusArr.splice(index2, 1);
        }
        changed = true;
        if (isArray$3(row.children)) {
          row.children.forEach((item) => {
            toggleRowStatus(statusArr, item, newVal != null ? newVal : !included);
          });
        }
      };
      if (isBoolean(newVal)) {
        if (newVal && !included) {
          toggleStatus("add");
        } else if (!newVal && included) {
          toggleStatus("remove");
        }
      } else {
        included ? toggleStatus("remove") : toggleStatus("add");
      }
      return changed;
    }
    function walkTreeNode(root2, cb, childrenKey = "children", lazyKey = "hasChildren") {
      const isNil2 = (array2) => !(Array.isArray(array2) && array2.length);
      function _walker(parent, children, level) {
        cb(parent, children, level);
        children.forEach((item) => {
          if (item[lazyKey]) {
            cb(item, null, level + 1);
            return;
          }
          const children2 = item[childrenKey];
          if (!isNil2(children2)) {
            _walker(item, children2, level + 1);
          }
        });
      }
      root2.forEach((item) => {
        if (item[lazyKey]) {
          cb(item, null, 0);
          return;
        }
        const children = item[childrenKey];
        if (!isNil2(children)) {
          _walker(item, children, 0);
        }
      });
    }
    let removePopper;
    function createTablePopper(parentNode, trigger2, popperContent, nextZIndex, tooltipOptions) {
      tooltipOptions = merge$1({
        enterable: true,
        showArrow: true
      }, tooltipOptions);
      const ns = parentNode == null ? void 0 : parentNode.dataset.prefix;
      const scrollContainer = parentNode == null ? void 0 : parentNode.querySelector(`.${ns}-scrollbar__wrap`);
      function renderContent() {
        const isLight = tooltipOptions.effect === "light";
        const content2 = document.createElement("div");
        content2.className = [
          `${ns}-popper`,
          isLight ? "is-light" : "is-dark",
          tooltipOptions.popperClass || ""
        ].join(" ");
        popperContent = escapeHtml$1(popperContent);
        content2.innerHTML = popperContent;
        content2.style.zIndex = String(nextZIndex());
        parentNode == null ? void 0 : parentNode.appendChild(content2);
        return content2;
      }
      function renderArrow() {
        const arrow2 = document.createElement("div");
        arrow2.className = `${ns}-popper__arrow`;
        return arrow2;
      }
      function showPopper() {
        popperInstance && popperInstance.update();
      }
      removePopper == null ? void 0 : removePopper();
      removePopper = () => {
        try {
          popperInstance && popperInstance.destroy();
          content && (parentNode == null ? void 0 : parentNode.removeChild(content));
          trigger2.removeEventListener("mouseenter", onOpen);
          trigger2.removeEventListener("mouseleave", onClose);
          scrollContainer == null ? void 0 : scrollContainer.removeEventListener("scroll", removePopper);
          removePopper = void 0;
        } catch (e) {
        }
      };
      let popperInstance = null;
      let onOpen = showPopper;
      let onClose = removePopper;
      if (tooltipOptions.enterable) {
        ({ onOpen, onClose } = useDelayedToggle({
          showAfter: tooltipOptions.showAfter,
          hideAfter: tooltipOptions.hideAfter,
          open: showPopper,
          close: removePopper
        }));
      }
      const content = renderContent();
      content.onmouseenter = onOpen;
      content.onmouseleave = onClose;
      const modifiers = [];
      if (tooltipOptions.offset) {
        modifiers.push({
          name: "offset",
          options: {
            offset: [0, tooltipOptions.offset]
          }
        });
      }
      if (tooltipOptions.showArrow) {
        const arrow2 = content.appendChild(renderArrow());
        modifiers.push({
          name: "arrow",
          options: {
            element: arrow2,
            padding: 10
          }
        });
      }
      const popperOptions = tooltipOptions.popperOptions || {};
      popperInstance = yn(trigger2, content, {
        placement: tooltipOptions.placement || "top",
        strategy: "fixed",
        ...popperOptions,
        modifiers: popperOptions.modifiers ? modifiers.concat(popperOptions.modifiers) : modifiers
      });
      trigger2.addEventListener("mouseenter", onOpen);
      trigger2.addEventListener("mouseleave", onClose);
      scrollContainer == null ? void 0 : scrollContainer.addEventListener("scroll", removePopper);
      return popperInstance;
    }
    function getCurrentColumns(column) {
      if (column.children) {
        return flatMap(column.children, getCurrentColumns);
      } else {
        return [column];
      }
    }
    function getColSpan(colSpan, column) {
      return colSpan + column.colSpan;
    }
    const isFixedColumn = (index2, fixed, store, realColumns) => {
      let start = 0;
      let after = index2;
      const columns2 = store.states.columns.value;
      if (realColumns) {
        const curColumns = getCurrentColumns(realColumns[index2]);
        const preColumns = columns2.slice(0, columns2.indexOf(curColumns[0]));
        start = preColumns.reduce(getColSpan, 0);
        after = start + curColumns.reduce(getColSpan, 0) - 1;
      } else {
        start = index2;
      }
      let fixedLayout;
      switch (fixed) {
        case "left":
          if (after < store.states.fixedLeafColumnsLength.value) {
            fixedLayout = "left";
          }
          break;
        case "right":
          if (start >= columns2.length - store.states.rightFixedLeafColumnsLength.value) {
            fixedLayout = "right";
          }
          break;
        default:
          if (after < store.states.fixedLeafColumnsLength.value) {
            fixedLayout = "left";
          } else if (start >= columns2.length - store.states.rightFixedLeafColumnsLength.value) {
            fixedLayout = "right";
          }
      }
      return fixedLayout ? {
        direction: fixedLayout,
        start,
        after
      } : {};
    };
    const getFixedColumnsClass = (namespace, index2, fixed, store, realColumns, offset2 = 0) => {
      const classes = [];
      const { direction: direction2, start, after } = isFixedColumn(index2, fixed, store, realColumns);
      if (direction2) {
        const isLeft = direction2 === "left";
        classes.push(`${namespace}-fixed-column--${direction2}`);
        if (isLeft && after + offset2 === store.states.fixedLeafColumnsLength.value - 1) {
          classes.push("is-last-column");
        } else if (!isLeft && start - offset2 === store.states.columns.value.length - store.states.rightFixedLeafColumnsLength.value) {
          classes.push("is-first-column");
        }
      }
      return classes;
    };
    function getOffset(offset2, column) {
      return offset2 + (column.realWidth === null || Number.isNaN(column.realWidth) ? Number(column.width) : column.realWidth);
    }
    const getFixedColumnOffset = (index2, fixed, store, realColumns) => {
      const {
        direction: direction2,
        start = 0,
        after = 0
      } = isFixedColumn(index2, fixed, store, realColumns);
      if (!direction2) {
        return;
      }
      const styles = {};
      const isLeft = direction2 === "left";
      const columns2 = store.states.columns.value;
      if (isLeft) {
        styles.left = columns2.slice(0, start).reduce(getOffset, 0);
      } else {
        styles.right = columns2.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 = getCurrentInstance();
      const defaultExpandAll = ref(false);
      const expandRows = ref([]);
      const updateExpandRows = () => {
        const data = watcherData.data.value || [];
        const rowKey2 = watcherData.rowKey.value;
        if (defaultExpandAll.value) {
          expandRows.value = data.slice();
        } else if (rowKey2) {
          const expandRowsMap = getKeysMap(expandRows.value, rowKey2);
          expandRows.value = data.reduce((prev, row) => {
            const rowId = getRowIdentity(row, rowKey2);
            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);
        if (changed) {
          instance.emit("expand-change", row, expandRows.value.slice());
        }
      };
      const setExpandRowKeys = (rowKeys) => {
        instance.store.assertRowKey();
        const data = watcherData.data.value || [];
        const rowKey2 = watcherData.rowKey.value;
        const keysMap = getKeysMap(data, rowKey2);
        expandRows.value = rowKeys.reduce((prev, cur) => {
          const info = keysMap[cur];
          if (info) {
            prev.push(info.row);
          }
          return prev;
        }, []);
      };
      const isRowExpanded = (row) => {
        const rowKey2 = watcherData.rowKey.value;
        if (rowKey2) {
          const expandMap = getKeysMap(expandRows.value, rowKey2);
          return !!expandMap[getRowIdentity(row, rowKey2)];
        }
        return expandRows.value.includes(row);
      };
      return {
        updateExpandRows,
        toggleRowExpansion,
        setExpandRowKeys,
        isRowExpanded,
        states: {
          expandRows,
          defaultExpandAll
        }
      };
    }
    function useCurrent(watcherData) {
      const instance = getCurrentInstance();
      const _currentRowKey = ref(null);
      const currentRow = ref(null);
      const setCurrentRowKey = (key) => {
        instance.store.assertRowKey();
        _currentRowKey.value = key;
        setCurrentRowByKey(key);
      };
      const restoreCurrentRowKey = () => {
        _currentRowKey.value = null;
      };
      const setCurrentRowByKey = (key) => {
        const { data, rowKey: rowKey2 } = watcherData;
        let _currentRow = null;
        if (rowKey2.value) {
          _currentRow = (unref(data) || []).find((item) => getRowIdentity(item, rowKey2.value) === key);
        }
        currentRow.value = _currentRow;
        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 rowKey2 = watcherData.rowKey.value;
        const data = watcherData.data.value || [];
        const oldCurrentRow = currentRow.value;
        if (!data.includes(oldCurrentRow) && oldCurrentRow) {
          if (rowKey2) {
            const currentRowKey = getRowIdentity(oldCurrentRow, rowKey2);
            setCurrentRowByKey(currentRowKey);
          } else {
            currentRow.value = null;
          }
          if (currentRow.value === null) {
            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 = ref([]);
      const treeData = ref({});
      const indent = ref(16);
      const lazy = ref(false);
      const lazyTreeNodeMap = ref({});
      const lazyColumnIdentifier = ref("hasChildren");
      const childrenColumnName = ref("children");
      const instance = getCurrentInstance();
      const normalizedData = computed(() => {
        if (!watcherData.rowKey.value)
          return {};
        const data = watcherData.data.value || [];
        return normalize(data);
      });
      const normalizedLazyNode = computed(() => {
        const rowKey2 = watcherData.rowKey.value;
        const keys2 = Object.keys(lazyTreeNodeMap.value);
        const res = {};
        if (!keys2.length)
          return res;
        keys2.forEach((key) => {
          if (lazyTreeNodeMap.value[key].length) {
            const item = { children: [] };
            lazyTreeNodeMap.value[key].forEach((row) => {
              const currentRowKey = getRowIdentity(row, rowKey2);
              item.children.push(currentRowKey);
              if (row[lazyColumnIdentifier.value] && !res[currentRowKey]) {
                res[currentRowKey] = { children: [] };
              }
            });
            res[key] = item;
          }
        });
        return res;
      });
      const normalize = (data) => {
        const rowKey2 = watcherData.rowKey.value;
        const res = {};
        walkTreeNode(data, (parent, children, level) => {
          const parentId = getRowIdentity(parent, rowKey2);
          if (Array.isArray(children)) {
            res[parentId] = {
              children: children.map((row) => getRowIdentity(row, rowKey2)),
              level
            };
          } else if (lazy.value) {
            res[parentId] = {
              children: [],
              lazy: true,
              level
            };
          }
        }, childrenColumnName.value, lazyColumnIdentifier.value);
        return res;
      };
      const updateTreeData = (ifChangeExpandRowKeys = false, ifExpandAll = ((_a2) => (_a2 = instance.store) == null ? void 0 : _a2.states.defaultExpandAll.value)()) => {
        var _a2;
        const nested = normalizedData.value;
        const normalizedLazyNode_ = normalizedLazyNode.value;
        const keys2 = Object.keys(nested);
        const newTreeData = {};
        if (keys2.length) {
          const oldTreeData = 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);
            }
          };
          keys2.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) => {
              const oldValue = oldTreeData[key];
              const lazyNodeChildren = normalizedLazyNode_[key].children;
              if (rootLazyRowKeys.includes(key)) {
                if (newTreeData[key].children.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: ""
                };
              }
            });
          }
        }
        treeData.value = newTreeData;
        (_a2 = instance.store) == null ? void 0 : _a2.updateTableScrollY();
      };
      watch(() => expandRowKeys.value, () => {
        updateTreeData(true);
      });
      watch(() => normalizedData.value, () => {
        updateTreeData();
      });
      watch(() => normalizedLazyNode.value, () => {
        updateTreeData();
      });
      const updateTreeExpandKeys = (value) => {
        expandRowKeys.value = value;
        updateTreeData();
      };
      const toggleTreeExpansion = (row, expanded) => {
        instance.store.assertRowKey();
        const rowKey2 = watcherData.rowKey.value;
        const id = getRowIdentity(row, rowKey2);
        const data = id && treeData.value[id];
        if (id && data && "expanded" in data) {
          const oldExpanded = data.expanded;
          expanded = typeof expanded === "undefined" ? !data.expanded : expanded;
          treeData.value[id].expanded = expanded;
          if (oldExpanded !== expanded) {
            instance.emit("expand-change", row, expanded);
          }
          instance.store.updateTableScrollY();
        }
      };
      const loadOrToggle = (row) => {
        instance.store.assertRowKey();
        const rowKey2 = watcherData.rowKey.value;
        const id = getRowIdentity(row, rowKey2);
        const data = treeData.value[id];
        if (lazy.value && data && "loaded" in data && !data.loaded) {
          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 (!Array.isArray(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);
          });
        }
      };
      return {
        loadData,
        loadOrToggle,
        toggleTreeExpansion,
        updateTreeExpandKeys,
        updateTreeData,
        normalize,
        states: {
          expandRowKeys,
          treeData,
          indent,
          lazy,
          lazyTreeNodeMap,
          lazyColumnIdentifier,
          childrenColumnName
        }
      };
    }
    const sortData = (data, states) => {
      const sortingColumn = states.sortingColumn;
      if (!sortingColumn || typeof sortingColumn.sortable === "string") {
        return data;
      }
      return orderBy(data, states.sortProp, states.sortOrder, sortingColumn.sortMethod, sortingColumn.sortBy);
    };
    const doFlattenColumns = (columns2) => {
      const result = [];
      columns2.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 _a2;
      const instance = getCurrentInstance();
      const { size: tableSize } = toRefs((_a2 = instance.proxy) == null ? void 0 : _a2.$props);
      const rowKey2 = ref(null);
      const data = ref([]);
      const _data = ref([]);
      const isComplex = ref(false);
      const _columns = ref([]);
      const originColumns = ref([]);
      const columns2 = ref([]);
      const fixedColumns = ref([]);
      const rightFixedColumns = ref([]);
      const leafColumns = ref([]);
      const fixedLeafColumns = ref([]);
      const rightFixedLeafColumns = ref([]);
      const updateOrderFns = [];
      const leafColumnsLength = ref(0);
      const fixedLeafColumnsLength = ref(0);
      const rightFixedLeafColumnsLength = ref(0);
      const isAllSelected = ref(false);
      const selection = ref([]);
      const reserveSelection = ref(false);
      const selectOnIndeterminate = ref(false);
      const selectable = ref(null);
      const filters = ref({});
      const filteredData = ref(null);
      const sortingColumn = ref(null);
      const sortProp = ref(null);
      const sortOrder = ref(null);
      const hoverRow = ref(null);
      watch(data, () => instance.state && scheduleLayout(false), {
        deep: true
      });
      const assertRowKey = () => {
        if (!rowKey2.value)
          throw new Error("[ElTable] prop row-key is required");
      };
      const updateChildFixed = (column) => {
        var _a22;
        (_a22 = column.children) == null ? void 0 : _a22.forEach((childColumn) => {
          childColumn.fixed = column.fixed;
          updateChildFixed(childColumn);
        });
      };
      const updateColumns = () => {
        _columns.value.forEach((column) => {
          updateChildFixed(column);
        });
        fixedColumns.value = _columns.value.filter((column) => column.fixed === true || column.fixed === "left");
        rightFixedColumns.value = _columns.value.filter((column) => column.fixed === "right");
        if (fixedColumns.value.length > 0 && _columns.value[0] && _columns.value[0].type === "selection" && !_columns.value[0].fixed) {
          _columns.value[0].fixed = true;
          fixedColumns.value.unshift(_columns.value[0]);
        }
        const notFixedColumns = _columns.value.filter((column) => !column.fixed);
        originColumns.value = [].concat(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;
        columns2.value = [].concat(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) => {
        return selection.value.includes(row);
      };
      const clearSelection = () => {
        isAllSelected.value = false;
        const oldSelection = selection.value;
        if (oldSelection.length) {
          selection.value = [];
          instance.emit("selection-change", []);
        }
      };
      const cleanSelection = () => {
        let deleted;
        if (rowKey2.value) {
          deleted = [];
          const selectedMap = getKeysMap(selection.value, rowKey2.value);
          const dataMap = getKeysMap(data.value, rowKey2.value);
          for (const key in selectedMap) {
            if (hasOwn(selectedMap, key) && !dataMap[key]) {
              deleted.push(selectedMap[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 = void 0, emitChange = true) => {
        const changed = toggleRowStatus(selection.value, row, selected);
        if (changed) {
          const newSelection = (selection.value || []).slice();
          if (emitChange) {
            instance.emit("select", newSelection, row);
          }
          instance.emit("selection-change", newSelection);
        }
      };
      const _toggleAllSelection = () => {
        var _a22, _b;
        const value = selectOnIndeterminate.value ? !isAllSelected.value : !(isAllSelected.value || selection.value.length);
        isAllSelected.value = value;
        let selectionChanged = false;
        let childrenCount = 0;
        const rowKey22 = (_b = (_a22 = instance == null ? void 0 : instance.store) == null ? void 0 : _a22.states) == null ? void 0 : _b.rowKey.value;
        data.value.forEach((row, index2) => {
          const rowIndex = index2 + childrenCount;
          if (selectable.value) {
            if (selectable.value.call(null, row, rowIndex) && toggleRowStatus(selection.value, row, value)) {
              selectionChanged = true;
            }
          } else {
            if (toggleRowStatus(selection.value, row, value)) {
              selectionChanged = true;
            }
          }
          childrenCount += getChildrenCount(getRowIdentity(row, rowKey22));
        });
        if (selectionChanged) {
          instance.emit("selection-change", selection.value ? selection.value.slice() : []);
        }
        instance.emit("select-all", selection.value);
      };
      const updateSelectionByRowKey = () => {
        const selectedMap = getKeysMap(selection.value, rowKey2.value);
        data.value.forEach((row) => {
          const rowId = getRowIdentity(row, rowKey2.value);
          const rowInfo = selectedMap[rowId];
          if (rowInfo) {
            selection.value[rowInfo.index] = row;
          }
        });
      };
      const updateAllSelected = () => {
        var _a22, _b, _c;
        if (((_a22 = data.value) == null ? void 0 : _a22.length) === 0) {
          isAllSelected.value = false;
          return;
        }
        let selectedMap;
        if (rowKey2.value) {
          selectedMap = getKeysMap(selection.value, rowKey2.value);
        }
        const isSelected2 = function(row) {
          if (selectedMap) {
            return !!selectedMap[getRowIdentity(row, rowKey2.value)];
          } else {
            return selection.value.includes(row);
          }
        };
        let isAllSelected_ = true;
        let selectedCount = 0;
        let childrenCount = 0;
        for (let i = 0, j = (data.value || []).length; i < j; i++) {
          const keyProp = (_c = (_b = instance == null ? void 0 : instance.store) == null ? void 0 : _b.states) == null ? void 0 : _c.rowKey.value;
          const rowIndex = i + childrenCount;
          const item = data.value[i];
          const isRowSelectable = selectable.value && selectable.value.call(null, item, rowIndex);
          if (!isSelected2(item)) {
            if (!selectable.value || isRowSelectable) {
              isAllSelected_ = false;
              break;
            }
          } else {
            selectedCount++;
          }
          childrenCount += getChildrenCount(getRowIdentity(item, keyProp));
        }
        if (selectedCount === 0)
          isAllSelected_ = false;
        isAllSelected.value = isAllSelected_;
      };
      const getChildrenCount = (rowKey22) => {
        var _a22;
        if (!instance || !instance.store)
          return 0;
        const { treeData } = instance.store.states;
        let count = 0;
        const children = (_a22 = treeData.value[rowKey22]) == null ? void 0 : _a22.children;
        if (children) {
          count += children.length;
          children.forEach((childKey) => {
            count += getChildrenCount(childKey);
          });
        }
        return count;
      };
      const updateFilters = (columns22, values) => {
        if (!Array.isArray(columns22)) {
          columns22 = [columns22];
        }
        const filters_ = {};
        columns22.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 = unref(_data);
        Object.keys(filters.value).forEach((columnId) => {
          const values = filters.value[columnId];
          if (!values || values.length === 0)
            return;
          const column = getColumnById({
            columns: columns2.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 = () => {
        data.value = sortData(filteredData.value, {
          sortingColumn: sortingColumn.value,
          sortProp: sortProp.value,
          sortOrder: sortOrder.value
        });
      };
      const execQuery = (ignore = void 0) => {
        if (!(ignore && ignore.filter)) {
          execFilter();
        }
        execSort();
      };
      const clearFilter = (columnKeys) => {
        const { tableHeaderRef } = instance.refs;
        if (!tableHeaderRef)
          return;
        const panels = Object.assign({}, tableHeaderRef.filterPanels);
        const keys2 = Object.keys(panels);
        if (!keys2.length)
          return;
        if (typeof columnKeys === "string") {
          columnKeys = [columnKeys];
        }
        if (Array.isArray(columnKeys)) {
          const columns_ = columnKeys.map((key) => getColumnByKey({
            columns: columns2.value
          }, key));
          keys2.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 {
          keys2.forEach((key) => {
            const column = columns2.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: rowKey2
      });
      const {
        updateTreeExpandKeys,
        toggleTreeExpansion,
        updateTreeData,
        loadOrToggle,
        states: treeStates
      } = useTree$2({
        data,
        rowKey: rowKey2
      });
      const {
        updateCurrentRowData,
        updateCurrentRow,
        setCurrentRowKey,
        states: currentData
      } = useCurrent({
        data,
        rowKey: rowKey2
      });
      const setExpandRowKeysAdapter = (val) => {
        setExpandRowKeys(val);
        updateTreeExpandKeys(val);
      };
      const toggleRowExpansionAdapter = (row, expanded) => {
        const hasExpandColumn = columns2.value.some(({ type: type2 }) => type2 === "expand");
        if (hasExpandColumn) {
          toggleRowExpansion(row, expanded);
        } else {
          toggleTreeExpansion(row, expanded);
        }
      };
      return {
        assertRowKey,
        updateColumns,
        scheduleLayout,
        isSelected,
        clearSelection,
        cleanSelection,
        getSelectionRows,
        toggleRowSelection,
        _toggleAllSelection,
        toggleAllSelection: null,
        updateSelectionByRowKey,
        updateAllSelected,
        updateFilters,
        updateCurrentRow,
        updateSort,
        execFilter,
        execSort,
        execQuery,
        clearFilter,
        clearSort,
        toggleRowExpansion,
        setExpandRowKeysAdapter,
        setCurrentRowKey,
        toggleRowExpansionAdapter,
        isRowExpanded,
        updateExpandRows,
        updateCurrentRowData,
        loadOrToggle,
        updateTreeData,
        states: {
          tableSize,
          rowKey: rowKey2,
          data,
          _data,
          isComplex,
          _columns,
          originColumns,
          columns: columns2,
          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(array2, column) {
      return array2.map((item) => {
        var _a2;
        if (item.id === column.id) {
          return column;
        } else if ((_a2 = item.children) == null ? void 0 : _a2.length) {
          item.children = replaceColumn(item.children, column);
        }
        return item;
      });
    }
    function sortColumn(array2) {
      array2.forEach((item) => {
        var _a2, _b;
        item.no = (_a2 = item.getColumnIndex) == null ? void 0 : _a2.call(item);
        if ((_b = item.children) == null ? void 0 : _b.length) {
          sortColumn(item.children);
        }
      });
      array2.sort((cur, pre) => cur.no - pre.no);
    }
    function useStore() {
      const instance = getCurrentInstance();
      const watcher = useWatcher$1();
      const ns = useNamespace("table");
      const mutations = {
        setData(states, data) {
          const dataInstanceChanged = 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 (unref(states.reserveSelection)) {
            instance.store.assertRowKey();
            instance.store.updateSelectionByRowKey();
          } else {
            if (dataInstanceChanged) {
              instance.store.clearSelection();
            } else {
              instance.store.cleanSelection();
            }
          }
          instance.store.updateAllSelected();
          if (instance.$ready) {
            instance.store.scheduleLayout();
          }
        },
        insertColumn(states, column, parent, updateColumnOrder) {
          const array2 = unref(states._columns);
          let newColumns = [];
          if (!parent) {
            array2.push(column);
            newColumns = array2;
          } else {
            if (parent && !parent.children) {
              parent.children = [];
            }
            parent.children.push(column);
            newColumns = replaceColumn(array2, 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 _a2;
          const newColumnIndex = (_a2 = column.getColumnIndex) == null ? void 0 : _a2.call(column);
          if (newColumnIndex === column.no)
            return;
          sortColumn(states._columns.value);
          if (instance.$ready) {
            instance.store.updateColumns();
          }
        },
        removeColumn(states, column, parent, updateColumnOrder) {
          const array2 = unref(states._columns) || [];
          if (parent) {
            parent.children.splice(parent.children.findIndex((item) => item.id === column.id), 1);
            nextTick(() => {
              var _a2;
              if (((_a2 = parent.children) == null ? void 0 : _a2.length) === 0) {
                delete parent.children;
              }
            });
            states._columns.value = replaceColumn(array2, parent);
          } else {
            const index2 = array2.indexOf(column);
            if (index2 > -1) {
              array2.splice(index2, 1);
              states._columns.value = array2;
            }
          }
          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 = 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 = unref(sortingColumn), propValue = unref(sortProp), orderValue = unref(sortOrder);
          if (orderValue === null) {
            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() {
          instance.store.toggleAllSelection();
        },
        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].concat(args));
        } else {
          throw new Error(`Action not found: ${name}`);
        }
      };
      const updateTableScrollY = function() {
        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"
      }
    };
    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) => {
        watch(() => getArrKeysValue(props, key), (value) => {
          handleValue(value, key, store);
        });
      });
    }
    function handleValue(value, propsKey, store) {
      let newVal = value;
      let storeKey = InitialStateMap[propsKey];
      if (typeof InitialStateMap[propsKey] === "object") {
        storeKey = storeKey.key;
        newVal = newVal || InitialStateMap[propsKey].default;
      }
      store.states[storeKey].value = newVal;
    }
    function getArrKeysValue(props, keys2) {
      if (keys2.includes(".")) {
        const keyList = keys2.split(".");
        let value = props;
        keyList.forEach((key) => {
          value = value[key];
        });
        return value;
      } else {
        return props[keys2];
      }
    }
    class TableLayout {
      constructor(options) {
        this.observers = [];
        this.table = null;
        this.store = null;
        this.columns = [];
        this.fit = true;
        this.showHeader = true;
        this.height = ref(null);
        this.scrollX = ref(false);
        this.scrollY = ref(false);
        this.bodyWidth = ref(null);
        this.fixedWidth = ref(null);
        this.rightFixedWidth = ref(null);
        this.gutterWidth = 0;
        for (const name in options) {
          if (hasOwn(options, name)) {
            if (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 (height === null)
          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))
          return nextTick(() => this.setHeight(value, prop));
        if (typeof value === "number") {
          el.style[prop] = `${value}px`;
          this.updateElsHeight();
        } else if (typeof value === "string") {
          el.style[prop] = value;
          this.updateElsHeight();
        }
      }
      setMaxHeight(value) {
        this.setHeight(value, "max-height");
      }
      getFlattenColumns() {
        const flattenColumns = [];
        const columns2 = this.table.store.states.columns.value;
        columns2.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() {
        if (!isClient)
          return;
        const fit = this.fit;
        const bodyWidth = this.table.vnode.el.clientWidth;
        let bodyMinWidth = 0;
        const flattenColumns = this.getFlattenColumns();
        const flexColumns = flattenColumns.filter((column) => typeof column.width !== "number");
        flattenColumns.forEach((column) => {
          if (typeof column.width === "number" && 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, index2) => {
                if (index2 === 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 index2 = this.observers.indexOf(observer);
        if (index2 !== -1) {
          this.observers.splice(index2, 1);
        }
      }
      notifyObservers(event) {
        const observers = this.observers;
        observers.forEach((observer) => {
          var _a2, _b;
          switch (event) {
            case "columns":
              (_a2 = observer.state) == null ? void 0 : _a2.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}.`);
          }
        });
      }
    }
    const { CheckboxGroup: ElCheckboxGroup } = ElCheckbox;
    const _sfc_main$w = /* @__PURE__ */ 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
        }
      },
      setup(props) {
        const instance = getCurrentInstance();
        const { t } = useLocale();
        const ns = useNamespace("table-filter");
        const parent = instance == null ? void 0 : instance.parent;
        if (!parent.filterPanels.value[props.column.id]) {
          parent.filterPanels.value[props.column.id] = instance;
        }
        const tooltipVisible = ref(false);
        const tooltip = ref(null);
        const filters = computed(() => {
          return props.column && props.column.filters;
        });
        const filterValue = computed({
          get: () => {
            var _a2;
            return (((_a2 = props.column) == null ? void 0 : _a2.filteredValue) || [])[0];
          },
          set: (value) => {
            if (filteredValue.value) {
              if (typeof value !== "undefined" && value !== null) {
                filteredValue.value.splice(0, 1, value);
              } else {
                filteredValue.value.splice(0, 1);
              }
            }
          }
        });
        const filteredValue = computed({
          get() {
            if (props.column) {
              return props.column.filteredValue || [];
            }
            return [];
          },
          set(value) {
            if (props.column) {
              props.upDataColumn("filteredValue", value);
            }
          }
        });
        const multiple = 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 (typeof _filterValue !== "undefined" && _filterValue !== null) {
            confirmFilter(filteredValue.value);
          } else {
            confirmFilter([]);
          }
          hidden();
        };
        const confirmFilter = (filteredValue2) => {
          props.store.commit("filterChange", {
            column: props.column,
            values: filteredValue2
          });
          props.store.updateAllSelected();
        };
        watch(tooltipVisible, (value) => {
          if (props.column) {
            props.upDataColumn("filterOpened", value);
          }
        }, {
          immediate: true
        });
        const popperPaneRef = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = tooltip.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
        });
        return {
          tooltipVisible,
          multiple,
          filteredValue,
          filterValue,
          filters,
          handleConfirm,
          handleReset,
          handleSelect,
          isActive,
          t,
          ns,
          showFilterPanel,
          hideFilterPanel,
          popperPaneRef,
          tooltip
        };
      }
    });
    const _hoisted_1$e = { key: 0 };
    const _hoisted_2$9 = ["disabled"];
    const _hoisted_3$3 = ["label", "onClick"];
    function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_checkbox = resolveComponent("el-checkbox");
      const _component_el_checkbox_group = resolveComponent("el-checkbox-group");
      const _component_el_scrollbar = resolveComponent("el-scrollbar");
      const _component_arrow_up = resolveComponent("arrow-up");
      const _component_arrow_down = resolveComponent("arrow-down");
      const _component_el_icon = resolveComponent("el-icon");
      const _component_el_tooltip = resolveComponent("el-tooltip");
      const _directive_click_outside = resolveDirective("click-outside");
      return openBlock(), 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.ns.b(),
        persistent: ""
      }, {
        content: withCtx(() => [
          _ctx.multiple ? (openBlock(), createElementBlock("div", _hoisted_1$e, [
            createBaseVNode("div", {
              class: normalizeClass(_ctx.ns.e("content"))
            }, [
              createVNode(_component_el_scrollbar, {
                "wrap-class": _ctx.ns.e("wrap")
              }, {
                default: withCtx(() => [
                  createVNode(_component_el_checkbox_group, {
                    modelValue: _ctx.filteredValue,
                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.filteredValue = $event),
                    class: normalizeClass(_ctx.ns.e("checkbox-group"))
                  }, {
                    default: withCtx(() => [
                      (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.filters, (filter) => {
                        return openBlock(), createBlock(_component_el_checkbox, {
                          key: filter.value,
                          label: filter.value
                        }, {
                          default: withCtx(() => [
                            createTextVNode(toDisplayString(filter.text), 1)
                          ]),
                          _: 2
                        }, 1032, ["label"]);
                      }), 128))
                    ]),
                    _: 1
                  }, 8, ["modelValue", "class"])
                ]),
                _: 1
              }, 8, ["wrap-class"])
            ], 2),
            createBaseVNode("div", {
              class: normalizeClass(_ctx.ns.e("bottom"))
            }, [
              createBaseVNode("button", {
                class: normalizeClass({ [_ctx.ns.is("disabled")]: _ctx.filteredValue.length === 0 }),
                disabled: _ctx.filteredValue.length === 0,
                type: "button",
                onClick: _cache[1] || (_cache[1] = (...args) => _ctx.handleConfirm && _ctx.handleConfirm(...args))
              }, toDisplayString(_ctx.t("el.table.confirmFilter")), 11, _hoisted_2$9),
              createBaseVNode("button", {
                type: "button",
                onClick: _cache[2] || (_cache[2] = (...args) => _ctx.handleReset && _ctx.handleReset(...args))
              }, toDisplayString(_ctx.t("el.table.resetFilter")), 1)
            ], 2)
          ])) : (openBlock(), createElementBlock("ul", {
            key: 1,
            class: normalizeClass(_ctx.ns.e("list"))
          }, [
            createBaseVNode("li", {
              class: normalizeClass([
                _ctx.ns.e("list-item"),
                {
                  [_ctx.ns.is("active")]: _ctx.filterValue === void 0 || _ctx.filterValue === null
                }
              ]),
              onClick: _cache[3] || (_cache[3] = ($event) => _ctx.handleSelect(null))
            }, toDisplayString(_ctx.t("el.table.clearFilter")), 3),
            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.filters, (filter) => {
              return openBlock(), createElementBlock("li", {
                key: filter.value,
                class: normalizeClass([_ctx.ns.e("list-item"), _ctx.ns.is("active", _ctx.isActive(filter))]),
                label: filter.value,
                onClick: ($event) => _ctx.handleSelect(filter.value)
              }, toDisplayString(filter.text), 11, _hoisted_3$3);
            }), 128))
          ], 2))
        ]),
        default: withCtx(() => [
          withDirectives((openBlock(), createElementBlock("span", {
            class: normalizeClass([
              `${_ctx.ns.namespace.value}-table__column-filter-trigger`,
              `${_ctx.ns.namespace.value}-none-outline`
            ]),
            onClick: _cache[4] || (_cache[4] = (...args) => _ctx.showFilterPanel && _ctx.showFilterPanel(...args))
          }, [
            createVNode(_component_el_icon, null, {
              default: withCtx(() => [
                _ctx.column.filterOpened ? (openBlock(), createBlock(_component_arrow_up, { key: 0 })) : (openBlock(), createBlock(_component_arrow_down, { key: 1 }))
              ]),
              _: 1
            })
          ], 2)), [
            [_directive_click_outside, _ctx.hideFilterPanel, _ctx.popperPaneRef]
          ])
        ]),
        _: 1
      }, 8, ["visible", "placement", "popper-class"]);
    }
    var FilterPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$w, [["render", _sfc_render$4], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/table/src/filter-panel.vue"]]);
    function useLayoutObserver(root2) {
      const instance = getCurrentInstance();
      onBeforeMount(() => {
        tableLayout.value.addObserver(instance);
      });
      onMounted(() => {
        onColumnsChange(tableLayout.value);
        onScrollableChange(tableLayout.value);
      });
      onUpdated(() => {
        onColumnsChange(tableLayout.value);
        onScrollableChange(tableLayout.value);
      });
      onUnmounted(() => {
        tableLayout.value.removeObserver(instance);
      });
      const tableLayout = computed(() => {
        const layout2 = root2.layout;
        if (!layout2) {
          throw new Error("Can not find table layout.");
        }
        return layout2;
      });
      const onColumnsChange = (layout2) => {
        var _a2;
        const cols = ((_a2 = root2.vnode.el) == null ? void 0 : _a2.querySelectorAll("colgroup > col")) || [];
        if (!cols.length)
          return;
        const flattenColumns = layout2.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 = (layout2) => {
        var _a2, _b;
        const cols = ((_a2 = root2.vnode.el) == null ? void 0 : _a2.querySelectorAll("colgroup > col[name=gutter]")) || [];
        for (let i = 0, j = cols.length; i < j; i++) {
          const col = cols[i];
          col.setAttribute("width", layout2.scrollY.value ? layout2.gutterWidth : "0");
        }
        const ths = ((_b = root2.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 = layout2.scrollY.value ? `${layout2.gutterWidth}px` : "0";
          th.style.display = layout2.scrollY.value ? "" : "none";
        }
      };
      return {
        tableLayout: tableLayout.value,
        onColumnsChange,
        onScrollableChange
      };
    }
    const TABLE_INJECTION_KEY = Symbol("ElTable");
    function useEvent(props, emit2) {
      const instance = getCurrentInstance();
      const parent = 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 = ref(null);
      const dragging = ref(false);
      const dragState = ref({});
      const handleMouseDown = (event, column) => {
        if (!isClient)
          return;
        if (column.children && column.children.length > 0)
          return;
        if (draggingColumn.value && props.border) {
          dragging.value = true;
          const table = parent;
          emit2("set-drag-visible", true);
          const tableEl = table == null ? void 0 : table.vnode.el;
          const tableLeft = tableEl.getBoundingClientRect().left;
          const columnEl = instance.vnode.el.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 = {};
              emit2("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) => {
        if (column.children && column.children.length > 0)
          return;
        const el = event.target;
        if (!isElement$1(el)) {
          return;
        }
        const target = el == null ? void 0 : el.closest("th");
        if (!column || !column.resizable)
          return;
        if (!dragging.value && props.border) {
          const rect = target.getBoundingClientRect();
          const bodyStyle = document.body.style;
          if (rect.width > 12 && rect.right - event.pageX < 8) {
            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 index2 = sortOrders.indexOf(order || null);
        return sortOrders[index2 > sortOrders.length - 2 ? 0 : index2 + 1];
      };
      const handleSortClick = (event, column, givenOrder) => {
        var _a2;
        event.stopPropagation();
        const order = column.order === givenOrder ? null : givenOrder || toggleOrder(column);
        const target = (_a2 = event.target) == null ? void 0 : _a2.closest("th");
        if (target) {
          if (hasClass(target, "noclick")) {
            removeClass(target, "noclick");
            return;
          }
        }
        if (!column.sortable)
          return;
        const states = props.store.states;
        let sortProp = states.sortProp.value;
        let sortOrder;
        const sortingColumn = states.sortingColumn.value;
        if (sortingColumn !== column || sortingColumn === column && sortingColumn.order === null) {
          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 = inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const getHeaderRowStyle = (rowIndex) => {
        const headerRowStyle = parent == null ? void 0 : parent.props.headerRowStyle;
        if (typeof headerRowStyle === "function") {
          return headerRowStyle.call(null, { rowIndex });
        }
        return headerRowStyle;
      };
      const getHeaderRowClass = (rowIndex) => {
        const classes = [];
        const headerRowClassName = parent == null ? void 0 : parent.props.headerRowClassName;
        if (typeof headerRowClassName === "string") {
          classes.push(headerRowClassName);
        } else if (typeof headerRowClassName === "function") {
          classes.push(headerRowClassName.call(null, { rowIndex }));
        }
        return classes.join(" ");
      };
      const getHeaderCellStyle = (rowIndex, columnIndex, row, column) => {
        var _a2;
        let headerCellStyles = (_a2 = parent == null ? void 0 : parent.props.headerCellStyle) != null ? _a2 : {};
        if (typeof headerCellStyles === "function") {
          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 (typeof headerCellClassName === "string") {
          classes.push(headerCellClassName);
        } else if (typeof headerCellClassName === "function") {
          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 = (columns2) => {
      const result = [];
      columns2.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 traverse2 = (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) => {
            traverse2(subColumn, column);
            colSpan += subColumn.colSpan;
          });
          column.colSpan = colSpan;
        } else {
          column.colSpan = 1;
        }
      };
      originColumns.forEach((column) => {
        column.level = 1;
        traverse2(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 = inject(TABLE_INJECTION_KEY);
      const columnRows = computed(() => {
        return convertToRows(props.store.states.originColumns.value);
      });
      const isGroup = 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 = /* @__PURE__ */ defineComponent({
      name: "ElTableHeader",
      components: {
        ElCheckbox
      },
      props: {
        fixed: {
          type: String,
          default: ""
        },
        store: {
          required: true,
          type: Object
        },
        border: Boolean,
        defaultSort: {
          type: Object,
          default: () => {
            return {
              prop: "",
              order: ""
            };
          }
        }
      },
      setup(props, { emit: emit2 }) {
        const instance = getCurrentInstance();
        const parent = inject(TABLE_INJECTION_KEY);
        const ns = useNamespace("table");
        const filterPanels = ref({});
        const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent);
        onMounted(async () => {
          await nextTick();
          await nextTick();
          const { prop, order } = props.defaultSort;
          parent == null ? void 0 : parent.store.commit("sort", { prop, order, init: true });
        });
        const {
          handleHeaderClick,
          handleHeaderContextMenu,
          handleMouseDown,
          handleMouseMove,
          handleMouseOut,
          handleSortClick,
          handleFilterClick
        } = useEvent(props, emit2);
        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
        };
      },
      render() {
        const {
          ns,
          isGroup,
          columnRows,
          getHeaderCellStyle,
          getHeaderCellClass,
          getHeaderRowClass,
          getHeaderRowStyle,
          handleHeaderClick,
          handleHeaderContextMenu,
          handleMouseDown,
          handleMouseMove,
          handleSortClick,
          handleMouseOut,
          store,
          $parent
        } = this;
        let rowSpan = 1;
        return h$1("thead", {
          class: { [ns.is("group")]: isGroup }
        }, columnRows.map((subColumns, rowIndex) => h$1("tr", {
          class: getHeaderRowClass(rowIndex),
          key: rowIndex,
          style: getHeaderRowStyle(rowIndex)
        }, subColumns.map((column, cellIndex) => {
          if (column.rowSpan > rowSpan) {
            rowSpan = column.rowSpan;
          }
          return h$1("th", {
            class: getHeaderCellClass(rowIndex, cellIndex, subColumns, column),
            colspan: column.colSpan,
            key: `${column.id}-thead`,
            rowspan: column.rowSpan,
            style: getHeaderCellStyle(rowIndex, cellIndex, subColumns, column),
            onClick: ($event) => handleHeaderClick($event, column),
            onContextmenu: ($event) => handleHeaderContextMenu($event, column),
            onMousedown: ($event) => handleMouseDown($event, column),
            onMousemove: ($event) => handleMouseMove($event, column),
            onMouseout: handleMouseOut
          }, [
            h$1("div", {
              class: [
                "cell",
                column.filteredValue && column.filteredValue.length > 0 ? "highlight" : ""
              ]
            }, [
              column.renderHeader ? column.renderHeader({
                column,
                $index: cellIndex,
                store,
                _self: $parent
              }) : column.label,
              column.sortable && h$1("span", {
                onClick: ($event) => handleSortClick($event, column),
                class: "caret-wrapper"
              }, [
                h$1("i", {
                  onClick: ($event) => handleSortClick($event, column, "ascending"),
                  class: "sort-caret ascending"
                }),
                h$1("i", {
                  onClick: ($event) => handleSortClick($event, column, "descending"),
                  class: "sort-caret descending"
                })
              ]),
              column.filterable && h$1(FilterPanel, {
                store,
                placement: column.filterPlacement || "bottom-start",
                column,
                upDataColumn: (key, value) => {
                  column[key] = value;
                }
              })
            ])
          ]);
        }))));
      }
    });
    function useEvents(props) {
      const parent = inject(TABLE_INJECTION_KEY);
      const tooltipContent = ref("");
      const tooltipTrigger = ref(h$1("div"));
      const { nextZIndex } = useZIndex();
      const handleEvent = (event, row, name) => {
        var _a2;
        const table = parent;
        const cell = getCell(event);
        let column;
        const namespace = (_a2 = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a2.dataset.prefix;
        if (cell) {
          column = getColumnByCell({
            columns: props.store.states.columns.value
          }, 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) => {
        props.store.commit("setCurrentRow", row);
        handleEvent(event, row, "click");
      };
      const handleContextMenu = (event, row) => {
        handleEvent(event, row, "contextmenu");
      };
      const handleMouseEnter = debounce((index2) => {
        props.store.commit("setHoverRow", index2);
      }, 30);
      const handleMouseLeave = debounce(() => {
        props.store.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 handleCellMouseEnter = (event, row, tooltipOptions) => {
        var _a2;
        const table = parent;
        const cell = getCell(event);
        const namespace = (_a2 = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a2.dataset.prefix;
        if (cell) {
          const column = getColumnByCell({
            columns: props.store.states.columns.value
          }, cell, namespace);
          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) {
          return;
        }
        const cellChild = event.target.querySelector(".cell");
        if (!(hasClass(cellChild, `${namespace}-tooltip`) && cellChild.childNodes.length)) {
          return;
        }
        const range2 = document.createRange();
        range2.setStart(cellChild, 0);
        range2.setEnd(cellChild, cellChild.childNodes.length);
        let rangeWidth = range2.getBoundingClientRect().width;
        let rangeHeight = range2.getBoundingClientRect().height;
        const offsetWidth = rangeWidth - Math.floor(rangeWidth);
        if (offsetWidth < 1e-3) {
          rangeWidth = Math.floor(rangeWidth);
        }
        const offsetHeight = rangeHeight - Math.floor(rangeHeight);
        if (offsetHeight < 1e-3) {
          rangeHeight = Math.floor(rangeHeight);
        }
        const { top, left: left2, right: right2, bottom } = getPadding(cellChild);
        const horizontalPadding = left2 + right2;
        const verticalPadding = top + bottom;
        if (rangeWidth + horizontalPadding > cellChild.offsetWidth || rangeHeight + verticalPadding > cellChild.offsetHeight || cellChild.scrollWidth > cellChild.offsetWidth) {
          createTablePopper(parent == null ? void 0 : parent.refs.tableWrapper, cell, cell.innerText || cell.textContent, nextZIndex, tooltipOptions);
        }
      };
      const handleCellMouseLeave = (event) => {
        const cell = getCell(event);
        if (!cell)
          return;
        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 = inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const getRowStyle = (row, rowIndex) => {
        const rowStyle = parent == null ? void 0 : parent.props.rowStyle;
        if (typeof rowStyle === "function") {
          return rowStyle.call(null, {
            row,
            rowIndex
          });
        }
        return rowStyle || null;
      };
      const getRowClass = (row, rowIndex) => {
        const classes = [ns.e("row")];
        if ((parent == null ? void 0 : parent.props.highlightCurrentRow) && row === props.store.states.currentRow.value) {
          classes.push("current-row");
        }
        if (props.stripe && rowIndex % 2 === 1) {
          classes.push(ns.em("row", "striped"));
        }
        const rowClassName = parent == null ? void 0 : parent.props.rowClassName;
        if (typeof rowClassName === "string") {
          classes.push(rowClassName);
        } else if (typeof rowClassName === "function") {
          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 (typeof cellStyle === "function") {
          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, offset2) => {
        const fixedClasses = getFixedColumnsClass(ns.b(), columnIndex, props == null ? void 0 : props.fixed, props.store, void 0, offset2);
        const classes = [column.id, column.align, column.className, ...fixedClasses];
        const cellClassName = parent == null ? void 0 : parent.props.cellClassName;
        if (typeof cellClassName === "string") {
          classes.push(cellClassName);
        } else if (typeof cellClassName === "function") {
          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 fn2 = parent == null ? void 0 : parent.props.spanMethod;
        if (typeof fn2 === "function") {
          const result = fn2({
            row,
            column,
            rowIndex,
            columnIndex
          });
          if (Array.isArray(result)) {
            rowspan = result[0];
            colspan = result[1];
          } else if (typeof result === "object") {
            rowspan = result.rowspan;
            colspan = result.colspan;
          }
        }
        return { rowspan, colspan };
      };
      const getColspanRealWidth = (columns2, colspan, index2) => {
        if (colspan < 1) {
          return columns2[index2].realWidth;
        }
        const widthArr = columns2.map(({ realWidth, width }) => realWidth || width).slice(index2, index2 + colspan);
        return Number(widthArr.reduce((acc, width) => Number(acc) + Number(width), -1));
      };
      return {
        getRowStyle,
        getRowClass,
        getCellStyle,
        getCellClass,
        getSpan,
        getColspanRealWidth
      };
    }
    function useRender$1(props) {
      const parent = 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);
      const firstDefaultColumnIndex = computed(() => {
        return props.store.states.columns.value.findIndex(({ type: type2 }) => type2 === "default");
      });
      const getKeyOfRow = (row, index2) => {
        const rowKey2 = parent.props.rowKey;
        if (rowKey2) {
          return getRowIdentity(row, rowKey2);
        }
        return index2;
      };
      const rowRender = (row, $index, treeRowData, expanded = false) => {
        const { tooltipEffect, tooltipOptions, store } = props;
        const { indent, columns: columns2 } = store.states;
        const rowClasses = getRowClass(row, $index);
        let display = true;
        if (treeRowData) {
          rowClasses.push(ns.em("row", `level-${treeRowData.level}`));
          display = treeRowData.display;
        }
        const displayStyle = display ? null : {
          display: "none"
        };
        return h$1("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
        }, columns2.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(columns2.value, colspan, cellIndex);
          const data = {
            store: props.store,
            _self: props.context || parent,
            column: columnData,
            row,
            $index,
            cellIndex,
            expanded
          };
          if (cellIndex === firstDefaultColumnIndex.value && treeRowData) {
            data.treeNode = {
              indent: treeRowData.level * indent.value,
              level: treeRowData.level
            };
            if (typeof treeRowData.expanded === "boolean") {
              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 = `${$index},${cellIndex}`;
          const patchKey = columnData.columnKey || columnData.rawColumnKey || "";
          const tdChildren = cellChildren(cellIndex, column, data);
          const mergedTooltipOptions = column.showOverflowTooltip && merge$1({
            effect: tooltipEffect
          }, tooltipOptions, column.showOverflowTooltip);
          return h$1("td", {
            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
          }, [tdChildren]);
        }));
      };
      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: rowKey2 } = store.states;
        const columns2 = store.states.columns.value;
        const hasExpandColumn = columns2.some(({ type: type2 }) => type2 === "expand");
        if (hasExpandColumn) {
          const expanded = isRowExpanded(row);
          const tr = rowRender(row, $index, void 0, expanded);
          const renderExpanded = parent.renderExpanded;
          if (expanded) {
            if (!renderExpanded) {
              console.error("[Element Error]renderExpanded is required.");
              return tr;
            }
            return [
              [
                tr,
                h$1("tr", {
                  key: `expanded-row__${tr.key}`
                }, [
                  h$1("td", {
                    colspan: columns2.length,
                    class: `${ns.e("cell")} ${ns.e("expanded-cell")}`
                  }, [renderExpanded({ row, $index, store, expanded })])
                ])
              ]
            ];
          } else {
            return [[tr]];
          }
        } else if (Object.keys(treeData.value).length) {
          assertRowKey();
          const key = getRowIdentity(row, rowKey2.value);
          let cur = treeData.value[key];
          let treeRowData = null;
          if (cur) {
            treeRowData = {
              expanded: cur.expanded,
              level: cur.level,
              display: true
            };
            if (typeof cur.lazy === "boolean") {
              if (typeof cur.loaded === "boolean" && cur.loaded) {
                treeRowData.noLazyChildren = !(cur.children && cur.children.length);
              }
              treeRowData.loading = cur.loading;
            }
          }
          const tmp = [rowRender(row, $index, treeRowData)];
          if (cur) {
            let i = 0;
            const traverse2 = (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, rowKey2.value);
                if (childKey === void 0 || childKey === null) {
                  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 (typeof cur.lazy === "boolean") {
                    if (typeof cur.loaded === "boolean" && 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];
                  traverse2(nodes2, cur);
                }
              });
            };
            cur.display = true;
            const nodes = lazyTreeNodeMap.value[key] || row[childrenColumnName.value];
            traverse2(nodes, cur);
          }
          return tmp;
        } else {
          return rowRender(row, $index, void 0);
        }
      };
      return {
        wrappedRowRender,
        tooltipContent,
        tooltipTrigger
      };
    }
    const defaultProps$2 = {
      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 TableBody = /* @__PURE__ */ defineComponent({
      name: "ElTableBody",
      props: defaultProps$2,
      setup(props) {
        const instance = getCurrentInstance();
        const parent = inject(TABLE_INJECTION_KEY);
        const ns = useNamespace("table");
        const { wrappedRowRender, tooltipContent, tooltipTrigger } = useRender$1(props);
        const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent);
        watch(props.store.states.hoverRow, (newVal, oldVal) => {
          if (!props.store.states.isComplex.value || !isClient)
            return;
          rAF(() => {
            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")}`));
            const oldRow = rows[oldVal];
            const newRow = rows[newVal];
            if (oldRow) {
              removeClass(oldRow, "hover-row");
            }
            if (newRow) {
              addClass(newRow, "hover-row");
            }
          });
        });
        onUnmounted(() => {
          var _a2;
          (_a2 = removePopper) == null ? void 0 : _a2();
        });
        return {
          ns,
          onColumnsChange,
          onScrollableChange,
          wrappedRowRender,
          tooltipContent,
          tooltipTrigger
        };
      },
      render() {
        const { wrappedRowRender, store } = this;
        const data = store.states.data.value || [];
        return h$1("tbody", { tabIndex: -1 }, [
          data.reduce((acc, row) => {
            return acc.concat(wrappedRowRender(row, acc.length));
          }, [])
        ]);
      }
    });
    function useMapState() {
      const table = inject(TABLE_INJECTION_KEY);
      const store = table == null ? void 0 : table.store;
      const leftFixedLeafCount = computed(() => {
        return store.states.fixedLeafColumnsLength.value;
      });
      const rightFixedLeafCount = computed(() => {
        return store.states.rightFixedColumns.value.length;
      });
      const columnsCount = computed(() => {
        return store.states.columns.value.length;
      });
      const leftFixedCount = computed(() => {
        return store.states.fixedColumns.value.length;
      });
      const rightFixedCount = computed(() => {
        return store.states.rightFixedColumns.value.length;
      });
      return {
        leftFixedLeafCount,
        rightFixedLeafCount,
        columnsCount,
        leftFixedCount,
        rightFixedCount,
        columns: store.states.columns
      };
    }
    function useStyle$1(props) {
      const { columns: columns2 } = useMapState();
      const ns = useNamespace("table");
      const getCellClasses = (columns22, cellIndex) => {
        const column = columns22[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: columns2
      };
    }
    var TableFooter = /* @__PURE__ */ 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 { getCellClasses, getCellStyles, columns: columns2 } = useStyle$1(props);
        const ns = useNamespace("table");
        return {
          ns,
          getCellClasses,
          getCellStyles,
          columns: columns2
        };
      },
      render() {
        const { columns: columns2, getCellStyles, getCellClasses, summaryMethod, sumText } = this;
        const data = this.store.states.data.value;
        let sums = [];
        if (summaryMethod) {
          sums = summaryMethod({
            columns: columns2,
            data
          });
        } else {
          columns2.forEach((column, index2) => {
            if (index2 === 0) {
              sums[index2] = 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[index2] = 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[index2] = "";
            }
          });
        }
        return h$1(h$1("tfoot", [
          h$1("tr", {}, [
            ...columns2.map((column, cellIndex) => h$1("td", {
              key: cellIndex,
              colspan: column.colSpan,
              rowspan: column.rowSpan,
              class: getCellClasses(columns2, cellIndex),
              style: getCellStyles(column, cellIndex)
            }, [
              h$1("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) => {
        store.toggleRowSelection(row, selected, false);
        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 });
      };
      return {
        setCurrentRow,
        getSelectionRows,
        toggleRowSelection,
        clearSelection,
        clearFilter,
        toggleAllSelection,
        toggleRowExpansion,
        clearSort,
        sort
      };
    }
    function useStyle(props, layout2, store, table) {
      const isHidden2 = ref(false);
      const renderExpanded = ref(null);
      const resizeProxyVisible = ref(false);
      const setDragVisible = (visible) => {
        resizeProxyVisible.value = visible;
      };
      const resizeState = ref({
        width: null,
        height: null,
        headerHeight: null
      });
      const isGroup = ref(false);
      const scrollbarViewStyle = {
        display: "inline-block",
        verticalAlign: "middle"
      };
      const tableWidth = ref();
      const tableScrollHeight = ref(0);
      const bodyScrollHeight = ref(0);
      const headerScrollHeight = ref(0);
      const footerScrollHeight = ref(0);
      const appendScrollHeight = ref(0);
      watchEffect(() => {
        layout2.setHeight(props.height);
      });
      watchEffect(() => {
        layout2.setMaxHeight(props.maxHeight);
      });
      watch(() => [props.currentRowKey, store.states.rowKey], ([currentRowKey, rowKey2]) => {
        if (!unref(rowKey2) || !unref(currentRowKey))
          return;
        store.setCurrentRowKey(`${currentRowKey}`);
      }, {
        immediate: true
      });
      watch(() => props.data, (data) => {
        table.store.commit("setData", data);
      }, {
        immediate: true,
        deep: true
      });
      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 = computed(() => {
        return props.height || props.maxHeight || store.states.fixedColumns.value.length > 0 || store.states.rightFixedColumns.value.length > 0;
      });
      const tableBodyStyles = computed(() => {
        return {
          width: layout2.bodyWidth.value ? `${layout2.bodyWidth.value}px` : ""
        };
      });
      const doLayout = () => {
        if (shouldUpdateHeight.value) {
          layout2.updateElsHeight();
        }
        layout2.updateColumnsWidth();
        requestAnimationFrame(syncPosition);
      };
      onMounted(async () => {
        await 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(layout2.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 (!layout2.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 _a2, _b;
          resizeListener();
          (_b = (_a2 = table.refs) == null ? void 0 : _a2.scrollBarRef) == null ? void 0 : _b.update();
        });
      };
      const resizeListener = () => {
        var _a2, _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 : (_a2 = table.refs.tableHeaderRef) == null ? void 0 : _a2.$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 = computed(() => {
        const { bodyWidth: bodyWidth_, scrollY, gutterWidth } = layout2;
        return bodyWidth_.value ? `${bodyWidth_.value - (scrollY.value ? gutterWidth : 0)}px` : "";
      });
      const tableLayout = computed(() => {
        if (props.maxHeight)
          return "fixed";
        return props.tableLayout;
      });
      const emptyBlockStyle = computed(() => {
        if (props.data && props.data.length)
          return null;
        let height = "100%";
        if (props.height && bodyScrollHeight.value) {
          height = `${bodyScrollHeight.value}px`;
        }
        const width = tableWidth.value;
        return {
          width: width ? `${width}px` : "",
          height
        };
      });
      const tableInnerStyle = computed(() => {
        if (props.height) {
          return {
            height: !Number.isNaN(Number(props.height)) ? `${props.height}px` : props.height
          };
        }
        if (props.maxHeight) {
          return {
            maxHeight: !Number.isNaN(Number(props.maxHeight)) ? `${props.maxHeight}px` : props.maxHeight
          };
        }
        return {};
      });
      const scrollbarStyle = 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 {};
      });
      const handleFixedMousewheel = (event, data) => {
        const bodyWrapper = table.refs.bodyWrapper;
        if (Math.abs(data.spinY) > 0) {
          const currentScrollTop = bodyWrapper.scrollTop;
          if (data.pixelY < 0 && currentScrollTop !== 0) {
            event.preventDefault();
          }
          if (data.pixelY > 0 && bodyWrapper.scrollHeight - bodyWrapper.clientHeight > currentScrollTop) {
            event.preventDefault();
          }
          bodyWrapper.scrollTop += Math.ceil(data.pixelY / 5);
        } else {
          bodyWrapper.scrollLeft += Math.ceil(data.pixelX / 5);
        }
      };
      return {
        isHidden: isHidden2,
        renderExpanded,
        setDragVisible,
        isGroup,
        handleMouseLeave,
        handleHeaderFooterMousewheel,
        tableSize,
        emptyBlockStyle,
        handleFixedMousewheel,
        resizeProxyVisible,
        bodyWidth,
        resizeState,
        doLayout,
        tableBodyStyles,
        tableLayout,
        scrollbarViewStyle,
        tableInnerStyle,
        scrollbarStyle
      };
    }
    function useKeyRender(table) {
      const observer = 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((fn2) => fn2());
        });
        observer.value.observe(columnsWrapper, config);
      };
      onMounted(() => {
        initWatchDom();
      });
      onUnmounted(() => {
        var _a2;
        (_a2 = observer.value) == null ? void 0 : _a2.disconnect();
      });
    }
    var defaultProps$1 = {
      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"
          };
        }
      },
      lazy: Boolean,
      load: Function,
      style: {
        type: Object,
        default: () => ({})
      },
      className: {
        type: String,
        default: ""
      },
      tableLayout: {
        type: String,
        default: "fixed"
      },
      scrollbarAlwaysOn: {
        type: Boolean,
        default: false
      },
      flexible: Boolean,
      showOverflowTooltip: [Boolean, Object]
    };
    function hColgroup(props) {
      const isAuto = props.tableLayout === "auto";
      let columns2 = props.columns || [];
      if (isAuto) {
        if (columns2.every((column) => column.width === void 0)) {
          columns2 = [];
        }
      }
      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 h$1("colgroup", {}, columns2.map((column) => h$1("col", getPropsData(column))));
    }
    hColgroup.props = ["columns", "tableLayout"];
    const useScrollbar$1 = () => {
      const scrollBarRef = ref();
      const scrollTo = (options, yCoord) => {
        const scrollbar = scrollBarRef.value;
        if (scrollbar) {
          scrollbar.scrollTo(options, yCoord);
        }
      };
      const setScrollPosition = (position, offset2) => {
        const scrollbar = scrollBarRef.value;
        if (scrollbar && isNumber(offset2) && ["Top", "Left"].includes(position)) {
          scrollbar[`setScroll${position}`](offset2);
        }
      };
      const setScrollTop = (top) => setScrollPosition("Top", top);
      const setScrollLeft = (left2) => setScrollPosition("Left", left2);
      return {
        scrollBarRef,
        scrollTo,
        setScrollTop,
        setScrollLeft
      };
    };
    let tableIdSeed = 1;
    const _sfc_main$v = /* @__PURE__ */ defineComponent({
      name: "ElTable",
      directives: {
        Mousewheel
      },
      components: {
        TableHeader,
        TableBody,
        TableFooter,
        ElScrollbar,
        hColgroup
      },
      props: defaultProps$1,
      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"
      ],
      setup(props) {
        const { t } = useLocale();
        const ns = useNamespace("table");
        const table = getCurrentInstance();
        provide(TABLE_INJECTION_KEY, table);
        const store = createStore(table, props);
        table.store = store;
        const layout2 = new TableLayout({
          store: table.store,
          table,
          fit: props.fit,
          showHeader: props.showHeader
        });
        table.layout = layout2;
        const isEmpty2 = computed(() => (store.states.data.value || []).length === 0);
        const {
          setCurrentRow,
          getSelectionRows,
          toggleRowSelection,
          clearSelection,
          clearFilter,
          toggleAllSelection,
          toggleRowExpansion,
          clearSort,
          sort
        } = useUtils(store);
        const {
          isHidden: isHidden2,
          renderExpanded,
          setDragVisible,
          isGroup,
          handleMouseLeave,
          handleHeaderFooterMousewheel,
          tableSize,
          emptyBlockStyle,
          handleFixedMousewheel,
          resizeProxyVisible,
          bodyWidth,
          resizeState,
          doLayout,
          tableBodyStyles,
          tableLayout,
          scrollbarViewStyle,
          tableInnerStyle,
          scrollbarStyle
        } = useStyle(props, layout2, 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 = computed(() => props.sumText || t("el.table.sumText"));
        const computedEmptyText = computed(() => {
          return props.emptyText || t("el.table.emptyText");
        });
        useKeyRender(table);
        return {
          ns,
          layout: layout2,
          store,
          handleHeaderFooterMousewheel,
          handleMouseLeave,
          tableId,
          tableSize,
          isHidden: isHidden2,
          isEmpty: isEmpty2,
          renderExpanded,
          resizeProxyVisible,
          resizeState,
          isGroup,
          bodyWidth,
          tableBodyStyles,
          emptyBlockStyle,
          debouncedUpdateLayout,
          handleFixedMousewheel,
          setCurrentRow,
          getSelectionRows,
          toggleRowSelection,
          clearSelection,
          clearFilter,
          toggleAllSelection,
          toggleRowExpansion,
          clearSort,
          doLayout,
          sort,
          t,
          setDragVisible,
          context: table,
          computedSumText,
          computedEmptyText,
          tableLayout,
          scrollbarViewStyle,
          tableInnerStyle,
          scrollbarStyle,
          scrollBarRef,
          scrollTo,
          setScrollLeft,
          setScrollTop
        };
      }
    });
    const _hoisted_1$d = ["data-prefix"];
    const _hoisted_2$8 = {
      ref: "hiddenColumns",
      class: "hidden-columns"
    };
    function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_hColgroup = resolveComponent("hColgroup");
      const _component_table_header = resolveComponent("table-header");
      const _component_table_body = resolveComponent("table-body");
      const _component_table_footer = resolveComponent("table-footer");
      const _component_el_scrollbar = resolveComponent("el-scrollbar");
      const _directive_mousewheel = resolveDirective("mousewheel");
      return openBlock(), createElementBlock("div", {
        ref: "tableWrapper",
        class: 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: normalizeStyle(_ctx.style),
        "data-prefix": _ctx.ns.namespace.value,
        onMouseleave: _cache[0] || (_cache[0] = (...args) => _ctx.handleMouseLeave && _ctx.handleMouseLeave(...args))
      }, [
        createBaseVNode("div", {
          class: normalizeClass(_ctx.ns.e("inner-wrapper")),
          style: normalizeStyle(_ctx.tableInnerStyle)
        }, [
          createBaseVNode("div", _hoisted_2$8, [
            renderSlot(_ctx.$slots, "default")
          ], 512),
          _ctx.showHeader && _ctx.tableLayout === "fixed" ? withDirectives((openBlock(), createElementBlock("div", {
            key: 0,
            ref: "headerWrapper",
            class: normalizeClass(_ctx.ns.e("header-wrapper"))
          }, [
            createBaseVNode("table", {
              ref: "tableHeader",
              class: normalizeClass(_ctx.ns.e("header")),
              style: normalizeStyle(_ctx.tableBodyStyles),
              border: "0",
              cellpadding: "0",
              cellspacing: "0"
            }, [
              createVNode(_component_hColgroup, {
                columns: _ctx.store.states.columns.value,
                "table-layout": _ctx.tableLayout
              }, null, 8, ["columns", "table-layout"]),
              createVNode(_component_table_header, {
                ref: "tableHeaderRef",
                border: _ctx.border,
                "default-sort": _ctx.defaultSort,
                store: _ctx.store,
                onSetDragVisible: _ctx.setDragVisible
              }, null, 8, ["border", "default-sort", "store", "onSetDragVisible"])
            ], 6)
          ], 2)), [
            [_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
          ]) : createCommentVNode("v-if", true),
          createBaseVNode("div", {
            ref: "bodyWrapper",
            class: normalizeClass(_ctx.ns.e("body-wrapper"))
          }, [
            createVNode(_component_el_scrollbar, {
              ref: "scrollBarRef",
              "view-style": _ctx.scrollbarViewStyle,
              "wrap-style": _ctx.scrollbarStyle,
              always: _ctx.scrollbarAlwaysOn
            }, {
              default: withCtx(() => [
                createBaseVNode("table", {
                  ref: "tableBody",
                  class: normalizeClass(_ctx.ns.e("body")),
                  cellspacing: "0",
                  cellpadding: "0",
                  border: "0",
                  style: normalizeStyle({
                    width: _ctx.bodyWidth,
                    tableLayout: _ctx.tableLayout
                  })
                }, [
                  createVNode(_component_hColgroup, {
                    columns: _ctx.store.states.columns.value,
                    "table-layout": _ctx.tableLayout
                  }, null, 8, ["columns", "table-layout"]),
                  _ctx.showHeader && _ctx.tableLayout === "auto" ? (openBlock(), createBlock(_component_table_header, {
                    key: 0,
                    ref: "tableHeaderRef",
                    class: normalizeClass(_ctx.ns.e("body-header")),
                    border: _ctx.border,
                    "default-sort": _ctx.defaultSort,
                    store: _ctx.store,
                    onSetDragVisible: _ctx.setDragVisible
                  }, null, 8, ["class", "border", "default-sort", "store", "onSetDragVisible"])) : createCommentVNode("v-if", true),
                  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" ? (openBlock(), createBlock(_component_table_footer, {
                    key: 1,
                    class: 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"])) : createCommentVNode("v-if", true)
                ], 6),
                _ctx.isEmpty ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  ref: "emptyBlock",
                  style: normalizeStyle(_ctx.emptyBlockStyle),
                  class: normalizeClass(_ctx.ns.e("empty-block"))
                }, [
                  createBaseVNode("span", {
                    class: normalizeClass(_ctx.ns.e("empty-text"))
                  }, [
                    renderSlot(_ctx.$slots, "empty", {}, () => [
                      createTextVNode(toDisplayString(_ctx.computedEmptyText), 1)
                    ])
                  ], 2)
                ], 6)) : createCommentVNode("v-if", true),
                _ctx.$slots.append ? (openBlock(), createElementBlock("div", {
                  key: 1,
                  ref: "appendWrapper",
                  class: normalizeClass(_ctx.ns.e("append-wrapper"))
                }, [
                  renderSlot(_ctx.$slots, "append")
                ], 2)) : createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["view-style", "wrap-style", "always"])
          ], 2),
          _ctx.showSummary && _ctx.tableLayout === "fixed" ? withDirectives((openBlock(), createElementBlock("div", {
            key: 1,
            ref: "footerWrapper",
            class: normalizeClass(_ctx.ns.e("footer-wrapper"))
          }, [
            createBaseVNode("table", {
              class: normalizeClass(_ctx.ns.e("footer")),
              cellspacing: "0",
              cellpadding: "0",
              border: "0",
              style: normalizeStyle(_ctx.tableBodyStyles)
            }, [
              createVNode(_component_hColgroup, {
                columns: _ctx.store.states.columns.value,
                "table-layout": _ctx.tableLayout
              }, null, 8, ["columns", "table-layout"]),
              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)), [
            [vShow, !_ctx.isEmpty],
            [_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
          ]) : createCommentVNode("v-if", true),
          _ctx.border || _ctx.isGroup ? (openBlock(), createElementBlock("div", {
            key: 2,
            class: normalizeClass(_ctx.ns.e("border-left-patch"))
          }, null, 2)) : createCommentVNode("v-if", true)
        ], 6),
        withDirectives(createBaseVNode("div", {
          ref: "resizeProxy",
          class: normalizeClass(_ctx.ns.e("column-resize-proxy"))
        }, null, 2), [
          [vShow, _ctx.resizeProxyVisible]
        ])
      ], 46, _hoisted_1$d);
    }
    var Table = /* @__PURE__ */ _export_sfc$1(_sfc_main$v, [["render", _sfc_render$3], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/table/src/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 = (type2) => {
      return defaultClassNames[type2] || "";
    };
    const cellForced = {
      selection: {
        renderHeader({ store, column }) {
          function isDisabled() {
            return store.states.data.value && store.states.data.value.length === 0;
          }
          return h$1(ElCheckbox, {
            disabled: isDisabled(),
            size: store.states.tableSize.value,
            indeterminate: store.states.selection.value.length > 0 && !store.states.isAllSelected.value,
            "onUpdate:modelValue": store.toggleAllSelection,
            modelValue: store.states.isAllSelected.value,
            ariaLabel: column.label
          });
        },
        renderCell({
          row,
          column,
          store,
          $index
        }) {
          return h$1(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 index2 = column.index;
          if (typeof index2 === "number") {
            i = $index + index2;
          } else if (typeof index2 === "function") {
            i = index2($index);
          }
          return h$1("div", {}, [i]);
        },
        sortable: false
      },
      expand: {
        renderHeader({ column }) {
          return column.label || "";
        },
        renderCell({
          row,
          store,
          expanded
        }) {
          const { ns } = store;
          const classes = [ns.e("expand-icon")];
          if (expanded) {
            classes.push(ns.em("expand-icon", "expanded"));
          }
          const callback = function(e) {
            e.stopPropagation();
            store.toggleRowExpansion(row);
          };
          return h$1("div", {
            class: classes,
            onClick: callback
          }, {
            default: () => {
              return [
                h$1(ElIcon, null, {
                  default: () => {
                    return [h$1(arrow_right_default)];
                  }
                })
              ];
            }
          });
        },
        sortable: false,
        resizable: false
      }
    };
    function defaultRenderCell({
      row,
      column,
      $index
    }) {
      var _a2;
      const property2 = column.property;
      const value = property2 && getProp(row, property2).value;
      if (column && column.formatter) {
        return column.formatter(row, column, value, $index);
      }
      return ((_a2 = value == null ? void 0 : value.toString) == null ? void 0 : _a2.call(value)) || "";
    }
    function treeCellPrefix({
      row,
      treeNode,
      store
    }, createPlaceholder = false) {
      const { ns } = store;
      if (!treeNode) {
        if (createPlaceholder) {
          return [
            h$1("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(h$1("span", {
          class: ns.e("indent"),
          style: { "padding-left": `${treeNode.indent}px` }
        }));
      }
      if (typeof treeNode.expanded === "boolean" && !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(h$1("div", {
          class: expandClasses,
          onClick: callback
        }, {
          default: () => {
            return [
              h$1(ElIcon, { class: { [ns.is("loading")]: treeNode.loading } }, {
                default: () => [h$1(icon)]
              })
            ];
          }
        }));
      } else {
        ele.push(h$1("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 = 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)) {
            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",
          "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)) {
            watch(() => props_[columnKey], (newVal) => {
              instance.columnConfig.value[key] = newVal;
            });
          }
        });
      };
      return {
        registerComplexWatchers,
        registerNormalWatchers
      };
    }
    function useRender(props, slots, owner) {
      const instance = getCurrentInstance();
      const columnId = ref("");
      const isSubColumn = ref(false);
      const realAlign = ref();
      const realHeaderAlign = ref();
      const ns = useNamespace("table");
      watchEffect(() => {
        realAlign.value = props.align ? `is-${props.align}` : null;
        realAlign.value;
      });
      watchEffect(() => {
        realHeaderAlign.value = props.headerAlign ? `is-${props.headerAlign}` : realAlign.value;
        realHeaderAlign.value;
      });
      const columnOrTableParent = computed(() => {
        let parent = instance.vnode.vParent || instance.parent;
        while (parent && !parent.tableId && !parent.columnId) {
          parent = parent.vnode.vParent || parent.parent;
        }
        return parent;
      });
      const hasTreeColumn = 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 = ref(parseWidth(props.width));
      const realMinWidth = 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(column.width === void 0 ? column.minWidth : column.width);
        return column;
      };
      const setColumnForcedProps = (column) => {
        const type2 = column.type;
        const source = cellForced[type2] || {};
        Object.keys(source).forEach((prop) => {
          const value = source[prop];
          if (prop !== "className" && value !== void 0) {
            column[prop] = value;
          }
        });
        const className = getDefaultClassName(type2);
        if (className) {
          const forceClass = `${unref(ns.namespace)}-${className}`;
          column.className = column.className ? `${column.className} ${forceClass}` : forceClass;
        }
        return column;
      };
      const checkSubColumn = (children) => {
        if (Array.isArray(children)) {
          children.forEach((child) => check(child));
        } else {
          check(children);
        }
        function check(item) {
          var _a2;
          if (((_a2 = item == null ? void 0 : item.type) == null ? void 0 : _a2.name) === "ElTableColumn") {
            item.vParent = instance;
          }
        }
      };
      const setColumnRenders = (column) => {
        if (props.renderHeader)
          ;
        else if (column.type !== "selection") {
          column.renderHeader = (scope) => {
            instance.columnConfig.value["label"];
            const renderHeader = slots.header;
            return renderHeader ? renderHeader(scope) : column.label;
          };
        }
        let originRenderCell = column.renderCell;
        if (column.type === "expand") {
          column.renderCell = (data) => h$1("div", {
            class: "cell"
          }, [originRenderCell(data)]);
          owner.value.renderExpanded = (data) => {
            return slots.default ? slots.default(data) : slots.default;
          };
        } else {
          originRenderCell = originRenderCell || defaultRenderCell;
          column.renderCell = (data) => {
            let children = null;
            if (slots.default) {
              const vnodes = slots.default(data);
              children = vnodes.some((v2) => v2.type !== Comment) ? vnodes : originRenderCell(data);
            } else {
              children = originRenderCell(data);
            }
            const { columns: columns2 } = owner.value.store.states;
            const firstUserColumnIndex = columns2.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} ${unref(ns.namespace)}-tooltip`;
              props2.style = {
                width: `${(data.column.realWidth || Number(data.column.width)) - 1}px`
              };
            }
            checkSubColumn(children);
            return h$1("div", props2, [prefix, children]);
          };
        }
        return column;
      };
      const getPropsData = (...propsKey) => {
        return propsKey.reduce((prev, cur) => {
          if (Array.isArray(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 = {
      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
      },
      fixed: [Boolean, String],
      formatter: Function,
      selectable: Function,
      reserveSelection: Boolean,
      filterMethod: Function,
      filteredValue: Array,
      filters: Array,
      filterPlacement: String,
      filterMultiple: {
        type: Boolean,
        default: true
      },
      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 = /* @__PURE__ */ defineComponent({
      name: "ElTableColumn",
      components: {
        ElCheckbox
      },
      props: defaultProps,
      setup(props, { slots }) {
        const instance = getCurrentInstance();
        const columnConfig = ref({});
        const owner = 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 = `${parent.tableId || parent.columnId}_column_${columnIdSeed++}`;
        onBeforeMount(() => {
          isSubColumn.value = owner.value !== parent;
          const type2 = props.type || "default";
          const sortable = props.sortable === "" ? true : props.sortable;
          const showOverflowTooltip = isUndefined(props.showOverflowTooltip) ? parent.props.showOverflowTooltip : props.showOverflowTooltip;
          const defaults = {
            ...cellStarts[type2],
            id: columnId.value,
            type: type2,
            property: props.prop || props.property,
            align: realAlign,
            headerAlign: realHeaderAlign,
            showOverflowTooltip,
            filterable: props.filters || props.filterMethod,
            filteredValue: [],
            filterPlacement: "",
            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"
          ];
          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();
        });
        onMounted(() => {
          var _a2;
          const parent2 = columnOrTableParent.value;
          const children = isSubColumn.value ? parent2.vnode.el.children : (_a2 = parent2.refs.hiddenColumns) == null ? void 0 : _a2.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 ? parent2.columnConfig.value : null, updateColumnOrder);
        });
        onBeforeUnmount(() => {
          owner.value.store.commit("removeColumn", columnConfig.value, isSubColumn.value ? parent.columnConfig.value : null, updateColumnOrder);
        });
        instance.columnId = columnId.value;
        instance.columnConfig = columnConfig;
        return;
      },
      render() {
        var _a2, _b, _c;
        try {
          const renderDefault = (_b = (_a2 = this.$slots).default) == null ? void 0 : _b.call(_a2, {
            row: {},
            column: {},
            $index: -1
          });
          const children = [];
          if (Array.isArray(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 === Fragment && Array.isArray(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 = h$1("div", children);
          return vnode;
        } catch (e) {
          return h$1("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["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 */
      ]: "asc"
      /* ASC */
    };
    const placeholderSign = Symbol("placeholder");
    const calcColumnStyle = (column, fixedColumn, fixed) => {
      var _a2;
      const flex = {
        flexGrow: 0,
        flexShrink: 0,
        ...fixed ? {} : {
          flexGrow: column.flexGrow || 0,
          flexShrink: column.flexShrink || 1
        }
      };
      if (!fixed) {
        flex.flexShrink = 1;
      }
      const style = {
        ...(_a2 = column.style) != null ? _a2 : {},
        ...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, columns2, fixed) {
      const visibleColumns = computed(() => {
        return unref(columns2).filter((column) => !column.hidden);
      });
      const fixedColumnsOnLeft = computed(() => unref(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
      const fixedColumnsOnRight = computed(() => unref(visibleColumns).filter((column) => column.fixed === "right"));
      const normalColumns = computed(() => unref(visibleColumns).filter((column) => !column.fixed));
      const mainColumns = computed(() => {
        const ret = [];
        unref(fixedColumnsOnLeft).forEach((column) => {
          ret.push({
            ...column,
            placeholderSign
          });
        });
        unref(normalColumns).forEach((column) => {
          ret.push(column);
        });
        unref(fixedColumnsOnRight).forEach((column) => {
          ret.push({
            ...column,
            placeholderSign
          });
        });
        return ret;
      });
      const hasFixedColumns = computed(() => {
        return unref(fixedColumnsOnLeft).length || unref(fixedColumnsOnRight).length;
      });
      const columnsStyles = computed(() => {
        const _columns = unref(columns2);
        return _columns.reduce((style, column) => {
          style[column.key] = calcColumnStyle(column, unref(fixed), props.fixed);
          return style;
        }, {});
      });
      const columnsTotalWidth = computed(() => {
        return unref(visibleColumns).reduce((width, column) => width + column.width, 0);
      });
      const getColumn = (key) => {
        return unref(columns2).find((column) => column.key === key);
      };
      const getColumnStyle = (key) => {
        return unref(columnsStyles)[key];
      };
      const updateColumnWidth = (column, width) => {
        column.width = width;
      };
      function onColumnSorted(e) {
        var _a2;
        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];
        }
        (_a2 = props.onColumnSort) == null ? void 0 : _a2.call(props, { column: getColumn(key), key, order });
      }
      return {
        columns: columns2,
        columnsStyles,
        columnsTotalWidth,
        fixedColumnsOnLeft,
        fixedColumnsOnRight,
        hasFixedColumns,
        mainColumns,
        normalColumns,
        visibleColumns,
        getColumn,
        getColumnStyle,
        updateColumnWidth,
        onColumnSorted
      };
    }
    const useScrollbar = (props, {
      mainTableRef,
      leftTableRef,
      rightTableRef,
      onMaybeEndReached
    }) => {
      const scrollPos = ref({ scrollLeft: 0, scrollTop: 0 });
      function doScroll(params) {
        var _a2, _b, _c;
        const { scrollTop } = params;
        (_a2 = mainTableRef.value) == null ? void 0 : _a2.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(unref(scrollPos));
      }
      function scrollToLeft(scrollLeft) {
        var _a2, _b;
        scrollPos.value.scrollLeft = scrollLeft;
        (_b = (_a2 = mainTableRef.value) == null ? void 0 : _a2.scrollTo) == null ? void 0 : _b.call(_a2, unref(scrollPos));
      }
      function onScroll(params) {
        var _a2;
        scrollTo(params);
        (_a2 = props.onScroll) == null ? void 0 : _a2.call(props, params);
      }
      function onVerticalScroll({ scrollTop }) {
        const { scrollTop: currentScrollTop } = unref(scrollPos);
        if (scrollTop !== currentScrollTop)
          scrollToTop(scrollTop);
      }
      function scrollToRow(row, strategy = "auto") {
        var _a2;
        (_a2 = mainTableRef.value) == null ? void 0 : _a2.scrollToRow(row, strategy);
      }
      watch(() => unref(scrollPos).scrollTop, (cur, prev) => {
        if (cur > prev)
          onMaybeEndReached();
      });
      return {
        scrollPos,
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow,
        onScroll,
        onVerticalScroll
      };
    };
    const useRow = (props, { mainTableRef, leftTableRef, rightTableRef }) => {
      const vm = getCurrentInstance();
      const { emit: emit2 } = vm;
      const isResetting = shallowRef(false);
      const hoveringRowKey = shallowRef(null);
      const expandedRowKeys = ref(props.defaultExpandedRowKeys || []);
      const lastRenderedRowIndex = ref(-1);
      const resetIndex = shallowRef(null);
      const rowHeights = ref({});
      const pendingRowHeights = ref({});
      const leftTableHeights = shallowRef({});
      const mainTableHeights = shallowRef({});
      const rightTableHeights = shallowRef({});
      const isDynamic = computed(() => isNumber(props.estimatedRowHeight));
      function onRowsRendered(params) {
        var _a2;
        (_a2 = props.onRowsRendered) == null ? void 0 : _a2.call(props, params);
        if (params.rowCacheEnd > unref(lastRenderedRowIndex)) {
          lastRenderedRowIndex.value = params.rowCacheEnd;
        }
      }
      function onRowHovered({ hovered, rowKey: rowKey2 }) {
        hoveringRowKey.value = hovered ? rowKey2 : null;
      }
      function onRowExpanded({
        expanded,
        rowData,
        rowIndex,
        rowKey: rowKey2
      }) {
        var _a2, _b;
        const _expandedRowKeys = [...unref(expandedRowKeys)];
        const currentKeyIndex = _expandedRowKeys.indexOf(rowKey2);
        if (expanded) {
          if (currentKeyIndex === -1)
            _expandedRowKeys.push(rowKey2);
        } else {
          if (currentKeyIndex > -1)
            _expandedRowKeys.splice(currentKeyIndex, 1);
        }
        expandedRowKeys.value = _expandedRowKeys;
        emit2("update:expandedRowKeys", _expandedRowKeys);
        (_a2 = props.onRowExpand) == null ? void 0 : _a2.call(props, {
          expanded,
          rowData,
          rowIndex,
          rowKey: rowKey2
        });
        (_b = props.onExpandedRowsChange) == null ? void 0 : _b.call(props, _expandedRowKeys);
      }
      const flushingRowHeights = debounce(() => {
        var _a2, _b, _c, _d;
        isResetting.value = true;
        rowHeights.value = { ...unref(rowHeights), ...unref(pendingRowHeights) };
        resetAfterIndex(unref(resetIndex), false);
        pendingRowHeights.value = {};
        resetIndex.value = null;
        (_a2 = mainTableRef.value) == null ? void 0 : _a2.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(index2, forceUpdate = false) {
        if (!unref(isDynamic))
          return;
        [mainTableRef, leftTableRef, rightTableRef].forEach((tableRef) => {
          const table = unref(tableRef);
          if (table)
            table.resetAfterRowIndex(index2, forceUpdate);
        });
      }
      function resetHeights(rowKey2, height, rowIdx) {
        const resetIdx = unref(resetIndex);
        if (resetIdx === null) {
          resetIndex.value = rowIdx;
        } else {
          if (resetIdx > rowIdx) {
            resetIndex.value = rowIdx;
          }
        }
        pendingRowHeights.value[rowKey2] = height;
      }
      function onRowHeightChange({ rowKey: rowKey2, height, rowIndex }, fixedDir) {
        if (!fixedDir) {
          mainTableHeights.value[rowKey2] = height;
        } else {
          if (fixedDir === FixedDir.RIGHT) {
            rightTableHeights.value[rowKey2] = height;
          } else {
            leftTableHeights.value[rowKey2] = height;
          }
        }
        const maximumHeight = Math.max(...[leftTableHeights, rightTableHeights, mainTableHeights].map((records) => records.value[rowKey2] || 0));
        if (unref(rowHeights)[rowKey2] !== maximumHeight) {
          resetHeights(rowKey2, maximumHeight, rowIndex);
          flushingRowHeights();
        }
      }
      return {
        hoveringRowKey,
        expandedRowKeys,
        lastRenderedRowIndex,
        isDynamic,
        isResetting,
        rowHeights,
        resetAfterIndex,
        onRowExpanded,
        onRowHovered,
        onRowsRendered,
        onRowHeightChange
      };
    };
    const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
      const depthMap = ref({});
      const flattenedData = computed(() => {
        const depths = {};
        const { data: data2, rowKey: rowKey2 } = props;
        const _expandedRowKeys = unref(expandedRowKeys);
        if (!_expandedRowKeys || !_expandedRowKeys.length)
          return data2;
        const array2 = [];
        const keysSet = /* @__PURE__ */ new Set();
        _expandedRowKeys.forEach((x2) => keysSet.add(x2));
        let copy = data2.slice();
        copy.forEach((x2) => depths[x2[rowKey2]] = 0);
        while (copy.length > 0) {
          const item = copy.shift();
          array2.push(item);
          if (keysSet.has(item[rowKey2]) && Array.isArray(item.children) && item.children.length > 0) {
            copy = [...item.children, ...copy];
            item.children.forEach((child) => depths[child[rowKey2]] = depths[item[rowKey2]] + 1);
          }
        }
        depthMap.value = depths;
        return array2;
      });
      const data = computed(() => {
        const { data: data2, expandColumnKey: expandColumnKey2 } = props;
        return expandColumnKey2 ? unref(flattenedData) : data2;
      });
      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$3(listLike) ? listLike.reduce(sumReducer, 0) : listLike;
    };
    const tryCall = (fLike, params, defaultRet = {}) => {
      return isFunction$2(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) => isVNode(ComponentLike) ? (props) => h$1(ComponentLike, props) : ComponentLike;
    const useStyles = (props, {
      columnsTotalWidth,
      data,
      fixedColumnsOnLeft,
      fixedColumnsOnRight
    }) => {
      const bodyWidth = computed(() => {
        const { fixed, width, vScrollbarSize } = props;
        const ret = width - vScrollbarSize;
        return fixed ? Math.max(Math.round(unref(columnsTotalWidth)), ret) : ret;
      });
      const headerWidth = computed(() => unref(bodyWidth) + (props.fixed ? props.vScrollbarSize : 0));
      const mainTableHeight = computed(() => {
        const { height = 0, maxHeight = 0, footerHeight: footerHeight2, hScrollbarSize } = props;
        if (maxHeight > 0) {
          const _fixedRowsHeight = unref(fixedRowsHeight);
          const _rowsHeight = unref(rowsHeight);
          const _headerHeight = unref(headerHeight);
          const total2 = _headerHeight + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
          return Math.min(total2, maxHeight - footerHeight2);
        }
        return height - footerHeight2;
      });
      const rowsHeight = computed(() => {
        const { rowHeight, estimatedRowHeight } = props;
        const _data = unref(data);
        if (isNumber(estimatedRowHeight)) {
          return _data.length * estimatedRowHeight;
        }
        return _data.length * rowHeight;
      });
      const fixedTableHeight = computed(() => {
        const { maxHeight } = props;
        const tableHeight = unref(mainTableHeight);
        if (isNumber(maxHeight) && maxHeight > 0)
          return tableHeight;
        const totalHeight = unref(rowsHeight) + unref(headerHeight) + unref(fixedRowsHeight);
        return Math.min(tableHeight, totalHeight);
      });
      const mapColumn = (column) => column.width;
      const leftTableWidth = computed(() => sum(unref(fixedColumnsOnLeft).map(mapColumn)));
      const rightTableWidth = computed(() => sum(unref(fixedColumnsOnRight).map(mapColumn)));
      const headerHeight = computed(() => sum(props.headerHeight));
      const fixedRowsHeight = computed(() => {
        var _a2;
        return (((_a2 = props.fixedData) == null ? void 0 : _a2.length) || 0) * props.rowHeight;
      });
      const windowHeight = computed(() => {
        return unref(mainTableHeight) - unref(headerHeight) - unref(fixedRowsHeight);
      });
      const rootStyle = computed(() => {
        const { style = {}, height, width } = props;
        return enforceUnit({
          ...style,
          height,
          width
        });
      });
      const footerHeight = computed(() => enforceUnit({ height: props.footerHeight }));
      const emptyStyle = computed(() => ({
        top: addUnit(unref(headerHeight)),
        bottom: addUnit(props.footerHeight),
        width: addUnit(props.width)
      }));
      return {
        bodyWidth,
        fixedTableHeight,
        mainTableHeight,
        leftTableWidth,
        rightTableWidth,
        headerWidth,
        rowsHeight,
        windowHeight,
        footerHeight,
        emptyStyle,
        rootStyle,
        headerHeight
      };
    };
    const useAutoResize = (props) => {
      const sizer = ref();
      const width$ = ref(0);
      const height$ = ref(0);
      let resizerStopper;
      onMounted(() => {
        resizerStopper = useResizeObserver(sizer, ([entry]) => {
          const { width, height } = entry.contentRect;
          const { paddingLeft, paddingRight, paddingTop, paddingBottom } = getComputedStyle(entry.target);
          const left2 = Number.parseInt(paddingLeft) || 0;
          const right2 = Number.parseInt(paddingRight) || 0;
          const top = Number.parseInt(paddingTop) || 0;
          const bottom = Number.parseInt(paddingBottom) || 0;
          width$.value = width - left2 - right2;
          height$.value = height - top - bottom;
        }).stop;
      });
      onBeforeUnmount(() => {
        resizerStopper == null ? void 0 : resizerStopper();
      });
      watch([width$, height$], ([width, height]) => {
        var _a2;
        (_a2 = props.onResize) == null ? void 0 : _a2.call(props, {
          width,
          height
        });
      });
      return {
        sizer,
        width: width$,
        height: height$
      };
    };
    function useTable(props) {
      const mainTableRef = ref();
      const leftTableRef = ref();
      const rightTableRef = ref();
      const {
        columns: columns2,
        columnsStyles,
        columnsTotalWidth,
        fixedColumnsOnLeft,
        fixedColumnsOnRight,
        hasFixedColumns,
        mainColumns,
        onColumnSorted
      } = useColumns(props, toRef(props, "columns"), toRef(props, "fixed"));
      const {
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow,
        onScroll,
        onVerticalScroll,
        scrollPos
      } = useScrollbar(props, {
        mainTableRef,
        leftTableRef,
        rightTableRef,
        onMaybeEndReached
      });
      const {
        expandedRowKeys,
        hoveringRowKey,
        lastRenderedRowIndex,
        isDynamic,
        isResetting,
        rowHeights,
        resetAfterIndex,
        onRowExpanded,
        onRowHeightChange,
        onRowHovered,
        onRowsRendered
      } = useRow(props, {
        mainTableRef,
        leftTableRef,
        rightTableRef
      });
      const { data, depthMap } = useData(props, {
        expandedRowKeys,
        lastRenderedRowIndex,
        resetAfterIndex
      });
      const {
        bodyWidth,
        fixedTableHeight,
        mainTableHeight,
        leftTableWidth,
        rightTableWidth,
        headerWidth,
        rowsHeight,
        windowHeight,
        footerHeight,
        emptyStyle,
        rootStyle,
        headerHeight
      } = useStyles(props, {
        columnsTotalWidth,
        data,
        fixedColumnsOnLeft,
        fixedColumnsOnRight
      });
      const isScrolling = shallowRef(false);
      const containerRef = ref();
      const showEmpty = computed(() => {
        const noData = unref(data).length === 0;
        return isArray$3(props.fixedData) ? props.fixedData.length === 0 && noData : noData;
      });
      function getRowHeight(rowIndex) {
        const { estimatedRowHeight, rowHeight, rowKey: rowKey2 } = props;
        if (!estimatedRowHeight)
          return rowHeight;
        return unref(rowHeights)[unref(data)[rowIndex][rowKey2]] || estimatedRowHeight;
      }
      function onMaybeEndReached() {
        const { onEndReached } = props;
        if (!onEndReached)
          return;
        const { scrollTop } = unref(scrollPos);
        const _totalHeight = unref(rowsHeight);
        const clientHeight = unref(windowHeight);
        const heightUntilEnd = _totalHeight - (scrollTop + clientHeight) + props.hScrollbarSize;
        if (unref(lastRenderedRowIndex) >= 0 && _totalHeight === scrollTop + unref(mainTableHeight) - unref(headerHeight)) {
          onEndReached(heightUntilEnd);
        }
      }
      watch(() => props.expandedRowKeys, (val) => expandedRowKeys.value = val, {
        deep: true
      });
      return {
        columns: columns2,
        containerRef,
        mainTableRef,
        leftTableRef,
        rightTableRef,
        isDynamic,
        isResetting,
        isScrolling,
        hoveringRowKey,
        hasFixedColumns,
        columnsStyles,
        columnsTotalWidth,
        data,
        expandedRowKeys,
        depthMap,
        fixedColumnsOnLeft,
        fixedColumnsOnRight,
        mainColumns,
        bodyWidth,
        emptyStyle,
        rootStyle,
        headerWidth,
        footerHeight,
        mainTableHeight,
        fixedTableHeight,
        leftTableWidth,
        rightTableWidth,
        showEmpty,
        getRowHeight,
        onColumnSorted,
        onRowHovered,
        onRowExpanded,
        onRowsRendered,
        onRowHeightChange,
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow,
        onScroll,
        onVerticalScroll
      };
    }
    const TableV2InjectionKey = Symbol("tableV2");
    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 _a2;
      const {
        cellData,
        style
      } = props;
      const displayText = ((_a2 = cellData == null ? void 0 : cellData.toString) == null ? void 0 : _a2.call(cellData)) || "";
      return createVNode("div", {
        "class": props.class,
        "title": displayText,
        "style": style
      }, [slots.default ? slots.default(props) : displayText]);
    };
    TableV2Cell.displayName = "ElTableV2Cell";
    TableV2Cell.inheritAttrs = false;
    const HeaderCell = (props, {
      slots
    }) => {
      var _a2, _b;
      return slots.default ? slots.default(props) : createVNode("div", {
        "class": props.class,
        "title": (_a2 = props.column) == null ? void 0 : _a2.title
      }, [(_b = props.column) == null ? void 0 : _b.title]);
    };
    HeaderCell.displayName = "ElTableV2HeaderCell";
    HeaderCell.inheritAttrs = false;
    const tableV2HeaderRowProps = buildProps({
      class: String,
      columns,
      columnsStyles: {
        type: definePropType(Object),
        required: true
      },
      headerIndex: Number,
      style: { type: definePropType(Object) }
    });
    const TableV2HeaderRow = /* @__PURE__ */ defineComponent({
      name: "ElTableV2HeaderRow",
      props: tableV2HeaderRowProps,
      setup(props, {
        slots
      }) {
        return () => {
          const {
            columns: columns2,
            columnsStyles,
            headerIndex,
            style
          } = props;
          let Cells = columns2.map((column, columnIndex) => {
            return slots.cell({
              columns: columns2,
              column,
              columnIndex,
              headerIndex,
              style: columnsStyles[column.key]
            });
          });
          if (slots.header) {
            Cells = slots.header({
              cells: Cells.map((node) => {
                if (isArray$3(node) && node.length === 1) {
                  return node[0];
                }
                return node;
              }),
              columns: columns2,
              headerIndex
            });
          }
          return createVNode("div", {
            "class": props.class,
            "style": style,
            "role": "row"
          }, [Cells]);
        };
      }
    });
    const COMPONENT_NAME$7 = "ElTableV2Header";
    const TableV2Header = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$7,
      props: tableV2HeaderProps,
      setup(props, {
        slots,
        expose
      }) {
        const ns = useNamespace("table-v2");
        const headerRef = ref();
        const headerStyle = computed(() => enforceUnit({
          width: props.width,
          height: props.height
        }));
        const rowStyle = computed(() => enforceUnit({
          width: props.rowWidth,
          height: props.height
        }));
        const headerHeights = computed(() => castArray$1(unref(props.headerHeight)));
        const scrollToLeft = (left2) => {
          const headerEl = unref(headerRef);
          nextTick(() => {
            (headerEl == null ? void 0 : headerEl.scroll) && headerEl.scroll({
              left: left2
            });
          });
        };
        const renderFixedRows = () => {
          const fixedRowClassName = ns.e("fixed-header-row");
          const {
            columns: columns2,
            fixedHeaderData,
            rowHeight
          } = props;
          return fixedHeaderData == null ? void 0 : fixedHeaderData.map((fixedRowData, fixedRowIndex) => {
            var _a2;
            const style = enforceUnit({
              height: rowHeight,
              width: "100%"
            });
            return (_a2 = slots.fixed) == null ? void 0 : _a2.call(slots, {
              class: fixedRowClassName,
              columns: columns2,
              rowData: fixedRowData,
              rowIndex: -(fixedRowIndex + 1),
              style
            });
          });
        };
        const renderDynamicRows = () => {
          const dynamicRowClassName = ns.e("dynamic-header-row");
          const {
            columns: columns2
          } = props;
          return unref(headerHeights).map((rowHeight, rowIndex) => {
            var _a2;
            const style = enforceUnit({
              width: "100%",
              height: rowHeight
            });
            return (_a2 = slots.dynamic) == null ? void 0 : _a2.call(slots, {
              class: dynamicRowClassName,
              columns: columns2,
              headerIndex: rowIndex,
              style
            });
          });
        };
        expose({
          scrollToLeft
        });
        return () => {
          if (props.height <= 0)
            return;
          return createVNode("div", {
            "ref": headerRef,
            "class": props.class,
            "style": unref(headerStyle),
            "role": "rowgroup"
          }, [createVNode("div", {
            "style": unref(rowStyle),
            "class": ns.e("header")
          }, [renderDynamicRows(), renderFixedRows()])]);
        };
      }
    });
    const useTableRow = (props) => {
      const {
        isScrolling
      } = inject(TableV2InjectionKey);
      const measured = ref(false);
      const rowRef = ref();
      const measurable = computed(() => {
        return isNumber(props.estimatedRowHeight) && props.rowIndex >= 0;
      });
      const doMeasure = (isInit = false) => {
        const $rowRef = unref(rowRef);
        if (!$rowRef)
          return;
        const {
          columns: columns2,
          onRowHeightChange,
          rowKey: rowKey2,
          rowIndex,
          style
        } = props;
        const {
          height
        } = $rowRef.getBoundingClientRect();
        measured.value = true;
        nextTick(() => {
          if (isInit || height !== Number.parseInt(style.height)) {
            const firstColumn = columns2[0];
            const isPlaceholder = (firstColumn == null ? void 0 : firstColumn.placeholderSign) === placeholderSign;
            onRowHeightChange == null ? void 0 : onRowHeightChange({
              rowKey: rowKey2,
              height,
              rowIndex
            }, firstColumn && !isPlaceholder && firstColumn.fixed);
          }
        });
      };
      const eventHandlers = computed(() => {
        const {
          rowData,
          rowIndex,
          rowKey: rowKey2,
          onRowHover
        } = props;
        const handlers = props.rowEventHandlers || {};
        const eventHandlers2 = {};
        Object.entries(handlers).forEach(([eventName, handler]) => {
          if (isFunction$2(handler)) {
            eventHandlers2[eventName] = (event) => {
              handler({
                event,
                rowData,
                rowIndex,
                rowKey: rowKey2
              });
            };
          }
        });
        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: rowKey2
              });
              existedHandler == null ? void 0 : existedHandler(event);
            };
          });
        }
        return eventHandlers2;
      });
      const onExpand = (expanded) => {
        const {
          onRowExpand,
          rowData,
          rowIndex,
          rowKey: rowKey2
        } = props;
        onRowExpand == null ? void 0 : onRowExpand({
          expanded,
          rowData,
          rowIndex,
          rowKey: rowKey2
        });
      };
      onMounted(() => {
        if (unref(measurable)) {
          doMeasure(true);
        }
      });
      return {
        isScrolling,
        measurable,
        measured,
        rowRef,
        eventHandlers,
        onExpand
      };
    };
    const COMPONENT_NAME$6 = "ElTableV2TableRow";
    const TableV2Row = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$6,
      props: tableV2RowProps,
      setup(props, {
        expose,
        slots,
        attrs
      }) {
        const {
          eventHandlers,
          isScrolling,
          measurable,
          measured,
          rowRef,
          onExpand
        } = useTableRow(props);
        expose({
          onExpand
        });
        return () => {
          const {
            columns: columns2,
            columnsStyles,
            expandColumnKey: expandColumnKey2,
            depth,
            rowData,
            rowIndex,
            style
          } = props;
          let ColumnCells = columns2.map((column, columnIndex) => {
            const expandable = isArray$3(rowData.children) && rowData.children.length > 0 && column.key === expandColumnKey2;
            return slots.cell({
              column,
              columns: columns2,
              columnIndex,
              depth,
              style: columnsStyles[column.key],
              rowData,
              rowIndex,
              isScrolling: unref(isScrolling),
              expandIconProps: expandable ? {
                rowData,
                rowIndex,
                onExpand
              } : void 0
            });
          });
          if (slots.row) {
            ColumnCells = slots.row({
              cells: ColumnCells.map((node) => {
                if (isArray$3(node) && node.length === 1) {
                  return node[0];
                }
                return node;
              }),
              style,
              columns: columns2,
              depth,
              rowData,
              rowIndex,
              isScrolling: unref(isScrolling)
            });
          }
          if (unref(measurable)) {
            const {
              height,
              ...exceptHeightStyle
            } = style || {};
            const _measured = unref(measured);
            return createVNode("div", mergeProps({
              "ref": rowRef,
              "class": props.class,
              "style": _measured ? style : exceptHeightStyle,
              "role": "row"
            }, attrs, unref(eventHandlers)), [ColumnCells]);
          }
          return createVNode("div", mergeProps(attrs, {
            "ref": rowRef,
            "class": props.class,
            "style": style,
            "role": "row"
          }, unref(eventHandlers)), [ColumnCells]);
        };
      }
    });
    const SortIcon = (props) => {
      const {
        sortOrder
      } = props;
      return createVNode(ElIcon, {
        "size": 14,
        "class": props.class
      }, {
        default: () => [sortOrder === SortOrder.ASC ? createVNode(sort_up_default, null, null) : createVNode(sort_down_default, null, null)]
      });
    };
    const ExpandIcon = (props) => {
      const {
        expanded,
        expandable,
        onExpand,
        style,
        size: size2
      } = props;
      const expandIconProps = {
        onClick: expandable ? () => onExpand(!expanded) : void 0,
        class: props.class
      };
      return createVNode(ElIcon, mergeProps(expandIconProps, {
        "size": size2,
        "style": style
      }), {
        default: () => [createVNode(arrow_right_default, null, null)]
      });
    };
    const COMPONENT_NAME$5 = "ElTableV2Grid";
    const useTableGrid = (props) => {
      const headerRef = ref();
      const bodyRef = ref();
      const totalHeight = computed(() => {
        const {
          data,
          rowHeight,
          estimatedRowHeight
        } = props;
        if (estimatedRowHeight) {
          return;
        }
        return data.length * rowHeight;
      });
      const fixedRowHeight = computed(() => {
        const {
          fixedData,
          rowHeight
        } = props;
        return ((fixedData == null ? void 0 : fixedData.length) || 0) * rowHeight;
      });
      const headerHeight = computed(() => sum(props.headerHeight));
      const gridHeight = computed(() => {
        const {
          height
        } = props;
        return Math.max(0, height - unref(headerHeight) - unref(fixedRowHeight));
      });
      const hasHeader = computed(() => {
        return unref(headerHeight) + unref(fixedRowHeight) > 0;
      });
      const itemKey = ({
        data,
        rowIndex
      }) => data[rowIndex][props.rowKey];
      function onItemRendered({
        rowCacheStart,
        rowCacheEnd,
        rowVisibleStart,
        rowVisibleEnd
      }) {
        var _a2;
        (_a2 = props.onRowsRendered) == null ? void 0 : _a2.call(props, {
          rowCacheStart,
          rowCacheEnd,
          rowVisibleStart,
          rowVisibleEnd
        });
      }
      function resetAfterRowIndex(index2, forceUpdate2) {
        var _a2;
        (_a2 = bodyRef.value) == null ? void 0 : _a2.resetAfterRowIndex(index2, forceUpdate2);
      }
      function scrollTo(leftOrOptions, top) {
        const header$ = unref(headerRef);
        const body$ = unref(bodyRef);
        if (!header$ || !body$)
          return;
        if (isObject$1(leftOrOptions)) {
          header$.scrollToLeft(leftOrOptions.scrollLeft);
          body$.scrollTo(leftOrOptions);
        } else {
          header$.scrollToLeft(leftOrOptions);
          body$.scrollTo({
            scrollLeft: leftOrOptions,
            scrollTop: top
          });
        }
      }
      function scrollToTop(scrollTop) {
        var _a2;
        (_a2 = unref(bodyRef)) == null ? void 0 : _a2.scrollTo({
          scrollTop
        });
      }
      function scrollToRow(row, strategy) {
        var _a2;
        (_a2 = unref(bodyRef)) == null ? void 0 : _a2.scrollToItem(row, 1, strategy);
      }
      function forceUpdate() {
        var _a2, _b;
        (_a2 = unref(bodyRef)) == null ? void 0 : _a2.$forceUpdate();
        (_b = unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
      }
      return {
        bodyRef,
        forceUpdate,
        fixedRowHeight,
        gridHeight,
        hasHeader,
        headerHeight,
        headerRef,
        totalHeight,
        itemKey,
        onItemRendered,
        resetAfterRowIndex,
        scrollTo,
        scrollToTop,
        scrollToRow
      };
    };
    const TableGrid = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$5,
      props: tableV2GridProps,
      setup(props, {
        slots,
        expose
      }) {
        const {
          ns
        } = inject(TableV2InjectionKey);
        const {
          bodyRef,
          fixedRowHeight,
          gridHeight,
          hasHeader,
          headerRef,
          headerHeight,
          totalHeight,
          forceUpdate,
          itemKey,
          onItemRendered,
          resetAfterRowIndex,
          scrollTo,
          scrollToTop,
          scrollToRow
        } = useTableGrid(props);
        expose({
          forceUpdate,
          totalHeight,
          scrollTo,
          scrollToTop,
          scrollToRow,
          resetAfterRowIndex
        });
        const getColumnWidth = () => props.bodyWidth;
        return () => {
          const {
            cache: cache2,
            columns: columns2,
            data,
            fixedData,
            useIsScrolling,
            scrollbarAlwaysOn,
            scrollbarEndGap,
            scrollbarStartGap,
            style,
            rowHeight,
            bodyWidth,
            estimatedRowHeight,
            headerWidth,
            height,
            width,
            getRowHeight,
            onScroll
          } = props;
          const isDynamicRowEnabled = isNumber(estimatedRowHeight);
          const Grid = isDynamicRowEnabled ? DynamicSizeGrid : FixedSizeGrid;
          const _headerHeight = unref(headerHeight);
          return createVNode("div", {
            "role": "table",
            "class": [ns.e("table"), props.class],
            "style": style
          }, [createVNode(Grid, {
            "ref": bodyRef,
            "data": data,
            "useIsScrolling": useIsScrolling,
            "itemKey": itemKey,
            "columnCache": 0,
            "columnWidth": isDynamicRowEnabled ? getColumnWidth : bodyWidth,
            "totalColumn": 1,
            "totalRow": data.length,
            "rowCache": cache2,
            "rowHeight": isDynamicRowEnabled ? getRowHeight : rowHeight,
            "width": width,
            "height": unref(gridHeight),
            "class": ns.e("body"),
            "role": "rowgroup",
            "scrollbarStartGap": scrollbarStartGap,
            "scrollbarEndGap": scrollbarEndGap,
            "scrollbarAlwaysOn": scrollbarAlwaysOn,
            "onScroll": onScroll,
            "onItemRendered": onItemRendered,
            "perfMode": false
          }, {
            default: (params) => {
              var _a2;
              const rowData = data[params.rowIndex];
              return (_a2 = slots.row) == null ? void 0 : _a2.call(slots, {
                ...params,
                columns: columns2,
                rowData
              });
            }
          }), unref(hasHeader) && createVNode(TableV2Header, {
            "ref": headerRef,
            "class": ns.e("header-wrapper"),
            "columns": columns2,
            "headerData": data,
            "headerHeight": props.headerHeight,
            "fixedHeaderData": fixedData,
            "rowWidth": headerWidth,
            "rowHeight": rowHeight,
            "width": width,
            "height": Math.min(_headerHeight + unref(fixedRowHeight), height)
          }, {
            dynamic: slots.header,
            fixed: slots.row
          })]);
        };
      }
    });
    function _isSlot$5(s2) {
      return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
    }
    const MainTable = (props, {
      slots
    }) => {
      const {
        mainTableRef,
        ...rest
      } = props;
      return createVNode(TableGrid, mergeProps({
        "ref": mainTableRef
      }, rest), _isSlot$5(slots) ? slots : {
        default: () => [slots]
      });
    };
    function _isSlot$4(s2) {
      return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
    }
    const LeftTable$1 = (props, {
      slots
    }) => {
      if (!props.columns.length)
        return;
      const {
        leftTableRef,
        ...rest
      } = props;
      return createVNode(TableGrid, mergeProps({
        "ref": leftTableRef
      }, rest), _isSlot$4(slots) ? slots : {
        default: () => [slots]
      });
    };
    function _isSlot$3(s2) {
      return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
    }
    const LeftTable = (props, {
      slots
    }) => {
      if (!props.columns.length)
        return;
      const {
        rightTableRef,
        ...rest
      } = props;
      return createVNode(TableGrid, mergeProps({
        "ref": rightTableRef
      }, rest), _isSlot$3(slots) ? slots : {
        default: () => [slots]
      });
    };
    function _isSlot$2(s2) {
      return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
    }
    const RowRenderer = (props, {
      slots
    }) => {
      const {
        columns: columns2,
        columnsStyles,
        depthMap,
        expandColumnKey: expandColumnKey2,
        expandedRowKeys,
        estimatedRowHeight,
        hasFixedColumns,
        hoveringRowKey,
        rowData,
        rowIndex,
        style,
        isScrolling,
        rowProps: rowProps2,
        rowClass,
        rowKey: rowKey2,
        rowEventHandlers,
        ns,
        onRowHovered,
        onRowExpanded
      } = props;
      const rowKls = tryCall(rowClass, {
        columns: columns2,
        rowData,
        rowIndex
      }, "");
      const additionalProps = tryCall(rowProps2, {
        columns: columns2,
        rowData,
        rowIndex
      });
      const _rowKey = rowData[rowKey2];
      const depth = depthMap[_rowKey] || 0;
      const canExpand = Boolean(expandColumnKey2);
      const isFixedRow = rowIndex < 0;
      const kls = [ns.e("row"), rowKls, {
        [ns.e(`row-depth-${depth}`)]: canExpand && rowIndex >= 0,
        [ns.is("expanded")]: canExpand && expandedRowKeys.includes(_rowKey),
        [ns.is("hovered")]: !isScrolling && _rowKey === hoveringRowKey,
        [ns.is("fixed")]: !depth && isFixedRow,
        [ns.is("customized")]: Boolean(slots.row)
      }];
      const onRowHover = hasFixedColumns ? onRowHovered : void 0;
      const _rowProps = {
        ...additionalProps,
        columns: columns2,
        columnsStyles,
        class: kls,
        depth,
        expandColumnKey: expandColumnKey2,
        estimatedRowHeight: isFixedRow ? void 0 : estimatedRowHeight,
        isScrolling,
        rowIndex,
        rowData,
        rowKey: _rowKey,
        rowEventHandlers,
        style
      };
      return createVNode(TableV2Row, mergeProps(_rowProps, {
        "onRowHover": onRowHover,
        "onRowExpand": onRowExpanded
      }), _isSlot$2(slots) ? slots : {
        default: () => [slots]
      });
    };
    const CellRenderer = ({
      columns: columns2,
      column,
      columnIndex,
      depth,
      expandIconProps,
      isScrolling,
      rowData,
      rowIndex,
      style,
      expandedRowKeys,
      ns,
      cellProps: _cellProps,
      expandColumnKey: expandColumnKey2,
      indentSize,
      iconSize,
      rowKey: rowKey2
    }, {
      slots
    }) => {
      const cellStyle = enforceUnit(style);
      if (column.placeholderSign === placeholderSign) {
        return createVNode("div", {
          "class": ns.em("row-cell", "placeholder"),
          "style": cellStyle
        }, null);
      }
      const {
        cellRenderer,
        dataKey,
        dataGetter
      } = column;
      const columnCellRenderer = componentToSlot(cellRenderer);
      const CellComponent = columnCellRenderer || slots.default || ((props) => createVNode(TableV2Cell, props, null));
      const cellData = isFunction$2(dataGetter) ? dataGetter({
        columns: columns2,
        column,
        columnIndex,
        rowData,
        rowIndex
      }) : get(rowData, dataKey != null ? dataKey : "");
      const extraCellProps = tryCall(_cellProps, {
        cellData,
        columns: columns2,
        column,
        columnIndex,
        rowIndex,
        rowData
      });
      const cellProps = {
        class: ns.e("cell-text"),
        columns: columns2,
        column,
        columnIndex,
        cellData,
        isScrolling,
        rowData,
        rowIndex
      };
      const Cell = CellComponent(cellProps);
      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 && expandColumnKey2 && column.key === expandColumnKey2;
      const expanded = rowIndex >= 0 && expandedRowKeys.includes(rowData[rowKey2]);
      let IconOrPlaceholder;
      const iconStyle = `margin-inline-start: ${depth * indentSize}px;`;
      if (expandable) {
        if (isObject$1(expandIconProps)) {
          IconOrPlaceholder = createVNode(ExpandIcon, mergeProps(expandIconProps, {
            "class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
            "size": iconSize,
            "expanded": expanded,
            "style": iconStyle,
            "expandable": true
          }), null);
        } else {
          IconOrPlaceholder = createVNode("div", {
            "style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ")
          }, null);
        }
      }
      return createVNode("div", mergeProps({
        "class": kls,
        "style": cellStyle
      }, extraCellProps, {
        "role": "cell"
      }), [IconOrPlaceholder, Cell]);
    };
    CellRenderer.inheritAttrs = false;
    function _isSlot$1(s2) {
      return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
    }
    const HeaderRenderer = ({
      columns: columns2,
      columnsStyles,
      headerIndex,
      style,
      headerClass,
      headerProps,
      ns
    }, {
      slots
    }) => {
      const param = {
        columns: columns2,
        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: columns2,
        headerIndex,
        style
      };
      return createVNode(TableV2HeaderRow, 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 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 cellRenderer = componentToSlot(headerCellRenderer) || slots.default || ((props2) => createVNode(HeaderCell, props2, null));
      const Cell = cellRenderer(cellProps);
      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 createVNode("div", mergeProps(cellWrapperProps, {
        "role": "columnheader"
      }), [Cell, sortable && createVNode(SortIcon, {
        "class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
        "sortOrder": sortOrder
      }, null)]);
    };
    const Footer$1 = (props, {
      slots
    }) => {
      var _a2;
      return createVNode("div", {
        "class": props.class,
        "style": props.style
      }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]);
    };
    Footer$1.displayName = "ElTableV2Footer";
    const Footer = (props, {
      slots
    }) => {
      return createVNode("div", {
        "class": props.class,
        "style": props.style
      }, [slots.default ? slots.default() : createVNode(ElEmpty, null, null)]);
    };
    Footer.displayName = "ElTableV2Empty";
    const Overlay = (props, {
      slots
    }) => {
      var _a2;
      return createVNode("div", {
        "class": props.class,
        "style": props.style
      }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]);
    };
    Overlay.displayName = "ElTableV2Overlay";
    function _isSlot(s2) {
      return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
    }
    const COMPONENT_NAME$4 = "ElTableV2";
    const TableV2 = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$4,
      props: tableV2Props,
      setup(props, {
        slots,
        expose
      }) {
        const ns = useNamespace("table-v2");
        const {
          columnsStyles,
          fixedColumnsOnLeft,
          fixedColumnsOnRight,
          mainColumns,
          mainTableHeight,
          fixedTableHeight,
          leftTableWidth,
          rightTableWidth,
          data,
          depthMap,
          expandedRowKeys,
          hasFixedColumns,
          hoveringRowKey,
          mainTableRef,
          leftTableRef,
          rightTableRef,
          isDynamic,
          isResetting,
          isScrolling,
          bodyWidth,
          emptyStyle,
          rootStyle,
          headerWidth,
          footerHeight,
          showEmpty,
          scrollTo,
          scrollToLeft,
          scrollToTop,
          scrollToRow,
          getRowHeight,
          onColumnSorted,
          onRowHeightChange,
          onRowHovered,
          onRowExpanded,
          onRowsRendered,
          onScroll,
          onVerticalScroll
        } = useTable(props);
        expose({
          scrollTo,
          scrollToLeft,
          scrollToTop,
          scrollToRow
        });
        provide(TableV2InjectionKey, {
          ns,
          isResetting,
          hoveringRowKey,
          isScrolling
        });
        return () => {
          const {
            cache: cache2,
            cellProps,
            estimatedRowHeight,
            expandColumnKey: expandColumnKey2,
            fixedData,
            headerHeight,
            headerClass,
            headerProps,
            headerCellProps,
            sortBy,
            sortState,
            rowHeight,
            rowClass,
            rowEventHandlers,
            rowKey: rowKey2,
            rowProps: rowProps2,
            scrollbarAlwaysOn,
            indentSize,
            iconSize,
            useIsScrolling,
            vScrollbarSize,
            width
          } = props;
          const _data = unref(data);
          const mainTableProps = {
            cache: cache2,
            class: ns.e("main"),
            columns: unref(mainColumns),
            data: _data,
            fixedData,
            estimatedRowHeight,
            bodyWidth: unref(bodyWidth) + vScrollbarSize,
            headerHeight,
            headerWidth: unref(headerWidth),
            height: unref(mainTableHeight),
            mainTableRef,
            rowKey: rowKey2,
            rowHeight,
            scrollbarAlwaysOn,
            scrollbarStartGap: 2,
            scrollbarEndGap: vScrollbarSize,
            useIsScrolling,
            width,
            getRowHeight,
            onRowsRendered,
            onScroll
          };
          const leftColumnsWidth = unref(leftTableWidth);
          const _fixedTableHeight = unref(fixedTableHeight);
          const leftTableProps = {
            cache: cache2,
            class: ns.e("left"),
            columns: unref(fixedColumnsOnLeft),
            data: _data,
            estimatedRowHeight,
            leftTableRef,
            rowHeight,
            bodyWidth: leftColumnsWidth,
            headerWidth: leftColumnsWidth,
            headerHeight,
            height: _fixedTableHeight,
            rowKey: rowKey2,
            scrollbarAlwaysOn,
            scrollbarStartGap: 2,
            scrollbarEndGap: vScrollbarSize,
            useIsScrolling,
            width: leftColumnsWidth,
            getRowHeight,
            onScroll: onVerticalScroll
          };
          const rightColumnsWidth = unref(rightTableWidth);
          const rightColumnsWidthWithScrollbar = rightColumnsWidth + vScrollbarSize;
          const rightTableProps = {
            cache: cache2,
            class: ns.e("right"),
            columns: unref(fixedColumnsOnRight),
            data: _data,
            estimatedRowHeight,
            rightTableRef,
            rowHeight,
            bodyWidth: rightColumnsWidthWithScrollbar,
            headerWidth: rightColumnsWidthWithScrollbar,
            headerHeight,
            height: _fixedTableHeight,
            rowKey: rowKey2,
            scrollbarAlwaysOn,
            scrollbarStartGap: 2,
            scrollbarEndGap: vScrollbarSize,
            width: rightColumnsWidthWithScrollbar,
            style: `--${unref(ns.namespace)}-table-scrollbar-size: ${vScrollbarSize}px`,
            useIsScrolling,
            getRowHeight,
            onScroll: onVerticalScroll
          };
          const _columnsStyles = unref(columnsStyles);
          const tableRowProps = {
            ns,
            depthMap: unref(depthMap),
            columnsStyles: _columnsStyles,
            expandColumnKey: expandColumnKey2,
            expandedRowKeys: unref(expandedRowKeys),
            estimatedRowHeight,
            hasFixedColumns: unref(hasFixedColumns),
            hoveringRowKey: unref(hoveringRowKey),
            rowProps: rowProps2,
            rowClass,
            rowKey: rowKey2,
            rowEventHandlers,
            onRowHovered,
            onRowExpanded,
            onRowHeightChange
          };
          const tableCellProps = {
            cellProps,
            expandColumnKey: expandColumnKey2,
            indentSize,
            iconSize,
            rowKey: rowKey2,
            expandedRowKeys: unref(expandedRowKeys),
            ns
          };
          const tableHeaderProps = {
            ns,
            headerClass,
            headerProps,
            columnsStyles: _columnsStyles
          };
          const tableHeaderCellProps = {
            ns,
            sortBy,
            sortState,
            headerCellProps,
            onColumnSorted
          };
          const tableSlots = {
            row: (props2) => createVNode(RowRenderer, mergeProps(props2, tableRowProps), {
              row: slots.row,
              cell: (props3) => {
                let _slot;
                return slots.cell ? createVNode(CellRenderer, mergeProps(props3, tableCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), _isSlot(_slot = slots.cell(props3)) ? _slot : {
                  default: () => [_slot]
                }) : createVNode(CellRenderer, mergeProps(props3, tableCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), null);
              }
            }),
            header: (props2) => createVNode(HeaderRenderer, mergeProps(props2, tableHeaderProps), {
              header: slots.header,
              cell: (props3) => {
                let _slot2;
                return slots["header-cell"] ? createVNode(HeaderCellRenderer, mergeProps(props3, tableHeaderCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), _isSlot(_slot2 = slots["header-cell"](props3)) ? _slot2 : {
                  default: () => [_slot2]
                }) : createVNode(HeaderCellRenderer, mergeProps(props3, tableHeaderCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), null);
              }
            })
          };
          const rootKls = [props.class, ns.b(), ns.e("root"), {
            [ns.is("dynamic")]: unref(isDynamic)
          }];
          const footerProps = {
            class: ns.e("footer"),
            style: unref(footerHeight)
          };
          return createVNode("div", {
            "class": rootKls,
            "style": unref(rootStyle)
          }, [createVNode(MainTable, mainTableProps, _isSlot(tableSlots) ? tableSlots : {
            default: () => [tableSlots]
          }), createVNode(LeftTable$1, leftTableProps, _isSlot(tableSlots) ? tableSlots : {
            default: () => [tableSlots]
          }), createVNode(LeftTable, rightTableProps, _isSlot(tableSlots) ? tableSlots : {
            default: () => [tableSlots]
          }), slots.footer && createVNode(Footer$1, footerProps, {
            default: slots.footer
          }), unref(showEmpty) && createVNode(Footer, {
            "class": ns.e("empty"),
            "style": unref(emptyStyle)
          }, {
            default: slots.empty
          }), slots.overlay && createVNode(Overlay, {
            "class": ns.e("overlay")
          }, {
            default: slots.overlay
          })]);
        };
      }
    });
    const autoResizerProps = buildProps({
      disableWidth: Boolean,
      disableHeight: Boolean,
      onResize: {
        type: definePropType(Function)
      }
    });
    const AutoResizer = /* @__PURE__ */ 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 _a2;
          return createVNode("div", {
            "ref": sizer,
            "class": ns.b(),
            "style": style
          }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots, {
            height: height.value,
            width: width.value
          })]);
        };
      }
    });
    const ElTableV2 = withInstall(TableV2);
    const ElAutoResizer = withInstall(AutoResizer);
    const tabsRootContextKey = Symbol("tabsRootContextKey");
    const tabBarProps = buildProps({
      tabs: {
        type: definePropType(Array),
        default: () => mutable([])
      }
    });
    const COMPONENT_NAME$3 = "ElTabBar";
    const __default__$l = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$3
    });
    const _sfc_main$u = /* @__PURE__ */ defineComponent({
      ...__default__$l,
      props: tabBarProps,
      setup(__props, { expose }) {
        const props = __props;
        const instance = getCurrentInstance();
        const rootTabs = inject(tabsRootContextKey);
        if (!rootTabs)
          throwError(COMPONENT_NAME$3, "<el-tabs><el-tab-bar /></el-tabs>");
        const ns = useNamespace("tabs");
        const barRef = ref();
        const barStyle = ref();
        const getBarStyle = () => {
          let offset2 = 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) => {
            var _a2, _b;
            const $el = (_b = (_a2 = instance.parent) == null ? void 0 : _a2.refs) == null ? void 0 : _b[`tab-${tab.uid}`];
            if (!$el)
              return false;
            if (!tab.active) {
              return true;
            }
            offset2 = $el[`offset${capitalize(position)}`];
            tabSize = $el[`client${capitalize(sizeName)}`];
            const tabStyles = window.getComputedStyle($el);
            if (sizeName === "width") {
              if (props.tabs.length > 1) {
                tabSize -= Number.parseFloat(tabStyles.paddingLeft) + Number.parseFloat(tabStyles.paddingRight);
              }
              offset2 += Number.parseFloat(tabStyles.paddingLeft);
            }
            return false;
          });
          return {
            [sizeName]: `${tabSize}px`,
            transform: `translate${capitalize(sizeDir)}(${offset2}px)`
          };
        };
        const update = () => barStyle.value = getBarStyle();
        watch(() => props.tabs, async () => {
          await nextTick();
          update();
        }, { immediate: true });
        useResizeObserver(barRef, () => update());
        expose({
          ref: barRef,
          update
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "barRef",
            ref: barRef,
            class: normalizeClass([unref(ns).e("active-bar"), unref(ns).is(unref(rootTabs).props.tabPosition)]),
            style: normalizeStyle(barStyle.value)
          }, null, 6);
        };
      }
    });
    var TabBar = /* @__PURE__ */ _export_sfc$1(_sfc_main$u, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tabs/src/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
    });
    const tabNavEmits = {
      tabClick: (tab, tabName, ev) => ev instanceof Event,
      tabRemove: (tab, ev) => ev instanceof Event
    };
    const COMPONENT_NAME$2 = "ElTabNav";
    const TabNav = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$2,
      props: tabNavProps,
      emits: tabNavEmits,
      setup(props, {
        expose,
        emit: emit2
      }) {
        const vm = getCurrentInstance();
        const rootTabs = inject(tabsRootContextKey);
        if (!rootTabs)
          throwError(COMPONENT_NAME$2, `<el-tabs><tab-nav /></el-tabs>`);
        const ns = useNamespace("tabs");
        const visibility = useDocumentVisibility();
        const focused = useWindowFocus();
        const navScroll$ = ref();
        const nav$ = ref();
        const el$ = ref();
        const tabBarRef = ref();
        const scrollable = ref(false);
        const navOffset = ref(0);
        const isFocus = ref(false);
        const focusable = ref(true);
        const sizeName = computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height");
        const navStyle = computed(() => {
          const dir = sizeName.value === "width" ? "X" : "Y";
          return {
            transform: `translate${dir}(-${navOffset.value}px)`
          };
        });
        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 navSize = nav$.value[`offset${capitalize(sizeName.value)}`];
          const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
          const currentOffset = navOffset.value;
          if (navSize - currentOffset <= containerSize)
            return;
          const newOffset = navSize - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize - containerSize;
          navOffset.value = newOffset;
        };
        const scrollToActiveTab = async () => {
          const nav = nav$.value;
          if (!scrollable.value || !el$.value || !navScroll$.value || !nav)
            return;
          await nextTick();
          const activeTab = el$.value.querySelector(".is-active");
          if (!activeTab)
            return;
          const navScroll = navScroll$.value;
          const isHorizontal2 = ["top", "bottom"].includes(rootTabs.props.tabPosition);
          const activeTabBounding = activeTab.getBoundingClientRect();
          const navScrollBounding = navScroll.getBoundingClientRect();
          const maxOffset = isHorizontal2 ? nav.offsetWidth - navScrollBounding.width : nav.offsetHeight - navScrollBounding.height;
          const currentOffset = navOffset.value;
          let newOffset = currentOffset;
          if (isHorizontal2) {
            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 _a2;
          if (!nav$.value || !navScroll$.value)
            return;
          props.stretch && ((_a2 = tabBarRef.value) == null ? void 0 : _a2.update());
          const navSize = nav$.value[`offset${capitalize(sizeName.value)}`];
          const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
          const currentOffset = navOffset.value;
          if (containerSize < navSize) {
            scrollable.value = scrollable.value || {};
            scrollable.value.prev = currentOffset;
            scrollable.value.next = currentOffset + containerSize < navSize;
            if (navSize - currentOffset < containerSize) {
              navOffset.value = navSize - containerSize;
            }
          } else {
            scrollable.value = false;
            if (currentOffset > 0) {
              navOffset.value = 0;
            }
          }
        };
        const changeTab = (e) => {
          const code = e.code;
          const {
            up: up2,
            down: down2,
            left: left2,
            right: right2
          } = EVENT_CODE;
          if (![up2, down2, left2, right2].includes(code))
            return;
          const tabList = Array.from(e.currentTarget.querySelectorAll("[role=tab]:not(.is-disabled)"));
          const currentIndex = tabList.indexOf(e.target);
          let nextIndex;
          if (code === left2 || code === up2) {
            if (currentIndex === 0) {
              nextIndex = tabList.length - 1;
            } else {
              nextIndex = currentIndex - 1;
            }
          } else {
            if (currentIndex < tabList.length - 1) {
              nextIndex = currentIndex + 1;
            } else {
              nextIndex = 0;
            }
          }
          tabList[nextIndex].focus({
            preventScroll: true
          });
          tabList[nextIndex].click();
          setFocus();
        };
        const setFocus = () => {
          if (focusable.value)
            isFocus.value = true;
        };
        const removeFocus = () => isFocus.value = false;
        watch(visibility, (visibility2) => {
          if (visibility2 === "hidden") {
            focusable.value = false;
          } else if (visibility2 === "visible") {
            setTimeout(() => focusable.value = true, 50);
          }
        });
        watch(focused, (focused2) => {
          if (focused2) {
            setTimeout(() => focusable.value = true, 50);
          } else {
            focusable.value = false;
          }
        });
        useResizeObserver(el$, update);
        onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
        onUpdated(() => update());
        expose({
          scrollToActiveTab,
          removeFocus
        });
        watch(() => props.panes, () => vm.update(), {
          flush: "post",
          deep: true
        });
        return () => {
          const scrollBtn = scrollable.value ? [createVNode("span", {
            "class": [ns.e("nav-prev"), ns.is("disabled", !scrollable.value.prev)],
            "onClick": scrollPrev
          }, [createVNode(ElIcon, null, {
            default: () => [createVNode(arrow_left_default, null, null)]
          })]), createVNode("span", {
            "class": [ns.e("nav-next"), ns.is("disabled", !scrollable.value.next)],
            "onClick": scrollNext
          }, [createVNode(ElIcon, null, {
            default: () => [createVNode(arrow_right_default, null, null)]
          })])] : null;
          const tabs = props.panes.map((pane, index2) => {
            var _a2, _b, _c, _d;
            const uid2 = pane.uid;
            const disabled = pane.props.disabled;
            const tabName = (_b = (_a2 = pane.props.name) != null ? _a2 : pane.index) != null ? _b : `${index2}`;
            const closable = !disabled && (pane.isClosable || props.editable);
            pane.index = `${index2}`;
            const btnClose = closable ? createVNode(ElIcon, {
              "class": "is-icon-close",
              "onClick": (ev) => emit2("tabRemove", pane, ev)
            }, {
              default: () => [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 ? 0 : -1;
            return createVNode("div", {
              "ref": `tab-${uid2}`,
              "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-${uid2}`,
              "aria-controls": `pane-${tabName}`,
              "role": "tab",
              "aria-selected": pane.active,
              "tabindex": tabindex,
              "onFocus": () => setFocus(),
              "onBlur": () => removeFocus(),
              "onClick": (ev) => {
                removeFocus();
                emit2("tabClick", pane, tabName, ev);
              },
              "onKeydown": (ev) => {
                if (closable && (ev.code === EVENT_CODE.delete || ev.code === EVENT_CODE.backspace)) {
                  emit2("tabRemove", pane, ev);
                }
              }
            }, [...[tabLabelContent, btnClose]]);
          });
          return createVNode("div", {
            "ref": el$,
            "class": [ns.e("nav-wrap"), ns.is("scrollable", !!scrollable.value), ns.is(rootTabs.props.tabPosition)]
          }, [scrollBtn, createVNode("div", {
            "class": ns.e("nav-scroll"),
            "ref": navScroll$
          }, [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
          }, [...[!props.type ? createVNode(TabBar, {
            "ref": tabBarRef,
            "tabs": [...props.panes]
          }, null) : null, tabs]])])]);
        };
      }
    });
    const tabsProps = buildProps({
      type: {
        type: String,
        values: ["card", "border-card", ""],
        default: ""
      },
      activeName: {
        type: [String, Number]
      },
      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
    });
    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 = /* @__PURE__ */ defineComponent({
      name: "ElTabs",
      props: tabsProps,
      emits: tabsEmits,
      setup(props, {
        emit: emit2,
        slots,
        expose
      }) {
        var _a2, _b;
        const ns = useNamespace("tabs");
        const {
          children: panes,
          addChild: registerPane,
          removeChild: unregisterPane
        } = useOrderedChildren(getCurrentInstance(), "ElTabPane");
        const nav$ = ref();
        const currentName = ref((_b = (_a2 = props.modelValue) != null ? _a2 : props.activeName) != null ? _b : "0");
        const setCurrentName = async (value, trigger2 = false) => {
          var _a22, _b2, _c;
          if (currentName.value === value || isUndefined(value))
            return;
          try {
            const canLeave = await ((_a22 = props.beforeLeave) == null ? void 0 : _a22.call(props, value, currentName.value));
            if (canLeave !== false) {
              currentName.value = value;
              if (trigger2) {
                emit2(UPDATE_MODEL_EVENT, value);
                emit2("tabChange", value);
              }
              (_c = (_b2 = nav$.value) == null ? void 0 : _b2.removeFocus) == null ? void 0 : _c.call(_b2);
            }
          } catch (e) {
          }
        };
        const handleTabClick = (tab, tabName, event) => {
          if (tab.props.disabled)
            return;
          setCurrentName(tabName, true);
          emit2("tabClick", tab, event);
        };
        const handleTabRemove = (pane, ev) => {
          if (pane.props.disabled || isUndefined(pane.props.name))
            return;
          ev.stopPropagation();
          emit2("edit", pane.props.name, "remove");
          emit2("tabRemove", pane.props.name);
        };
        const handleTabAdd = () => {
          emit2("edit", void 0, "add");
          emit2("tabAdd");
        };
        useDeprecated({
          from: '"activeName"',
          replacement: '"model-value" or "v-model"',
          scope: "ElTabs",
          version: "2.3.0",
          ref: "https://element-plus.org/en-US/component/tabs.html#attributes",
          type: "Attribute"
        }, computed(() => !!props.activeName));
        watch(() => props.activeName, (modelValue) => setCurrentName(modelValue));
        watch(() => props.modelValue, (modelValue) => setCurrentName(modelValue));
        watch(currentName, async () => {
          var _a22;
          await nextTick();
          (_a22 = nav$.value) == null ? void 0 : _a22.scrollToActiveTab();
        });
        provide(tabsRootContextKey, {
          props,
          currentName,
          registerPane,
          unregisterPane
        });
        expose({
          currentName
        });
        return () => {
          const addSlot = slots.addIcon;
          const newButton = props.editable || props.addable ? createVNode("span", {
            "class": ns.e("new-tab"),
            "tabindex": "0",
            "onClick": handleTabAdd,
            "onKeydown": (ev) => {
              if (ev.code === EVENT_CODE.enter)
                handleTabAdd();
            }
          }, [addSlot ? renderSlot(slots, "addIcon") : createVNode(ElIcon, {
            "class": ns.is("icon-plus")
          }, {
            default: () => [createVNode(plus_default, null, null)]
          })]) : null;
          const header = createVNode("div", {
            "class": [ns.e("header"), ns.is(props.tabPosition)]
          }, [newButton, 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 panels = createVNode("div", {
            "class": ns.e("content")
          }, [renderSlot(slots, "default")]);
          return createVNode("div", {
            "class": [ns.b(), ns.m(props.tabPosition), {
              [ns.m("card")]: props.type === "card",
              [ns.m("border-card")]: props.type === "border-card"
            }]
          }, [...props.tabPosition !== "bottom" ? [header, panels] : [panels, header]]);
        };
      }
    });
    const tabPaneProps = buildProps({
      label: {
        type: String,
        default: ""
      },
      name: {
        type: [String, Number]
      },
      closable: Boolean,
      disabled: Boolean,
      lazy: Boolean
    });
    const _hoisted_1$c = ["id", "aria-hidden", "aria-labelledby"];
    const COMPONENT_NAME$1 = "ElTabPane";
    const __default__$k = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME$1
    });
    const _sfc_main$t = /* @__PURE__ */ defineComponent({
      ...__default__$k,
      props: tabPaneProps,
      setup(__props) {
        const props = __props;
        const instance = getCurrentInstance();
        const slots = useSlots();
        const tabsRoot = inject(tabsRootContextKey);
        if (!tabsRoot)
          throwError(COMPONENT_NAME$1, "usage: <el-tabs><el-tab-pane /></el-tabs/>");
        const ns = useNamespace("tab-pane");
        const index2 = ref();
        const isClosable = computed(() => props.closable || tabsRoot.props.closable);
        const active = computedEager(() => {
          var _a2;
          return tabsRoot.currentName.value === ((_a2 = props.name) != null ? _a2 : index2.value);
        });
        const loaded = ref(active.value);
        const paneName = computed(() => {
          var _a2;
          return (_a2 = props.name) != null ? _a2 : index2.value;
        });
        const shouldBeRender = computedEager(() => !props.lazy || loaded.value || active.value);
        watch(active, (val) => {
          if (val)
            loaded.value = true;
        });
        const pane = reactive({
          uid: instance.uid,
          slots,
          props,
          paneName,
          active,
          index: index2,
          isClosable
        });
        onMounted(() => {
          tabsRoot.registerPane(pane);
        });
        onUnmounted(() => {
          tabsRoot.unregisterPane(pane.uid);
        });
        return (_ctx, _cache) => {
          return unref(shouldBeRender) ? withDirectives((openBlock(), createElementBlock("div", {
            key: 0,
            id: `pane-${unref(paneName)}`,
            class: normalizeClass(unref(ns).b()),
            role: "tabpanel",
            "aria-hidden": !unref(active),
            "aria-labelledby": `tab-${unref(paneName)}`
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 10, _hoisted_1$c)), [
            [vShow, unref(active)]
          ]) : createCommentVNode("v-if", true);
        };
      }
    });
    var TabPane = /* @__PURE__ */ _export_sfc$1(_sfc_main$t, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tabs/src/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: {
        type: Boolean
      },
      lineClamp: {
        type: [String, Number]
      },
      tag: {
        type: String,
        default: "span"
      }
    });
    const __default__$j = /* @__PURE__ */ defineComponent({
      name: "ElText"
    });
    const _sfc_main$s = /* @__PURE__ */ defineComponent({
      ...__default__$j,
      props: textProps,
      setup(__props) {
        const props = __props;
        const textSize = useFormSize();
        const ns = useNamespace("text");
        const textKls = computed(() => [
          ns.b(),
          ns.m(props.type),
          ns.m(textSize.value),
          ns.is("truncated", props.truncated),
          ns.is("line-clamp", !isUndefined(props.lineClamp))
        ]);
        return (_ctx, _cache) => {
          return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
            class: normalizeClass(unref(textKls)),
            style: normalizeStyle({ "-webkit-line-clamp": _ctx.lineClamp })
          }, {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["class", "style"]);
        };
      }
    });
    var Text = /* @__PURE__ */ _export_sfc$1(_sfc_main$s, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/text/src/text.vue"]]);
    const ElText = withInstall(Text);
    const timeSelectProps = buildProps({
      format: {
        type: String,
        default: "HH:mm"
      },
      modelValue: String,
      disabled: Boolean,
      editable: {
        type: Boolean,
        default: true
      },
      effect: {
        type: 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: String,
      maxTime: String,
      name: String,
      prefixIcon: {
        type: definePropType([String, Object]),
        default: () => clock_default
      },
      clearIcon: {
        type: definePropType([String, Object]),
        default: () => circle_close_default
      }
    });
    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__$i = /* @__PURE__ */ defineComponent({
      name: "ElTimeSelect"
    });
    const _sfc_main$r = /* @__PURE__ */ defineComponent({
      ...__default__$i,
      props: timeSelectProps,
      emits: ["change", "blur", "focus", "update:modelValue"],
      setup(__props, { expose }) {
        const props = __props;
        dayjs.extend(customParseFormat);
        const { Option: ElOption2 } = ElSelect;
        const nsInput = useNamespace("input");
        const select = ref();
        const _disabled = useFormDisabled();
        const { lang } = useLocale();
        const value = computed(() => props.modelValue);
        const start = computed(() => {
          const time = parseTime(props.start);
          return time ? formatTime(time) : null;
        });
        const end2 = computed(() => {
          const time = parseTime(props.end);
          return time ? formatTime(time) : null;
        });
        const step = computed(() => {
          const time = parseTime(props.step);
          return time ? formatTime(time) : null;
        });
        const minTime = computed(() => {
          const time = parseTime(props.minTime || "");
          return time ? formatTime(time) : null;
        });
        const maxTime = computed(() => {
          const time = parseTime(props.maxTime || "");
          return time ? formatTime(time) : null;
        });
        const items = computed(() => {
          const result = [];
          if (props.start && props.end && props.step) {
            let current = start.value;
            let currentTime;
            while (current && end2.value && compareTime(current, end2.value) <= 0) {
              currentTime = dayjs(current, "HH:mm").locale(lang.value).format(props.format);
              result.push({
                value: currentTime,
                disabled: compareTime(current, minTime.value || "-1:-1") <= 0 || compareTime(current, maxTime.value || "100:100") >= 0
              });
              current = nextTime(current, step.value);
            }
          }
          return result;
        });
        const blur = () => {
          var _a2, _b;
          (_b = (_a2 = select.value) == null ? void 0 : _a2.blur) == null ? void 0 : _b.call(_a2);
        };
        const focus = () => {
          var _a2, _b;
          (_b = (_a2 = select.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
        };
        expose({
          blur,
          focus
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(unref(ElSelect), {
            ref_key: "select",
            ref: select,
            "model-value": unref(value),
            disabled: unref(_disabled),
            clearable: _ctx.clearable,
            "clear-icon": _ctx.clearIcon,
            size: _ctx.size,
            effect: _ctx.effect,
            placeholder: _ctx.placeholder,
            "default-first-option": "",
            filterable: _ctx.editable,
            "onUpdate:modelValue": _cache[0] || (_cache[0] = (event) => _ctx.$emit("update:modelValue", event)),
            onChange: _cache[1] || (_cache[1] = (event) => _ctx.$emit("change", event)),
            onBlur: _cache[2] || (_cache[2] = (event) => _ctx.$emit("blur", event)),
            onFocus: _cache[3] || (_cache[3] = (event) => _ctx.$emit("focus", event))
          }, {
            prefix: withCtx(() => [
              _ctx.prefixIcon ? (openBlock(), createBlock(unref(ElIcon), {
                key: 0,
                class: normalizeClass(unref(nsInput).e("prefix-icon"))
              }, {
                default: withCtx(() => [
                  (openBlock(), createBlock(resolveDynamicComponent(_ctx.prefixIcon)))
                ]),
                _: 1
              }, 8, ["class"])) : createCommentVNode("v-if", true)
            ]),
            default: withCtx(() => [
              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(items), (item) => {
                return openBlock(), createBlock(unref(ElOption2), {
                  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"]);
        };
      }
    });
    var TimeSelect = /* @__PURE__ */ _export_sfc$1(_sfc_main$r, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-select/src/time-select.vue"]]);
    TimeSelect.install = (app) => {
      app.component(TimeSelect.name, TimeSelect);
    };
    const _TimeSelect = TimeSelect;
    const ElTimeSelect = _TimeSelect;
    const Timeline = /* @__PURE__ */ defineComponent({
      name: "ElTimeline",
      setup(_2, { slots }) {
        const ns = useNamespace("timeline");
        provide("timeline", slots);
        return () => {
          return h$1("ul", { class: [ns.b()] }, [renderSlot(slots, "default")]);
        };
      }
    });
    const timelineItemProps = buildProps({
      timestamp: {
        type: String,
        default: ""
      },
      hideTimestamp: {
        type: Boolean,
        default: false
      },
      center: {
        type: Boolean,
        default: false
      },
      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: {
        type: Boolean,
        default: false
      }
    });
    const __default__$h = /* @__PURE__ */ defineComponent({
      name: "ElTimelineItem"
    });
    const _sfc_main$q = /* @__PURE__ */ defineComponent({
      ...__default__$h,
      props: timelineItemProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("timeline-item");
        const defaultNodeKls = computed(() => [
          ns.e("node"),
          ns.em("node", props.size || ""),
          ns.em("node", props.type || ""),
          ns.is("hollow", props.hollow)
        ]);
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("li", {
            class: normalizeClass([unref(ns).b(), { [unref(ns).e("center")]: _ctx.center }])
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("tail"))
            }, null, 2),
            !_ctx.$slots.dot ? (openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(unref(defaultNodeKls)),
              style: normalizeStyle({
                backgroundColor: _ctx.color
              })
            }, [
              _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), {
                key: 0,
                class: normalizeClass(unref(ns).e("icon"))
              }, {
                default: withCtx(() => [
                  (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
                ]),
                _: 1
              }, 8, ["class"])) : createCommentVNode("v-if", true)
            ], 6)) : createCommentVNode("v-if", true),
            _ctx.$slots.dot ? (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(unref(ns).e("dot"))
            }, [
              renderSlot(_ctx.$slots, "dot")
            ], 2)) : createCommentVNode("v-if", true),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("wrapper"))
            }, [
              !_ctx.hideTimestamp && _ctx.placement === "top" ? (openBlock(), createElementBlock("div", {
                key: 0,
                class: normalizeClass([unref(ns).e("timestamp"), unref(ns).is("top")])
              }, toDisplayString(_ctx.timestamp), 3)) : createCommentVNode("v-if", true),
              createBaseVNode("div", {
                class: normalizeClass(unref(ns).e("content"))
              }, [
                renderSlot(_ctx.$slots, "default")
              ], 2),
              !_ctx.hideTimestamp && _ctx.placement === "bottom" ? (openBlock(), createElementBlock("div", {
                key: 1,
                class: normalizeClass([unref(ns).e("timestamp"), unref(ns).is("bottom")])
              }, toDisplayString(_ctx.timestamp), 3)) : createCommentVNode("v-if", true)
            ], 2)
          ], 2);
        };
      }
    });
    var TimelineItem = /* @__PURE__ */ _export_sfc$1(_sfc_main$q, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/timeline/src/timeline-item.vue"]]);
    const ElTimeline = withInstall(Timeline, {
      TimelineItem
    });
    const ElTimelineItem = withNoopInstall(TimelineItem);
    const tooltipV2CommonProps = buildProps({
      nowrap: Boolean
    });
    var TooltipV2Sides = /* @__PURE__ */ ((TooltipV2Sides2) => {
      TooltipV2Sides2["top"] = "top";
      TooltipV2Sides2["bottom"] = "bottom";
      TooltipV2Sides2["left"] = "left";
      TooltipV2Sides2["right"] = "right";
      return TooltipV2Sides2;
    })(TooltipV2Sides || {});
    const tooltipV2Sides = Object.values(TooltipV2Sides);
    const tooltipV2ArrowProps = buildProps({
      width: {
        type: Number,
        default: 10
      },
      height: {
        type: Number,
        default: 10
      },
      style: {
        type: definePropType(Object),
        default: null
      }
    });
    const tooltipV2ArrowSpecialProps = buildProps({
      side: {
        type: definePropType(String),
        values: tooltipV2Sides,
        required: true
      }
    });
    const tooltipV2Strategies = ["absolute", "fixed"];
    const tooltipV2Placements = [
      "top-start",
      "top-end",
      "top",
      "bottom-start",
      "bottom-end",
      "bottom",
      "left-start",
      "left-end",
      "left",
      "right-start",
      "right-end",
      "right"
    ];
    const tooltipV2ContentProps = buildProps({
      ariaLabel: String,
      arrowPadding: {
        type: definePropType(Number),
        default: 5
      },
      effect: {
        type: String,
        default: ""
      },
      contentClass: String,
      placement: {
        type: definePropType(String),
        values: tooltipV2Placements,
        default: "bottom"
      },
      reference: {
        type: definePropType(Object),
        default: null
      },
      offset: {
        type: Number,
        default: 8
      },
      strategy: {
        type: definePropType(String),
        values: tooltipV2Strategies,
        default: "absolute"
      },
      showArrow: {
        type: Boolean,
        default: false
      }
    });
    const tooltipV2RootProps = buildProps({
      delayDuration: {
        type: Number,
        default: 300
      },
      defaultOpen: Boolean,
      open: {
        type: Boolean,
        default: void 0
      },
      onOpenChange: {
        type: definePropType(Function)
      },
      "onUpdate:open": {
        type: definePropType(Function)
      }
    });
    const EventHandler = {
      type: definePropType(Function)
    };
    const tooltipV2TriggerProps = buildProps({
      onBlur: EventHandler,
      onClick: EventHandler,
      onFocus: EventHandler,
      onMouseDown: EventHandler,
      onMouseEnter: EventHandler,
      onMouseLeave: EventHandler
    });
    const tooltipV2Props = buildProps({
      ...tooltipV2RootProps,
      ...tooltipV2ArrowProps,
      ...tooltipV2TriggerProps,
      ...tooltipV2ContentProps,
      alwaysOn: Boolean,
      fullTransition: Boolean,
      transitionProps: {
        type: definePropType(Object),
        default: null
      },
      teleported: Boolean,
      to: {
        type: definePropType(String),
        default: "body"
      }
    });
    const tooltipV2RootKey = Symbol("tooltipV2");
    const tooltipV2ContentKey = Symbol("tooltipV2Content");
    const TOOLTIP_V2_OPEN = "tooltip_v2.open";
    const __default__$g = /* @__PURE__ */ defineComponent({
      name: "ElTooltipV2Root"
    });
    const _sfc_main$p = /* @__PURE__ */ defineComponent({
      ...__default__$g,
      props: tooltipV2RootProps,
      setup(__props, { expose }) {
        const props = __props;
        const _open = ref(props.defaultOpen);
        const triggerRef2 = ref(null);
        const open = computed({
          get: () => isPropAbsent(props.open) ? _open.value : props.open,
          set: (open2) => {
            var _a2;
            _open.value = open2;
            (_a2 = props["onUpdate:open"]) == null ? void 0 : _a2.call(props, open2);
          }
        });
        const isOpenDelayed = computed(() => isNumber(props.delayDuration) && props.delayDuration > 0);
        const { start: onDelayedOpen, stop: clearTimer } = useTimeoutFn(() => {
          open.value = true;
        }, computed(() => props.delayDuration), {
          immediate: false
        });
        const ns = useNamespace("tooltip-v2");
        const contentId = useId();
        const onNormalOpen = () => {
          clearTimer();
          open.value = true;
        };
        const onDelayOpen = () => {
          unref(isOpenDelayed) ? onDelayedOpen() : onNormalOpen();
        };
        const onOpen = onNormalOpen;
        const onClose = () => {
          clearTimer();
          open.value = false;
        };
        const onChange = (open2) => {
          var _a2;
          if (open2) {
            document.dispatchEvent(new CustomEvent(TOOLTIP_V2_OPEN));
            onOpen();
          }
          (_a2 = props.onOpenChange) == null ? void 0 : _a2.call(props, open2);
        };
        watch(open, onChange);
        onMounted(() => {
          document.addEventListener(TOOLTIP_V2_OPEN, onClose);
        });
        onBeforeUnmount(() => {
          clearTimer();
          document.removeEventListener(TOOLTIP_V2_OPEN, onClose);
        });
        provide(tooltipV2RootKey, {
          contentId,
          triggerRef: triggerRef2,
          ns,
          onClose,
          onDelayOpen,
          onOpen
        });
        expose({
          onOpen,
          onClose
        });
        return (_ctx, _cache) => {
          return renderSlot(_ctx.$slots, "default", { open: unref(open) });
        };
      }
    });
    var TooltipV2Root = /* @__PURE__ */ _export_sfc$1(_sfc_main$p, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip-v2/src/root.vue"]]);
    const __default__$f = /* @__PURE__ */ defineComponent({
      name: "ElTooltipV2Arrow"
    });
    const _sfc_main$o = /* @__PURE__ */ defineComponent({
      ...__default__$f,
      props: {
        ...tooltipV2ArrowProps,
        ...tooltipV2ArrowSpecialProps
      },
      setup(__props) {
        const props = __props;
        const { ns } = inject(tooltipV2RootKey);
        const { arrowRef } = inject(tooltipV2ContentKey);
        const arrowStyle = computed(() => {
          const { style, width, height } = props;
          const namespace = ns.namespace.value;
          return {
            [`--${namespace}-tooltip-v2-arrow-width`]: `${width}px`,
            [`--${namespace}-tooltip-v2-arrow-height`]: `${height}px`,
            [`--${namespace}-tooltip-v2-arrow-border-width`]: `${width / 2}px`,
            [`--${namespace}-tooltip-v2-arrow-cover-width`]: width / 2 - 1,
            ...style || {}
          };
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("span", {
            ref_key: "arrowRef",
            ref: arrowRef,
            style: normalizeStyle(unref(arrowStyle)),
            class: normalizeClass(unref(ns).e("arrow"))
          }, null, 6);
        };
      }
    });
    var TooltipV2Arrow = /* @__PURE__ */ _export_sfc$1(_sfc_main$o, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip-v2/src/arrow.vue"]]);
    const visualHiddenProps = buildProps({
      style: {
        type: definePropType([String, Object, Array]),
        default: () => ({})
      }
    });
    const __default__$e = /* @__PURE__ */ defineComponent({
      name: "ElVisuallyHidden"
    });
    const _sfc_main$n = /* @__PURE__ */ defineComponent({
      ...__default__$e,
      props: visualHiddenProps,
      setup(__props) {
        const props = __props;
        const computedStyle = computed(() => {
          return [
            props.style,
            {
              position: "absolute",
              border: 0,
              width: 1,
              height: 1,
              padding: 0,
              margin: -1,
              overflow: "hidden",
              clip: "rect(0, 0, 0, 0)",
              whiteSpace: "nowrap",
              wordWrap: "normal"
            }
          ];
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("span", mergeProps(_ctx.$attrs, { style: unref(computedStyle) }), [
            renderSlot(_ctx.$slots, "default")
          ], 16);
        };
      }
    });
    var ElVisuallyHidden = /* @__PURE__ */ _export_sfc$1(_sfc_main$n, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/visual-hidden/src/visual-hidden.vue"]]);
    const _hoisted_1$b = ["data-side"];
    const __default__$d = /* @__PURE__ */ defineComponent({
      name: "ElTooltipV2Content"
    });
    const _sfc_main$m = /* @__PURE__ */ defineComponent({
      ...__default__$d,
      props: { ...tooltipV2ContentProps, ...tooltipV2CommonProps },
      setup(__props) {
        const props = __props;
        const { triggerRef: triggerRef2, contentId } = inject(tooltipV2RootKey);
        const placement = ref(props.placement);
        const strategy = ref(props.strategy);
        const arrowRef = ref(null);
        const { referenceRef, contentRef, middlewareData, x: x2, y, update } = useFloating({
          placement,
          strategy,
          middleware: computed(() => {
            const middleware = [offset(props.offset)];
            if (props.showArrow) {
              middleware.push(arrowMiddleware({
                arrowRef
              }));
            }
            return middleware;
          })
        });
        const zIndex2 = useZIndex().nextZIndex();
        const ns = useNamespace("tooltip-v2");
        const side = computed(() => {
          return placement.value.split("-")[0];
        });
        const contentStyle = computed(() => {
          return {
            position: unref(strategy),
            top: `${unref(y) || 0}px`,
            left: `${unref(x2) || 0}px`,
            zIndex: zIndex2
          };
        });
        const arrowStyle = computed(() => {
          if (!props.showArrow)
            return {};
          const { arrow: arrow2 } = unref(middlewareData);
          return {
            [`--${ns.namespace.value}-tooltip-v2-arrow-x`]: `${arrow2 == null ? void 0 : arrow2.x}px` || "",
            [`--${ns.namespace.value}-tooltip-v2-arrow-y`]: `${arrow2 == null ? void 0 : arrow2.y}px` || ""
          };
        });
        const contentClass = computed(() => [
          ns.e("content"),
          ns.is("dark", props.effect === "dark"),
          ns.is(unref(strategy)),
          props.contentClass
        ]);
        watch(arrowRef, () => update());
        watch(() => props.placement, (val) => placement.value = val);
        onMounted(() => {
          watch(() => props.reference || triggerRef2.value, (el) => {
            referenceRef.value = el || void 0;
          }, {
            immediate: true
          });
        });
        provide(tooltipV2ContentKey, { arrowRef });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "contentRef",
            ref: contentRef,
            style: normalizeStyle(unref(contentStyle)),
            "data-tooltip-v2-root": ""
          }, [
            !_ctx.nowrap ? (openBlock(), createElementBlock("div", {
              key: 0,
              "data-side": unref(side),
              class: normalizeClass(unref(contentClass))
            }, [
              renderSlot(_ctx.$slots, "default", {
                contentStyle: unref(contentStyle),
                contentClass: unref(contentClass)
              }),
              createVNode(unref(ElVisuallyHidden), {
                id: unref(contentId),
                role: "tooltip"
              }, {
                default: withCtx(() => [
                  _ctx.ariaLabel ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                    createTextVNode(toDisplayString(_ctx.ariaLabel), 1)
                  ], 64)) : renderSlot(_ctx.$slots, "default", { key: 1 })
                ]),
                _: 3
              }, 8, ["id"]),
              renderSlot(_ctx.$slots, "arrow", {
                style: normalizeStyle(unref(arrowStyle)),
                side: unref(side)
              })
            ], 10, _hoisted_1$b)) : createCommentVNode("v-if", true)
          ], 4);
        };
      }
    });
    var TooltipV2Content = /* @__PURE__ */ _export_sfc$1(_sfc_main$m, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip-v2/src/content.vue"]]);
    const forwardRefProps = buildProps({
      setRef: {
        type: definePropType(Function),
        required: true
      },
      onlyChild: Boolean
    });
    var ForwardRef = /* @__PURE__ */ defineComponent({
      props: forwardRefProps,
      setup(props, {
        slots
      }) {
        const fragmentRef = ref();
        const setRef2 = composeRefs(fragmentRef, (el) => {
          if (el) {
            props.setRef(el.nextElementSibling);
          } else {
            props.setRef(null);
          }
        });
        return () => {
          var _a2;
          const [firstChild] = ((_a2 = slots.default) == null ? void 0 : _a2.call(slots)) || [];
          const child = props.onlyChild ? ensureOnlyChild(firstChild.children) : firstChild.children;
          return createVNode(Fragment, {
            "ref": setRef2
          }, [child]);
        };
      }
    });
    const __default__$c = /* @__PURE__ */ defineComponent({
      name: "ElTooltipV2Trigger"
    });
    const _sfc_main$l = /* @__PURE__ */ defineComponent({
      ...__default__$c,
      props: {
        ...tooltipV2CommonProps,
        ...tooltipV2TriggerProps
      },
      setup(__props) {
        const props = __props;
        const { onClose, onOpen, onDelayOpen, triggerRef: triggerRef2, contentId } = inject(tooltipV2RootKey);
        let isMousedown = false;
        const setTriggerRef = (el) => {
          triggerRef2.value = el;
        };
        const onMouseup = () => {
          isMousedown = false;
        };
        const onMouseenter = composeEventHandlers(props.onMouseEnter, onDelayOpen);
        const onMouseleave = composeEventHandlers(props.onMouseLeave, onClose);
        const onMousedown = composeEventHandlers(props.onMouseDown, () => {
          onClose();
          isMousedown = true;
          document.addEventListener("mouseup", onMouseup, { once: true });
        });
        const onFocus = composeEventHandlers(props.onFocus, () => {
          if (!isMousedown)
            onOpen();
        });
        const onBlur = composeEventHandlers(props.onBlur, onClose);
        const onClick = composeEventHandlers(props.onClick, (e) => {
          if (e.detail === 0)
            onClose();
        });
        const events = {
          blur: onBlur,
          click: onClick,
          focus: onFocus,
          mousedown: onMousedown,
          mouseenter: onMouseenter,
          mouseleave: onMouseleave
        };
        const setEvents = (el, events2, type2) => {
          if (el) {
            Object.entries(events2).forEach(([name, handler]) => {
              el[type2](name, handler);
            });
          }
        };
        watch(triggerRef2, (triggerEl, previousTriggerEl) => {
          setEvents(triggerEl, events, "addEventListener");
          setEvents(previousTriggerEl, events, "removeEventListener");
          if (triggerEl) {
            triggerEl.setAttribute("aria-describedby", contentId.value);
          }
        });
        onBeforeUnmount(() => {
          setEvents(triggerRef2.value, events, "removeEventListener");
          document.removeEventListener("mouseup", onMouseup);
        });
        return (_ctx, _cache) => {
          return _ctx.nowrap ? (openBlock(), createBlock(unref(ForwardRef), {
            key: 0,
            "set-ref": setTriggerRef,
            "only-child": ""
          }, {
            default: withCtx(() => [
              renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          })) : (openBlock(), createElementBlock("button", mergeProps({
            key: 1,
            ref_key: "triggerRef",
            ref: triggerRef2
          }, _ctx.$attrs), [
            renderSlot(_ctx.$slots, "default")
          ], 16));
        };
      }
    });
    var TooltipV2Trigger = /* @__PURE__ */ _export_sfc$1(_sfc_main$l, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip-v2/src/trigger.vue"]]);
    const __default__$b = /* @__PURE__ */ defineComponent({
      name: "ElTooltipV2"
    });
    const _sfc_main$k = /* @__PURE__ */ defineComponent({
      ...__default__$b,
      props: tooltipV2Props,
      setup(__props) {
        const props = __props;
        const refedProps = toRefs(props);
        const arrowProps = reactive(pick$1(refedProps, Object.keys(tooltipV2ArrowProps)));
        const contentProps = reactive(pick$1(refedProps, Object.keys(tooltipV2ContentProps)));
        const rootProps = reactive(pick$1(refedProps, Object.keys(tooltipV2RootProps)));
        const triggerProps = reactive(pick$1(refedProps, Object.keys(tooltipV2TriggerProps)));
        return (_ctx, _cache) => {
          return openBlock(), createBlock(TooltipV2Root, normalizeProps(guardReactiveProps(rootProps)), {
            default: withCtx(({ open }) => [
              createVNode(TooltipV2Trigger, mergeProps(triggerProps, { nowrap: "" }), {
                default: withCtx(() => [
                  renderSlot(_ctx.$slots, "trigger")
                ]),
                _: 3
              }, 16),
              (openBlock(), createBlock(Teleport, {
                to: _ctx.to,
                disabled: !_ctx.teleported
              }, [
                _ctx.fullTransition ? (openBlock(), createBlock(Transition, normalizeProps(mergeProps({ key: 0 }, _ctx.transitionProps)), {
                  default: withCtx(() => [
                    _ctx.alwaysOn || open ? (openBlock(), createBlock(TooltipV2Content, normalizeProps(mergeProps({ key: 0 }, contentProps)), {
                      arrow: withCtx(({ style, side }) => [
                        _ctx.showArrow ? (openBlock(), createBlock(TooltipV2Arrow, mergeProps({ key: 0 }, arrowProps, {
                          style,
                          side
                        }), null, 16, ["style", "side"])) : createCommentVNode("v-if", true)
                      ]),
                      default: withCtx(() => [
                        renderSlot(_ctx.$slots, "default")
                      ]),
                      _: 3
                    }, 16)) : createCommentVNode("v-if", true)
                  ]),
                  _: 2
                }, 1040)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
                  _ctx.alwaysOn || open ? (openBlock(), createBlock(TooltipV2Content, normalizeProps(mergeProps({ key: 0 }, contentProps)), {
                    arrow: withCtx(({ style, side }) => [
                      _ctx.showArrow ? (openBlock(), createBlock(TooltipV2Arrow, mergeProps({ key: 0 }, arrowProps, {
                        style,
                        side
                      }), null, 16, ["style", "side"])) : createCommentVNode("v-if", true)
                    ]),
                    default: withCtx(() => [
                      renderSlot(_ctx.$slots, "default")
                    ]),
                    _: 3
                  }, 16)) : createCommentVNode("v-if", true)
                ], 64))
              ], 8, ["to", "disabled"]))
            ]),
            _: 3
          }, 16);
        };
      }
    });
    var TooltipV2 = /* @__PURE__ */ _export_sfc$1(_sfc_main$k, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip-v2/src/tooltip.vue"]]);
    const ElTooltipV2 = withInstall(TooltipV2);
    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$3) || isArray$3(value) && isNil(movedKeys);
    const transferEmits = {
      [CHANGE_EVENT]: (value, direction2, movedKeys) => [value, movedKeys].every(isArray$3) && ["left", "right"].includes(direction2),
      [UPDATE_MODEL_EVENT]: (value) => isArray$3(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 initProps2 = {
        label: "label",
        key: "key",
        disabled: "disabled"
      };
      return computed(() => ({
        ...initProps2,
        ...props.props
      }));
    };
    const useCheck$1 = (props, panelState, emit2) => {
      const propsAlias = usePropsAlias(props);
      const filteredData = computed(() => {
        return props.data.filter((item) => {
          if (isFunction$2(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 = computed(() => filteredData.value.filter((item) => !item[propsAlias.value.disabled]));
      const checkedSummary = 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 = 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]) : [];
      };
      watch(() => panelState.checked, (val, oldVal) => {
        updateAllChecked();
        if (panelState.checkChangeByUser) {
          const movedKeys = val.concat(oldVal).filter((v2) => !val.includes(v2) || !oldVal.includes(v2));
          emit2(CHECKED_CHANGE_EVENT, val, movedKeys);
        } else {
          emit2(CHECKED_CHANGE_EVENT, val);
          panelState.checkChangeByUser = true;
        }
      });
      watch(checkableData, () => {
        updateAllChecked();
      });
      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;
      });
      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, emit2) => {
      const onSourceCheckedChange = (val, movedKeys) => {
        checkedState.leftChecked = val;
        if (!movedKeys)
          return;
        emit2(LEFT_CHECK_CHANGE_EVENT, val, movedKeys);
      };
      const onTargetCheckedChange = (val, movedKeys) => {
        checkedState.rightChecked = val;
        if (!movedKeys)
          return;
        emit2(RIGHT_CHECK_CHANGE_EVENT, val, movedKeys);
      };
      return {
        onSourceCheckedChange,
        onTargetCheckedChange
      };
    };
    const useComputedData = (props) => {
      const propsAlias = usePropsAlias(props);
      const dataObj = computed(() => props.data.reduce((o2, cur) => (o2[cur[propsAlias.value.key]] = cur) && o2, {}));
      const sourceData = computed(() => props.data.filter((item) => !props.modelValue.includes(item[propsAlias.value.key])));
      const targetData = 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, emit2) => {
      const propsAlias = usePropsAlias(props);
      const _emit = (value, direction2, movedKeys) => {
        emit2(UPDATE_MODEL_EVENT, value);
        emit2(CHANGE_EVENT, value, direction2, movedKeys);
      };
      const addToLeft = () => {
        const currentValue = props.modelValue.slice();
        checkedState.rightChecked.forEach((item) => {
          const index2 = currentValue.indexOf(item);
          if (index2 > -1) {
            currentValue.splice(index2, 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__$a = /* @__PURE__ */ defineComponent({
      name: "ElTransferPanel"
    });
    const _sfc_main$j = /* @__PURE__ */ defineComponent({
      ...__default__$a,
      props: transferPanelProps,
      emits: transferPanelEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const slots = useSlots();
        const OptionContent = ({ option }) => option;
        const { t } = useLocale();
        const ns = useNamespace("transfer");
        const panelState = reactive({
          checked: [],
          allChecked: false,
          query: "",
          checkChangeByUser: true
        });
        const propsAlias = usePropsAlias(props);
        const {
          filteredData,
          checkedSummary,
          isIndeterminate,
          handleAllCheckedChange
        } = useCheck$1(props, panelState, emit2);
        const hasNoMatch = computed(() => !isEmpty(panelState.query) && isEmpty(filteredData.value));
        const hasFooter = computed(() => !isEmpty(slots.default()[0].children));
        const { checked, allChecked, query } = toRefs(panelState);
        expose({
          query
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(ns).b("panel"))
          }, [
            createBaseVNode("p", {
              class: normalizeClass(unref(ns).be("panel", "header"))
            }, [
              createVNode(unref(ElCheckbox), {
                modelValue: unref(allChecked),
                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(allChecked) ? allChecked.value = $event : null),
                indeterminate: unref(isIndeterminate),
                "validate-event": false,
                onChange: unref(handleAllCheckedChange)
              }, {
                default: withCtx(() => [
                  createTextVNode(toDisplayString(_ctx.title) + " ", 1),
                  createBaseVNode("span", null, toDisplayString(unref(checkedSummary)), 1)
                ]),
                _: 1
              }, 8, ["modelValue", "indeterminate", "onChange"])
            ], 2),
            createBaseVNode("div", {
              class: normalizeClass([unref(ns).be("panel", "body"), unref(ns).is("with-footer", unref(hasFooter))])
            }, [
              _ctx.filterable ? (openBlock(), createBlock(unref(ElInput), {
                key: 0,
                modelValue: unref(query),
                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(query) ? query.value = $event : null),
                class: normalizeClass(unref(ns).be("panel", "filter")),
                size: "default",
                placeholder: _ctx.placeholder,
                "prefix-icon": unref(search_default),
                clearable: "",
                "validate-event": false
              }, null, 8, ["modelValue", "class", "placeholder", "prefix-icon"])) : createCommentVNode("v-if", true),
              withDirectives(createVNode(unref(ElCheckboxGroup$1), {
                modelValue: unref(checked),
                "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => isRef(checked) ? checked.value = $event : null),
                "validate-event": false,
                class: normalizeClass([unref(ns).is("filterable", _ctx.filterable), unref(ns).be("panel", "list")])
              }, {
                default: withCtx(() => [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(filteredData), (item) => {
                    return openBlock(), createBlock(unref(ElCheckbox), {
                      key: item[unref(propsAlias).key],
                      class: normalizeClass(unref(ns).be("panel", "item")),
                      label: item[unref(propsAlias).key],
                      disabled: item[unref(propsAlias).disabled],
                      "validate-event": false
                    }, {
                      default: withCtx(() => {
                        var _a2;
                        return [
                          createVNode(OptionContent, {
                            option: (_a2 = _ctx.optionRender) == null ? void 0 : _a2.call(_ctx, item)
                          }, null, 8, ["option"])
                        ];
                      }),
                      _: 2
                    }, 1032, ["class", "label", "disabled"]);
                  }), 128))
                ]),
                _: 1
              }, 8, ["modelValue", "class"]), [
                [vShow, !unref(hasNoMatch) && !unref(isEmpty)(_ctx.data)]
              ]),
              withDirectives(createBaseVNode("p", {
                class: normalizeClass(unref(ns).be("panel", "empty"))
              }, toDisplayString(unref(hasNoMatch) ? unref(t)("el.transfer.noMatch") : unref(t)("el.transfer.noData")), 3), [
                [vShow, unref(hasNoMatch) || unref(isEmpty)(_ctx.data)]
              ])
            ], 2),
            unref(hasFooter) ? (openBlock(), createElementBlock("p", {
              key: 0,
              class: normalizeClass(unref(ns).be("panel", "footer"))
            }, [
              renderSlot(_ctx.$slots, "default")
            ], 2)) : createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var TransferPanel = /* @__PURE__ */ _export_sfc$1(_sfc_main$j, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/transfer/src/transfer-panel.vue"]]);
    const _hoisted_1$a = { key: 0 };
    const _hoisted_2$7 = { key: 0 };
    const __default__$9 = /* @__PURE__ */ defineComponent({
      name: "ElTransfer"
    });
    const _sfc_main$i = /* @__PURE__ */ defineComponent({
      ...__default__$9,
      props: transferProps,
      emits: transferEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const slots = useSlots();
        const { t } = useLocale();
        const ns = useNamespace("transfer");
        const { formItem } = useFormItem();
        const checkedState = reactive({
          leftChecked: [],
          rightChecked: []
        });
        const propsAlias = usePropsAlias(props);
        const { sourceData, targetData } = useComputedData(props);
        const { onSourceCheckedChange, onTargetCheckedChange } = useCheckedChange(checkedState, emit2);
        const { addToLeft, addToRight } = useMove(props, checkedState, emit2);
        const leftPanel = ref();
        const rightPanel = ref();
        const clearQuery = (which) => {
          switch (which) {
            case "left":
              leftPanel.value.query = "";
              break;
            case "right":
              rightPanel.value.query = "";
              break;
          }
        };
        const hasButtonTexts = computed(() => props.buttonTexts.length === 2);
        const leftPanelTitle = computed(() => props.titles[0] || t("el.transfer.titles.0"));
        const rightPanelTitle = computed(() => props.titles[1] || t("el.transfer.titles.1"));
        const panelFilterPlaceholder = computed(() => props.filterPlaceholder || t("el.transfer.filterPlaceholder"));
        watch(() => props.modelValue, () => {
          var _a2;
          if (props.validateEvent) {
            (_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn());
          }
        });
        const optionRender = computed(() => (option) => {
          if (props.renderContent)
            return props.renderContent(h$1, option);
          if (slots.default)
            return slots.default({ option });
          return h$1("span", option[propsAlias.value.label] || option[propsAlias.value.key]);
        });
        expose({
          clearQuery,
          leftPanel,
          rightPanel
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass(unref(ns).b())
          }, [
            createVNode(TransferPanel, {
              ref_key: "leftPanel",
              ref: leftPanel,
              data: unref(sourceData),
              "option-render": unref(optionRender),
              placeholder: unref(panelFilterPlaceholder),
              title: unref(leftPanelTitle),
              filterable: _ctx.filterable,
              format: _ctx.format,
              "filter-method": _ctx.filterMethod,
              "default-checked": _ctx.leftDefaultChecked,
              props: props.props,
              onCheckedChange: unref(onSourceCheckedChange)
            }, {
              default: withCtx(() => [
                renderSlot(_ctx.$slots, "left-footer")
              ]),
              _: 3
            }, 8, ["data", "option-render", "placeholder", "title", "filterable", "format", "filter-method", "default-checked", "props", "onCheckedChange"]),
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).e("buttons"))
            }, [
              createVNode(unref(ElButton), {
                type: "primary",
                class: normalizeClass([unref(ns).e("button"), unref(ns).is("with-texts", unref(hasButtonTexts))]),
                disabled: unref(isEmpty)(checkedState.rightChecked),
                onClick: unref(addToLeft)
              }, {
                default: withCtx(() => [
                  createVNode(unref(ElIcon), null, {
                    default: withCtx(() => [
                      createVNode(unref(arrow_left_default))
                    ]),
                    _: 1
                  }),
                  !unref(isUndefined)(_ctx.buttonTexts[0]) ? (openBlock(), createElementBlock("span", _hoisted_1$a, toDisplayString(_ctx.buttonTexts[0]), 1)) : createCommentVNode("v-if", true)
                ]),
                _: 1
              }, 8, ["class", "disabled", "onClick"]),
              createVNode(unref(ElButton), {
                type: "primary",
                class: normalizeClass([unref(ns).e("button"), unref(ns).is("with-texts", unref(hasButtonTexts))]),
                disabled: unref(isEmpty)(checkedState.leftChecked),
                onClick: unref(addToRight)
              }, {
                default: withCtx(() => [
                  !unref(isUndefined)(_ctx.buttonTexts[1]) ? (openBlock(), createElementBlock("span", _hoisted_2$7, toDisplayString(_ctx.buttonTexts[1]), 1)) : createCommentVNode("v-if", true),
                  createVNode(unref(ElIcon), null, {
                    default: withCtx(() => [
                      createVNode(unref(arrow_right_default))
                    ]),
                    _: 1
                  })
                ]),
                _: 1
              }, 8, ["class", "disabled", "onClick"])
            ], 2),
            createVNode(TransferPanel, {
              ref_key: "rightPanel",
              ref: rightPanel,
              data: unref(targetData),
              "option-render": unref(optionRender),
              placeholder: unref(panelFilterPlaceholder),
              filterable: _ctx.filterable,
              format: _ctx.format,
              "filter-method": _ctx.filterMethod,
              title: unref(rightPanelTitle),
              "default-checked": _ctx.rightDefaultChecked,
              props: props.props,
              onCheckedChange: unref(onTargetCheckedChange)
            }, {
              default: withCtx(() => [
                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$1(_sfc_main$i, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/transfer/src/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 = function(key, data) {
      if (!key)
        return data[NODE_KEY];
      return data[key];
    };
    const handleCurrentChange = (store, emit2, setCurrent) => {
      const preCurrentNode = store.value.currentNode;
      setCurrent();
      const currentNode = store.value.currentNode;
      if (preCurrentNode === currentNode)
        return;
      emit2("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 (typeof config === "function") {
        return config(data, node);
      } else if (typeof config === "string") {
        return data[config];
      } else if (typeof config === "undefined") {
        const dataProp = data[prop];
        return dataProp === void 0 ? "" : dataProp;
      }
    };
    let nodeIdSeed = 0;
    let Node$1 = class Node2 {
      constructor(options) {
        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() {
        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 isLeaf2 = getPropertyFromData(this, "isLeaf");
          if (typeof isLeaf2 === "boolean") {
            this.isLeafByUser = isLeaf2;
          }
        }
        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.expand();
        }
        if (!Array.isArray(this.data)) {
          markNodeData(this, this.data);
        }
        if (!this.data)
          return;
        const defaultExpandedKeys = store.defaultExpandedKeys;
        const key = store.key;
        if (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.parent && (this.level === 1 || this.parent.expanded === true))
          this.canFocus = true;
      }
      setData(data) {
        if (!Array.isArray(data)) {
          markNodeData(this, data);
        }
        this.data = data;
        this.childNodes = [];
        let children;
        if (this.level === 0 && Array.isArray(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 index2 = parent.childNodes.indexOf(this);
          if (index2 > -1) {
            return parent.childNodes[index2 + 1];
          }
        }
        return null;
      }
      get previousSibling() {
        const parent = this.parent;
        if (parent) {
          const index2 = parent.childNodes.indexOf(this);
          if (index2 > -1) {
            return index2 > 0 ? parent.childNodes[index2 - 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, index2, batch) {
        if (!child)
          throw new Error("InsertChild error: child is required.");
        if (!(child instanceof Node2)) {
          if (!batch) {
            const children = this.getChildren(true);
            if (!children.includes(child.data)) {
              if (typeof index2 === "undefined" || index2 < 0) {
                children.push(child.data);
              } else {
                children.splice(index2, 0, child.data);
              }
            }
          }
          Object.assign(child, {
            parent: this,
            store: this.store
          });
          child = reactive(new Node2(child));
          if (child instanceof Node2) {
            child.initialize();
          }
        }
        child.level = this.level + 1;
        if (typeof index2 === "undefined" || index2 < 0) {
          this.childNodes.push(child);
        } else {
          this.childNodes.splice(index2, 0, child);
        }
        this.updateLeafState();
      }
      insertBefore(child, ref2) {
        let index2;
        if (ref2) {
          index2 = this.childNodes.indexOf(ref2);
        }
        this.insertChild(child, index2);
      }
      insertAfter(child, ref2) {
        let index2;
        if (ref2) {
          index2 = this.childNodes.indexOf(ref2);
          if (index2 !== -1)
            index2 += 1;
        }
        this.insertChild(child, index2);
      }
      removeChild(child) {
        const children = this.getChildren() || [];
        const dataIndex = children.indexOf(child.data);
        if (dataIndex > -1) {
          children.splice(dataIndex, 1);
        }
        const index2 = this.childNodes.indexOf(child);
        if (index2 > -1) {
          this.store && this.store.deregisterNode(child);
          child.parent = null;
          this.childNodes.splice(index2, 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.level > 0) {
              parent.expanded = true;
              parent = parent.parent;
            }
          }
          this.expanded = true;
          if (callback)
            callback();
          this.childNodes.forEach((item) => {
            item.canFocus = true;
          });
        };
        if (this.shouldLoadData()) {
          this.loadData((data) => {
            if (Array.isArray(data)) {
              if (this.checked) {
                this.setChecked(true, true);
              } else if (!this.store.checkStrictly) {
                reInitChecked(this);
              }
              done();
            }
          });
        } else {
          done();
        }
      }
      doCreateChildren(array2, defaultProps2 = {}) {
        array2.forEach((item) => {
          this.insertChild(Object.assign({ data: item }, defaultProps2), void 0, true);
        });
      }
      collapse() {
        this.expanded = false;
        this.childNodes.forEach((item) => {
          item.canFocus = false;
        });
      }
      shouldLoadData() {
        return 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 (data[children] === void 0) {
          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, index2) => {
          const key = item[NODE_KEY];
          const isNodeExists = !!key && oldData.findIndex((data) => data[NODE_KEY] === key) >= 0;
          if (isNodeExists) {
            newDataMap[key] = { index: index2, data: item };
          } else {
            newNodes.push({ index: index2, data: item });
          }
        });
        if (!this.store.lazy) {
          oldData.forEach((item) => {
            if (!newDataMap[item[NODE_KEY]])
              this.removeChildByData(item);
          });
        }
        newNodes.forEach(({ index: index2, data }) => {
          this.insertChild({ data }, index2);
        });
        this.updateLeafState();
      }
      loadData(callback, defaultProps2 = {}) {
        if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps2).length)) {
          this.loading = true;
          const resolve2 = (children) => {
            this.childNodes = [];
            this.doCreateChildren(children, defaultProps2);
            this.loaded = true;
            this.loading = false;
            this.updateLeafState();
            if (callback) {
              callback.call(this, children);
            }
          };
          this.store.load(this, resolve2);
        } else {
          if (callback) {
            callback.call(this);
          }
        }
      }
    };
    class TreeStore {
      constructor(options) {
        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$1({
          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();
          });
        } else {
          this._initDefaultCheckedNodes();
        }
      }
      filter(value) {
        const filterNodeMethod = this.filterNodeMethod;
        const lazy = this.lazy;
        const traverse2 = function(node) {
          const childNodes = node.root ? node.root.childNodes : node.childNodes;
          childNodes.forEach((child) => {
            child.visible = filterNodeMethod.call(child, value, child.data, child);
            traverse2(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 && !lazy)
            node.expand();
        };
        traverse2(this);
      }
      setData(newVal) {
        const instanceChanged = newVal !== this.root.data;
        if (instanceChanged) {
          this.root.setData(newVal);
          this._initDefaultCheckedNodes();
        } else {
          this.root.updateChildren();
        }
      }
      getNode(data) {
        if (data instanceof Node$1)
          return data;
        const key = isObject$1(data) ? getNodeKey(this.key, data) : data;
        return this.nodesMap[key] || null;
      }
      insertBefore(data, refData) {
        const refNode = this.getNode(refData);
        refNode.parent.insertBefore({ data }, refNode);
      }
      insertAfter(data, refData) {
        const refNode = this.getNode(refData);
        refNode.parent.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 = 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 (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 (nodeKey !== void 0)
            this.nodesMap[node.key] = 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 traverse2 = 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);
            }
            traverse2(child);
          });
        };
        traverse2(this);
        return checkedNodes;
      }
      getCheckedKeys(leafOnly = false) {
        return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
      }
      getHalfCheckedNodes() {
        const nodes = [];
        const traverse2 = function(node) {
          const childNodes = node.root ? node.root.childNodes : node.childNodes;
          childNodes.forEach((child) => {
            if (child.indeterminate) {
              nodes.push(child.data);
            }
            traverse2(child);
          });
        };
        traverse2(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((a2, b2) => b2.level - a2.level);
        const cache2 = /* @__PURE__ */ Object.create(null);
        const keys2 = Object.keys(checkedKeys);
        allNodes.forEach((node) => node.setChecked(false, false));
        for (let i = 0, j = allNodes.length; i < j; i++) {
          const node = allNodes[i];
          const nodeKey = node.data[key].toString();
          const checked = keys2.includes(nodeKey);
          if (!checked) {
            if (node.checked && !cache2[nodeKey]) {
              node.setChecked(false, false);
            }
            continue;
          }
          let parent = node.parent;
          while (parent && parent.level > 0) {
            cache2[parent.data[key]] = true;
            parent = parent.parent;
          }
          if (node.isLeaf || this.checkStrictly) {
            node.setChecked(true, false);
            continue;
          }
          node.setChecked(true, true);
          if (leafOnly) {
            node.setChecked(false, false);
            const traverse2 = function(node2) {
              const childNodes = node2.childNodes;
              childNodes.forEach((child) => {
                if (!child.isLeaf) {
                  child.setChecked(false, false);
                }
                traverse2(child);
              });
            };
            traverse2(node);
          }
        }
      }
      setCheckedNodes(array2, leafOnly = false) {
        const key = this.key;
        const checkedKeys = {};
        array2.forEach((item) => {
          checkedKeys[(item || {})[key]] = true;
        });
        this._setCheckedKeys(key, leafOnly, checkedKeys);
      }
      setCheckedKeys(keys2, leafOnly = false) {
        this.defaultCheckedKeys = keys2;
        const key = this.key;
        const checkedKeys = {};
        keys2.forEach((key2) => {
          checkedKeys[key2] = true;
        });
        this._setCheckedKeys(key, leafOnly, checkedKeys);
      }
      setDefaultExpandedKeys(keys2) {
        keys2 = keys2 || [];
        this.defaultExpandedKeys = keys2;
        keys2.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) {
        const key = node[this.key];
        const currNode = this.nodesMap[key];
        this.setCurrentNode(currNode);
        if (shouldAutoExpandParent && this.currentNode.level > 1) {
          this.currentNode.parent.expand(null, true);
        }
      }
      setCurrentNodeKey(key, shouldAutoExpandParent = true) {
        if (key === null || key === void 0) {
          this.currentNode && (this.currentNode.isCurrent = false);
          this.currentNode = null;
          return;
        }
        const node = this.getNode(key);
        if (node) {
          this.setCurrentNode(node);
          if (shouldAutoExpandParent && this.currentNode.level > 1) {
            this.currentNode.parent.expand(null, true);
          }
        }
      }
    }
    const _sfc_main$h = /* @__PURE__ */ defineComponent({
      name: "ElTreeNodeContent",
      props: {
        node: {
          type: Object,
          required: true
        },
        renderContent: Function
      },
      setup(props) {
        const ns = useNamespace("tree");
        const nodeInstance = inject("NodeInstance");
        const tree = inject("RootTree");
        return () => {
          const node = props.node;
          const { data, store } = node;
          return props.renderContent ? props.renderContent(h$1, { _self: nodeInstance, node, data, store }) : renderSlot(tree.ctx.slots, "default", { node, data }, () => [
            h$1("span", { class: ns.be("node", "label") }, [node.label])
          ]);
        };
      }
    });
    var NodeContent = /* @__PURE__ */ _export_sfc$1(_sfc_main$h, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node-content.vue"]]);
    function useNodeExpandEventBroadcast(props) {
      const parentNodeMap = inject("TreeNodeMap", null);
      const currentNodeMap = {
        treeNodeExpand: (node) => {
          if (props.node !== node) {
            props.node.collapse();
          }
        },
        children: []
      };
      if (parentNodeMap) {
        parentNodeMap.children.push(currentNodeMap);
      }
      provide("TreeNodeMap", 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 = ref({
        showDropIndicator: false,
        draggingNode: null,
        dropNode: null,
        allowDrop: true,
        dropType: null
      });
      const treeNodeDragStart = ({ event, treeNode }) => {
        if (typeof props.allowDrag === "function" && !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 }) => {
        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 (typeof props.allowDrop === "function") {
          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;
        }
        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 targetPosition = dropNode.$el.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
        const treePosition = el$.value.getBoundingClientRect();
        let dropType;
        const prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : -1;
        const nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : 1;
        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 = dropNode.$el.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
        const dropIndicator = dropIndicator$.value;
        if (dropType === "before") {
          indicatorTop = iconPosition.top - treePosition.top;
        } else if (dropType === "after") {
          indicatorTop = iconPosition.bottom - treePosition.top;
        }
        dropIndicator.style.top = `${indicatorTop}px`;
        dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
        if (dropType === "inner") {
          addClass(dropNode.$el, ns.is("drop-inner"));
        } else {
          removeClass(dropNode.$el, 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) => {
        const { draggingNode, dropType, dropNode } = dragState.value;
        event.preventDefault();
        event.dataTransfer.dropEffect = "move";
        if (draggingNode && dropNode) {
          const draggingNodeCopy = { data: draggingNode.node.data };
          if (dropType !== "none") {
            draggingNode.node.remove();
          }
          if (dropType === "before") {
            dropNode.node.parent.insertBefore(draggingNodeCopy, dropNode.node);
          } else if (dropType === "after") {
            dropNode.node.parent.insertAfter(draggingNodeCopy, dropNode.node);
          } else if (dropType === "inner") {
            dropNode.node.insertChild(draggingNodeCopy);
          }
          if (dropType !== "none") {
            store.value.registerNode(draggingNodeCopy);
          }
          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;
      };
      provide(dragEventsKey, {
        treeNodeDragStart,
        treeNodeDragOver,
        treeNodeDragEnd
      });
      return {
        dragState
      };
    }
    const _sfc_main$g = /* @__PURE__ */ defineComponent({
      name: "ElTreeNode",
      components: {
        ElCollapseTransition: _CollapseTransition,
        ElCheckbox,
        NodeContent,
        ElIcon,
        Loading: loading_default
      },
      props: {
        node: {
          type: Node$1,
          default: () => ({})
        },
        props: {
          type: Object,
          default: () => ({})
        },
        accordion: Boolean,
        renderContent: Function,
        renderAfterExpand: Boolean,
        showCheckbox: {
          type: Boolean,
          default: false
        }
      },
      emits: ["node-expand"],
      setup(props, ctx) {
        const ns = useNamespace("tree");
        const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
        const tree = inject("RootTree");
        const expanded = ref(false);
        const childNodeRendered = ref(false);
        const oldChecked = ref(null);
        const oldIndeterminate = ref(null);
        const node$ = ref(null);
        const dragEvents = inject(dragEventsKey);
        const instance = getCurrentInstance();
        provide("NodeInstance", instance);
        if (props.node.expanded) {
          expanded.value = true;
          childNodeRendered.value = true;
        }
        const childrenKey = tree.props.props["children"] || "children";
        watch(() => {
          const children = props.node.data[childrenKey];
          return children && [...children];
        }, () => {
          props.node.updateChildren();
        });
        watch(() => props.node.indeterminate, (val) => {
          handleSelectChange(props.node.checked, val);
        });
        watch(() => props.node.checked, (val) => {
          handleSelectChange(val, props.node.indeterminate);
        });
        watch(() => props.node.expanded, (val) => {
          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$2(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, () => tree.store.value.setCurrentNode(props.node));
          tree.currentNode.value = props.node;
          if (tree.props.expandOnClickNode) {
            handleExpandIconClick();
          }
          if (tree.props.checkOnClickNode && !props.node.disabled) {
            handleCheckChange(null, {
              target: { checked: !props.node.checked }
            });
          }
          tree.ctx.emit("node-click", props.node.data, props.node, instance, e);
        };
        const handleContextMenu = (event) => {
          if (tree.instance.vnode.props["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, ev) => {
          props.node.setChecked(ev.target.checked, !tree.props.checkStrictly);
          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
        };
      }
    });
    const _hoisted_1$9 = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"];
    const _hoisted_2$6 = ["aria-expanded"];
    function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_icon = resolveComponent("el-icon");
      const _component_el_checkbox = resolveComponent("el-checkbox");
      const _component_loading = resolveComponent("loading");
      const _component_node_content = resolveComponent("node-content");
      const _component_el_tree_node = resolveComponent("el-tree-node");
      const _component_el_collapse_transition = resolveComponent("el-collapse-transition");
      return withDirectives((openBlock(), createElementBlock("div", {
        ref: "node$",
        class: 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: _cache[1] || (_cache[1] = withModifiers((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"])),
        onContextmenu: _cache[2] || (_cache[2] = (...args) => _ctx.handleContextMenu && _ctx.handleContextMenu(...args)),
        onDragstart: _cache[3] || (_cache[3] = withModifiers((...args) => _ctx.handleDragStart && _ctx.handleDragStart(...args), ["stop"])),
        onDragover: _cache[4] || (_cache[4] = withModifiers((...args) => _ctx.handleDragOver && _ctx.handleDragOver(...args), ["stop"])),
        onDragend: _cache[5] || (_cache[5] = withModifiers((...args) => _ctx.handleDragEnd && _ctx.handleDragEnd(...args), ["stop"])),
        onDrop: _cache[6] || (_cache[6] = withModifiers((...args) => _ctx.handleDrop && _ctx.handleDrop(...args), ["stop"]))
      }, [
        createBaseVNode("div", {
          class: normalizeClass(_ctx.ns.be("node", "content")),
          style: normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
        }, [
          _ctx.tree.props.icon || _ctx.CaretRight ? (openBlock(), createBlock(_component_el_icon, {
            key: 0,
            class: normalizeClass([
              _ctx.ns.be("node", "expand-icon"),
              _ctx.ns.is("leaf", _ctx.node.isLeaf),
              {
                expanded: !_ctx.node.isLeaf && _ctx.expanded
              }
            ]),
            onClick: withModifiers(_ctx.handleExpandIconClick, ["stop"])
          }, {
            default: withCtx(() => [
              (openBlock(), createBlock(resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))
            ]),
            _: 1
          }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
          _ctx.showCheckbox ? (openBlock(), createBlock(_component_el_checkbox, {
            key: 1,
            "model-value": _ctx.node.checked,
            indeterminate: _ctx.node.indeterminate,
            disabled: !!_ctx.node.disabled,
            onClick: _cache[0] || (_cache[0] = withModifiers(() => {
            }, ["stop"])),
            onChange: _ctx.handleCheckChange
          }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : createCommentVNode("v-if", true),
          _ctx.node.loading ? (openBlock(), createBlock(_component_el_icon, {
            key: 2,
            class: normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
          }, {
            default: withCtx(() => [
              createVNode(_component_loading)
            ]),
            _: 1
          }, 8, ["class"])) : createCommentVNode("v-if", true),
          createVNode(_component_node_content, {
            node: _ctx.node,
            "render-content": _ctx.renderContent
          }, null, 8, ["node", "render-content"])
        ], 6),
        createVNode(_component_el_collapse_transition, null, {
          default: withCtx(() => [
            !_ctx.renderAfterExpand || _ctx.childNodeRendered ? withDirectives((openBlock(), createElementBlock("div", {
              key: 0,
              class: normalizeClass(_ctx.ns.be("node", "children")),
              role: "group",
              "aria-expanded": _ctx.expanded
            }, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.node.childNodes, (child) => {
                return openBlock(), 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, _hoisted_2$6)), [
              [vShow, _ctx.expanded]
            ]) : createCommentVNode("v-if", true)
          ]),
          _: 1
        })
      ], 42, _hoisted_1$9)), [
        [vShow, _ctx.node.visible]
      ]);
    }
    var ElTreeNode$1 = /* @__PURE__ */ _export_sfc$1(_sfc_main$g, [["render", _sfc_render$2], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node.vue"]]);
    function useKeydown({ el$ }, store) {
      const ns = useNamespace("tree");
      const treeItems = shallowRef([]);
      const checkboxItems = shallowRef([]);
      onMounted(() => {
        initTabIndex();
      });
      onUpdated(() => {
        treeItems.value = Array.from(el$.value.querySelectorAll("[role=treeitem]"));
        checkboxItems.value = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
      });
      watch(checkboxItems, (val) => {
        val.forEach((checkbox) => {
          checkbox.setAttribute("tabindex", "-1");
        });
      });
      const handleKeydown = (ev) => {
        const currentItem = ev.target;
        if (!currentItem.className.includes(ns.b("node")))
          return;
        const code = ev.code;
        treeItems.value = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
        const currentIndex = treeItems.value.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.value.length - 1;
            const startIndex = nextIndex;
            while (true) {
              if (store.value.getNode(treeItems.value[nextIndex].dataset.key).canFocus)
                break;
              nextIndex--;
              if (nextIndex === startIndex) {
                nextIndex = -1;
                break;
              }
              if (nextIndex < 0) {
                nextIndex = treeItems.value.length - 1;
              }
            }
          } else {
            nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.value.length - 1 ? currentIndex + 1 : 0;
            const startIndex = nextIndex;
            while (true) {
              if (store.value.getNode(treeItems.value[nextIndex].dataset.key).canFocus)
                break;
              nextIndex++;
              if (nextIndex === startIndex) {
                nextIndex = -1;
                break;
              }
              if (nextIndex >= treeItems.value.length) {
                nextIndex = 0;
              }
            }
          }
          nextIndex !== -1 && treeItems.value[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.space].includes(code) && hasInput) {
          ev.preventDefault();
          hasInput.click();
        }
      };
      useEventListener(el$, "keydown", handleKeydown);
      const initTabIndex = () => {
        var _a2;
        treeItems.value = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
        checkboxItems.value = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
        const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
        if (checkedItem.length) {
          checkedItem[0].setAttribute("tabindex", "0");
          return;
        }
        (_a2 = treeItems.value[0]) == null ? void 0 : _a2.setAttribute("tabindex", "0");
      };
    }
    const _sfc_main$f = /* @__PURE__ */ defineComponent({
      name: "ElTree",
      components: { ElTreeNode: ElTreeNode$1 },
      props: {
        data: {
          type: Array,
          default: () => []
        },
        emptyText: {
          type: String
        },
        renderAfterExpand: {
          type: Boolean,
          default: true
        },
        nodeKey: String,
        checkStrictly: Boolean,
        defaultExpandAll: Boolean,
        expandOnClickNode: {
          type: Boolean,
          default: true
        },
        checkOnClickNode: Boolean,
        checkDescendants: {
          type: Boolean,
          default: false
        },
        autoExpandParent: {
          type: Boolean,
          default: true
        },
        defaultCheckedKeys: Array,
        defaultExpandedKeys: Array,
        currentNodeKey: [String, Number],
        renderContent: Function,
        showCheckbox: {
          type: Boolean,
          default: false
        },
        draggable: {
          type: Boolean,
          default: false
        },
        allowDrag: Function,
        allowDrop: Function,
        props: {
          type: Object,
          default: () => ({
            children: "children",
            label: "label",
            disabled: "disabled"
          })
        },
        lazy: {
          type: Boolean,
          default: false
        },
        highlightCurrent: Boolean,
        load: Function,
        filterNodeMethod: Function,
        accordion: Boolean,
        indent: {
          type: Number,
          default: 18
        },
        icon: {
          type: iconPropType
        }
      },
      emits: [
        "check-change",
        "current-change",
        "node-click",
        "node-contextmenu",
        "node-collapse",
        "node-expand",
        "check",
        "node-drag-start",
        "node-drag-end",
        "node-drop",
        "node-drag-leave",
        "node-drag-enter",
        "node-drag-over"
      ],
      setup(props, ctx) {
        const { t } = useLocale();
        const ns = useNamespace("tree");
        const store = 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 root2 = ref(store.value.root);
        const currentNode = ref(null);
        const el$ = ref(null);
        const dropIndicator$ = ref(null);
        const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
        const { dragState } = useDragNodeHandler({
          props,
          ctx,
          el$,
          dropIndicator$,
          store
        });
        useKeydown({ el$ }, store);
        const isEmpty2 = computed(() => {
          const { childNodes } = root2.value;
          return !childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible);
        });
        watch(() => props.currentNodeKey, (newVal) => {
          store.value.setCurrentNodeKey(newVal);
        });
        watch(() => props.defaultCheckedKeys, (newVal) => {
          store.value.setDefaultCheckedKey(newVal);
        });
        watch(() => props.defaultExpandedKeys, (newVal) => {
          store.value.setDefaultExpandedKeys(newVal);
        });
        watch(() => props.data, (newVal) => {
          store.value.setData(newVal);
        }, { deep: true });
        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 !== root2.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 = (keys2, leafOnly) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in setCheckedKeys");
          store.value.setCheckedKeys(keys2, leafOnly);
        };
        const setChecked2 = (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, () => store.value.setUserCurrentNode(node, shouldAutoExpandParent));
        };
        const setCurrentKey = (key, shouldAutoExpandParent = true) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in setCurrentKey");
          handleCurrentChange(store, ctx.emit, () => store.value.setCurrentNodeKey(key, shouldAutoExpandParent));
        };
        const getNode = (data) => {
          return store.value.getNode(data);
        };
        const remove2 = (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, instance) => {
          broadcastExpanded(node);
          ctx.emit("node-expand", nodeData, node, instance);
        };
        const updateKeyChildren = (key, data) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in updateKeyChild");
          store.value.updateChildren(key, data);
        };
        provide("RootTree", {
          ctx,
          props,
          store,
          root: root2,
          currentNode,
          instance: getCurrentInstance()
        });
        provide(formItemContextKey, void 0);
        return {
          ns,
          store,
          root: root2,
          currentNode,
          dragState,
          el$,
          dropIndicator$,
          isEmpty: isEmpty2,
          filter,
          getNodeKey: getNodeKey$1,
          getNodePath,
          getCheckedNodes,
          getCheckedKeys,
          getCurrentNode,
          getCurrentKey,
          setCheckedNodes,
          setCheckedKeys,
          setChecked: setChecked2,
          getHalfCheckedNodes,
          getHalfCheckedKeys,
          setCurrentNode,
          setCurrentKey,
          t,
          getNode,
          remove: remove2,
          append,
          insertBefore,
          insertAfter,
          handleNodeExpand,
          updateKeyChildren
        };
      }
    });
    function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_tree_node = resolveComponent("el-tree-node");
      return openBlock(), createElementBlock("div", {
        ref: "el$",
        class: 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"
      }, [
        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.root.childNodes, (child) => {
          return openBlock(), 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 ? (openBlock(), createElementBlock("div", {
          key: 0,
          class: normalizeClass(_ctx.ns.e("empty-block"))
        }, [
          renderSlot(_ctx.$slots, "empty", {}, () => {
            var _a2;
            return [
              createBaseVNode("span", {
                class: normalizeClass(_ctx.ns.e("empty-text"))
              }, toDisplayString((_a2 = _ctx.emptyText) != null ? _a2 : _ctx.t("el.tree.emptyText")), 3)
            ];
          })
        ], 2)) : createCommentVNode("v-if", true),
        withDirectives(createBaseVNode("div", {
          ref: "dropIndicator$",
          class: normalizeClass(_ctx.ns.e("drop-indicator"))
        }, null, 2), [
          [vShow, _ctx.dragState.showDropIndicator]
        ])
      ], 2);
    }
    var Tree = /* @__PURE__ */ _export_sfc$1(_sfc_main$f, [["render", _sfc_render$1], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree.vue"]]);
    Tree.install = (app) => {
      app.component(Tree.name, Tree);
    };
    const _Tree = Tree;
    const ElTree = _Tree;
    const useSelect = (props, { attrs, emit: emit2 }, {
      tree,
      key
    }) => {
      const ns = useNamespace("tree-select");
      const result = {
        ...pick$1(toRefs(props), Object.keys(ElSelect.props)),
        ...attrs,
        "onUpdate:modelValue": (value) => emit2(UPDATE_MODEL_EVENT, value),
        valueKey: key,
        popperClass: computed(() => {
          const classes = [ns.e("popper")];
          if (props.popperClass)
            classes.push(props.popperClass);
          return classes.join(" ");
        }),
        filterMethod: (keyword = "") => {
          if (props.filterMethod)
            props.filterMethod(keyword);
          nextTick(() => {
            var _a2;
            (_a2 = tree.value) == null ? void 0 : _a2.filter(keyword);
          });
        },
        onVisibleChange: (visible) => {
          var _a2;
          (_a2 = attrs.onVisibleChange) == null ? void 0 : _a2.call(attrs, visible);
          if (props.filterable && visible) {
            result.filterMethod();
          }
        }
      };
      return result;
    };
    const component = /* @__PURE__ */ defineComponent({
      extends: ElOption,
      setup(props, ctx) {
        const result = ElOption.setup(props, ctx);
        delete result.selectOptionClick;
        const vm = getCurrentInstance().proxy;
        nextTick(() => {
          if (!result.select.cachedOptions.get(vm.value)) {
            result.select.onOptionCreate(vm);
          }
        });
        return result;
      },
      methods: {
        selectOptionClick() {
          this.$el.parentElement.click();
        }
      }
    });
    function isValidValue(val) {
      return val || val === 0;
    }
    function isValidArray(val) {
      return Array.isArray(val) && val.length;
    }
    function toValidArray(val) {
      return Array.isArray(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: emit2 }, {
      select,
      tree,
      key
    }) => {
      watch(() => props.modelValue, () => {
        if (props.showCheckbox) {
          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 = computed(() => ({
        value: key.value,
        label: "label",
        children: "children",
        disabled: "disabled",
        isLeaf: "isLeaf",
        ...props.props
      }));
      const getNodeValByProp = (prop, data) => {
        var _a2;
        const propVal = propsMap.value[prop];
        if (isFunction$2(propVal)) {
          return propVal(data, (_a2 = tree.value) == null ? void 0 : _a2.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, index2, array2, parent) => parent && getNodeValByProp("value", parent));
      }).filter((item) => isValidValue(item));
      const cacheOptions = 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 cacheOptionsMap = computed(() => {
        return cacheOptions.value.reduce((prev, next) => ({ ...prev, [next.value]: next }), {});
      });
      return {
        ...pick$1(toRefs(props), Object.keys(_Tree.props)),
        ...attrs,
        nodeKey: key,
        expandOnClickNode: computed(() => {
          return !props.checkStrictly && props.expandOnClickNode;
        }),
        defaultExpandedKeys: computed(() => {
          return props.defaultExpandedKeys ? props.defaultExpandedKeys.concat(defaultExpandedParentKeys) : defaultExpandedParentKeys;
        }),
        renderContent: (h2, { node, data, store }) => {
          return h2(component, {
            value: getNodeValByProp("value", data),
            label: getNodeValByProp("label", data),
            disabled: getNodeValByProp("disabled", data)
          }, props.renderContent ? () => props.renderContent(h2, { node, data, store }) : slots.default ? () => slots.default({ node, data, store }) : void 0);
        },
        filterNodeMethod: (value, data, node) => {
          var _a2;
          if (props.filterNodeMethod)
            return props.filterNodeMethod(value, data, node);
          if (!value)
            return true;
          return (_a2 = getNodeValByProp("label", data)) == null ? void 0 : _a2.includes(value);
        },
        onNodeClick: (data, node, e) => {
          var _a2, _b, _c;
          (_a2 = attrs.onNodeClick) == null ? void 0 : _a2.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.options.get(getNodeValByProp("value", data));
              (_c = select.value) == null ? void 0 : _c.handleOptionSelect(option);
            }
          } else if (props.expandOnClickNode) {
            e.proxy.handleExpandIconClick();
          }
        },
        onCheck: (data, params) => {
          if (!props.showCheckbox)
            return;
          const dataValue = getNodeValByProp("value", data);
          const uncachedCheckedKeys = params.checkedKeys;
          const cachedKeys = props.multiple ? toValidArray(props.modelValue).filter((item) => item in cacheOptionsMap.value && !tree.value.getNode(item) && !uncachedCheckedKeys.includes(item)) : [];
          const checkedKeys = uncachedCheckedKeys.concat(cachedKeys);
          if (props.checkStrictly) {
            emit2(UPDATE_MODEL_EVENT, props.multiple ? checkedKeys : checkedKeys.includes(dataValue) ? dataValue : void 0);
          } else {
            if (props.multiple) {
              emit2(UPDATE_MODEL_EVENT, tree.value.getCheckedKeys(true));
            } 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));
              emit2(UPDATE_MODEL_EVENT, firstLeafKey === props.modelValue || hasCheckedChild ? void 0 : firstLeafKey);
            }
          }
          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()
            });
          });
        },
        cacheOptions
      };
    };
    var CacheOptions = /* @__PURE__ */ defineComponent({
      props: {
        data: {
          type: Array,
          default: () => []
        }
      },
      setup(props) {
        const select = inject(selectKey);
        watch(() => props.data, () => {
          var _a2;
          props.data.forEach((item) => {
            if (!select.cachedOptions.has(item.value)) {
              select.cachedOptions.set(item.value, item);
            }
          });
          const inputs = ((_a2 = select.selectWrapper) == null ? void 0 : _a2.querySelectorAll("input")) || [];
          if (!Array.from(inputs).includes(document.activeElement)) {
            select.setSelected();
          }
        }, { flush: "post", immediate: true });
        return () => void 0;
      }
    });
    const _sfc_main$e = /* @__PURE__ */ defineComponent({
      name: "ElTreeSelect",
      inheritAttrs: false,
      props: {
        ...ElSelect.props,
        ..._Tree.props,
        cacheData: {
          type: Array,
          default: () => []
        }
      },
      setup(props, context) {
        const { slots, expose } = context;
        const select = ref();
        const tree = ref();
        const key = computed(() => props.nodeKey || props.valueKey || "value");
        const selectProps = useSelect(props, context, { select, tree, key });
        const { cacheOptions, ...treeProps2 } = useTree$1(props, context, {
          select,
          tree,
          key
        });
        const methods = reactive({});
        expose(methods);
        onMounted(() => {
          Object.assign(methods, {
            ...pick$1(tree.value, [
              "filter",
              "updateKeyChildren",
              "getCheckedNodes",
              "setCheckedNodes",
              "getCheckedKeys",
              "setCheckedKeys",
              "setChecked",
              "getHalfCheckedNodes",
              "getHalfCheckedKeys",
              "getCurrentKey",
              "getCurrentNode",
              "setCurrentKey",
              "setCurrentNode",
              "getNode",
              "remove",
              "append",
              "insertBefore",
              "insertAfter"
            ]),
            ...pick$1(select.value, ["focus", "blur"])
          });
        });
        return () => h$1(ElSelect, reactive({
          ...selectProps,
          ref: (ref2) => select.value = ref2
        }), {
          ...slots,
          default: () => [
            h$1(CacheOptions, { data: cacheOptions.value }),
            h$1(_Tree, reactive({
              ...treeProps2,
              ref: (ref2) => tree.value = ref2
            }))
          ]
        });
      }
    });
    var TreeSelect = /* @__PURE__ */ _export_sfc$1(_sfc_main$e, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree-select/src/tree-select.vue"]]);
    TreeSelect.install = (app) => {
      app.component(TreeSelect.name, TreeSelect);
    };
    const _TreeSelect = TreeSelect;
    const ElTreeSelect = _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";
      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",
          label: "label",
          disabled: "disabled",
          value: "id"
          /* KEY */
        })
      },
      highlightCurrent: {
        type: Boolean,
        default: false
      },
      showCheckbox: {
        type: Boolean,
        default: false
      },
      defaultCheckedKeys: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      checkStrictly: {
        type: Boolean,
        default: false
      },
      defaultExpandedKeys: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      indent: {
        type: Number,
        default: 16
      },
      itemSize,
      icon: {
        type: iconPropType
      },
      expandOnClickNode: {
        type: Boolean,
        default: true
      },
      checkOnClickNode: {
        type: Boolean,
        default: false
      },
      currentNodeKey: {
        type: definePropType([String, Number])
      },
      accordion: {
        type: Boolean,
        default: false
      },
      filterMethod: {
        type: definePropType(Function)
      },
      perfMode: {
        type: Boolean,
        default: true
      }
    });
    const treeNodeProps = buildProps({
      node: {
        type: definePropType(Object),
        default: () => mutable(EMPTY_NODE)
      },
      expanded: {
        type: Boolean,
        default: false
      },
      checked: {
        type: Boolean,
        default: false
      },
      indeterminate: {
        type: Boolean,
        default: false
      },
      showCheckbox: {
        type: Boolean,
        default: false
      },
      disabled: {
        type: Boolean,
        default: false
      },
      current: {
        type: Boolean,
        default: false
      },
      hiddenExpandIcon: {
        type: Boolean,
        default: false
      },
      itemSize
    });
    const treeNodeContentProps = buildProps({
      node: {
        type: definePropType(Object),
        required: true
      }
    });
    const NODE_CLICK = "node-click";
    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_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 && typeof checked === "boolean",
      [NODE_CONTEXTMENU]: (event, data, node) => event && data && node
    };
    const treeNodeEmits = {
      click: (node, e) => !!(node && e),
      toggle: (node) => !!node,
      check: (node, checked) => node && typeof checked === "boolean"
    };
    function useCheck(props, tree) {
      const checkedKeys = ref(/* @__PURE__ */ new Set());
      const indeterminateKeys = ref(/* @__PURE__ */ new Set());
      const { emit: emit2 } = getCurrentInstance();
      watch([() => tree.value, () => props.defaultCheckedKeys], () => {
        return 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) => {
        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);
        updateCheckedKeys();
        if (nodeClick) {
          afterNodeCheck(node, isChecked2);
        }
      };
      const afterNodeCheck = (node, checked) => {
        const { checkedNodes, checkedKeys: checkedKeys2 } = getChecked();
        const { halfCheckedNodes, halfCheckedKeys } = getHalfChecked();
        emit2(NODE_CHECK, node.data, {
          checkedKeys: checkedKeys2,
          checkedNodes,
          halfCheckedKeys,
          halfCheckedNodes
        });
        emit2(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 keys2 = [];
        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)) {
              keys2.push(key);
              checkedNodes.push(node.data);
            }
          });
        }
        return {
          checkedKeys: keys2,
          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(keys2) {
        checkedKeys.value.clear();
        indeterminateKeys.value.clear();
        _setCheckedKeys(keys2);
      }
      function setChecked2(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(keys2) {
        if (tree == null ? void 0 : tree.value) {
          const { treeNodeMap } = tree.value;
          if (props.showCheckbox && treeNodeMap && keys2) {
            for (const key of keys2) {
              const node = treeNodeMap.get(key);
              if (node && !isChecked(node)) {
                toggleCheckbox(node, true, false);
              }
            }
          }
        }
      }
      return {
        updateCheckedKeys,
        toggleCheckbox,
        isChecked,
        isIndeterminate,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked: setChecked2,
        setCheckedKeys
      };
    }
    function useFilter(props, tree) {
      const hiddenNodeKeySet = ref(/* @__PURE__ */ new Set([]));
      const hiddenExpandIconKeySet = ref(/* @__PURE__ */ new Set([]));
      const filterable = computed(() => {
        return isFunction$2(props.filterMethod);
      });
      function doFilter(query) {
        var _a2;
        if (!filterable.value) {
          return;
        }
        const expandKeySet = /* @__PURE__ */ new Set();
        const hiddenExpandIconKeys = hiddenExpandIconKeySet.value;
        const hiddenKeys = hiddenNodeKeySet.value;
        const family = [];
        const nodes = ((_a2 = tree.value) == null ? void 0 : _a2.treeNodes) || [];
        const filter = props.filterMethod;
        hiddenKeys.clear();
        function traverse2(nodes2) {
          nodes2.forEach((node) => {
            family.push(node);
            if (filter == null ? void 0 : filter(query, node.data)) {
              family.forEach((member) => {
                expandKeySet.add(member.key);
              });
            } else if (node.isLeaf) {
              hiddenKeys.add(node.key);
            }
            const children = node.children;
            if (children) {
              traverse2(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();
          });
        }
        traverse2(nodes);
        return expandKeySet;
      }
      function isForceHiddenExpandIcon(node) {
        return hiddenExpandIconKeySet.value.has(node.key);
      }
      return {
        hiddenExpandIconKeySet,
        hiddenNodeKeySet,
        doFilter,
        isForceHiddenExpandIcon
      };
    }
    function useTree(props, emit2) {
      const expandedKeySet = ref(new Set(props.defaultExpandedKeys));
      const currentKey = ref();
      const tree = shallowRef();
      watch(() => props.currentNodeKey, (key) => {
        currentKey.value = key;
      }, {
        immediate: true
      });
      watch(() => props.data, (data) => {
        setData(data);
      }, {
        immediate: true
      });
      const {
        isIndeterminate,
        isChecked,
        toggleCheckbox,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked: setChecked2,
        setCheckedKeys
      } = useCheck(props, tree);
      const { doFilter, hiddenNodeKeySet, isForceHiddenExpandIcon } = useFilter(props, tree);
      const valueKey = computed(() => {
        var _a2;
        return ((_a2 = props.props) == null ? void 0 : _a2.value) || TreeOptionsEnum.KEY;
      });
      const childrenKey = computed(() => {
        var _a2;
        return ((_a2 = props.props) == null ? void 0 : _a2.children) || TreeOptionsEnum.CHILDREN;
      });
      const disabledKey = computed(() => {
        var _a2;
        return ((_a2 = props.props) == null ? void 0 : _a2.disabled) || TreeOptionsEnum.DISABLED;
      });
      const labelKey = computed(() => {
        var _a2;
        return ((_a2 = props.props) == null ? void 0 : _a2.label) || TreeOptionsEnum.LABEL;
      });
      const flattenTree = computed(() => {
        const expandedKeys = expandedKeySet.value;
        const hiddenKeys = hiddenNodeKeySet.value;
        const flattenNodes = [];
        const nodes = tree.value && tree.value.treeNodes || [];
        function traverse2() {
          const stack = [];
          for (let i = nodes.length - 1; i >= 0; --i) {
            stack.push(nodes[i]);
          }
          while (stack.length) {
            const node = stack.pop();
            if (!node)
              continue;
            if (!hiddenKeys.has(node.key)) {
              flattenNodes.push(node);
            }
            if (expandedKeys.has(node.key)) {
              const children = node.children;
              if (children) {
                const length = children.length;
                for (let i = length - 1; i >= 0; --i) {
                  stack.push(children[i]);
                }
              }
            }
          }
        }
        traverse2();
        return flattenNodes;
      });
      const isNotEmpty = computed(() => {
        return flattenTree.value.length > 0;
      });
      function createTree(data) {
        const treeNodeMap = /* @__PURE__ */ new Map();
        const levelTreeNodeMap = /* @__PURE__ */ new Map();
        let maxLevel = 1;
        function traverse2(nodes, level = 1, parent = void 0) {
          var _a2;
          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;
            if (children && children.length) {
              node.children = traverse2(children, level + 1, node);
            }
            siblings.push(node);
            treeNodeMap.set(value, node);
            if (!levelTreeNodeMap.has(level)) {
              levelTreeNodeMap.set(level, []);
            }
            (_a2 = levelTreeNodeMap.get(level)) == null ? void 0 : _a2.push(node);
          }
          if (level > maxLevel) {
            maxLevel = level;
          }
          return siblings;
        }
        const treeNodes = traverse2(data);
        return {
          treeNodeMap,
          levelTreeNodeMap,
          maxLevel,
          treeNodes
        };
      }
      function filter(query) {
        const keys2 = doFilter(query);
        if (keys2) {
          expandedKeySet.value = keys2;
        }
      }
      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(keys2) {
        expandedKeySet.value = new Set(keys2);
      }
      function handleNodeClick(node, e) {
        emit2(NODE_CLICK, node.data, node, e);
        handleCurrentChange2(node);
        if (props.expandOnClickNode) {
          toggleExpand(node);
        }
        if (props.showCheckbox && props.checkOnClickNode && !node.disabled) {
          toggleCheckbox(node, !isChecked(node), true);
        }
      }
      function handleCurrentChange2(node) {
        if (!isCurrent(node)) {
          currentKey.value = node.key;
          emit2(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);
            }
          });
        }
        keySet.add(node.key);
        emit2(NODE_EXPAND, node.data, node);
      }
      function collapseNode(node) {
        expandedKeySet.value.delete(node.key);
        emit2(NODE_COLLAPSE, node.data, node);
      }
      function isExpanded(node) {
        return expandedKeySet.value.has(node.key);
      }
      function isDisabled(node) {
        return !!node.disabled;
      }
      function isCurrent(node) {
        const current = currentKey.value;
        return current !== void 0 && current === node.key;
      }
      function getCurrentNode() {
        var _a2, _b;
        if (!currentKey.value)
          return void 0;
        return (_b = (_a2 = tree.value) == null ? void 0 : _a2.treeNodeMap.get(currentKey.value)) == null ? void 0 : _b.data;
      }
      function getCurrentKey() {
        return currentKey.value;
      }
      function setCurrentKey(key) {
        currentKey.value = key;
      }
      function setData(data) {
        nextTick(() => tree.value = createTree(data));
      }
      function getNode(data) {
        var _a2;
        const key = isObject$1(data) ? getKey(data) : data;
        return (_a2 = tree.value) == null ? void 0 : _a2.treeNodeMap.get(key);
      }
      return {
        tree,
        flattenTree,
        isNotEmpty,
        getKey,
        getChildren,
        toggleExpand,
        toggleCheckbox,
        isExpanded,
        isChecked,
        isIndeterminate,
        isDisabled,
        isCurrent,
        isForceHiddenExpandIcon,
        handleNodeClick,
        handleNodeCheck,
        getCurrentNode,
        getCurrentKey,
        setCurrentKey,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked: setChecked2,
        setCheckedKeys,
        filter,
        setData,
        getNode,
        expandNode,
        collapseNode,
        setExpandedKeys
      };
    }
    var ElNodeContent = /* @__PURE__ */ defineComponent({
      name: "ElTreeNodeContent",
      props: treeNodeContentProps,
      setup(props) {
        const tree = 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 }) : h$1("span", { class: ns.be("node", "label") }, [node == null ? void 0 : node.label]);
        };
      }
    });
    const _hoisted_1$8 = ["aria-expanded", "aria-disabled", "aria-checked", "data-key", "onClick"];
    const __default__$8 = /* @__PURE__ */ defineComponent({
      name: "ElTreeNode"
    });
    const _sfc_main$d = /* @__PURE__ */ defineComponent({
      ...__default__$8,
      props: treeNodeProps,
      emits: treeNodeEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const tree = inject(ROOT_TREE_INJECTION_KEY);
        const ns = useNamespace("tree");
        const indent = computed(() => {
          var _a2;
          return (_a2 = tree == null ? void 0 : tree.props.indent) != null ? _a2 : 16;
        });
        const icon = computed(() => {
          var _a2;
          return (_a2 = tree == null ? void 0 : tree.props.icon) != null ? _a2 : caret_right_default;
        });
        const handleClick = (e) => {
          emit2("click", props.node, e);
        };
        const handleExpandIconClick = () => {
          emit2("toggle", props.node);
        };
        const handleCheckChange = (value) => {
          emit2("check", props.node, value);
        };
        const handleContextMenu = (event) => {
          var _a2, _b, _c, _d;
          if ((_c = (_b = (_a2 = tree == null ? void 0 : tree.instance) == null ? void 0 : _a2.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 _a2, _b, _c;
          return openBlock(), createElementBlock("div", {
            ref: "node$",
            class: normalizeClass([
              unref(ns).b("node"),
              unref(ns).is("expanded", _ctx.expanded),
              unref(ns).is("current", _ctx.current),
              unref(ns).is("focusable", !_ctx.disabled),
              unref(ns).is("checked", !_ctx.disabled && _ctx.checked)
            ]),
            role: "treeitem",
            tabindex: "-1",
            "aria-expanded": _ctx.expanded,
            "aria-disabled": _ctx.disabled,
            "aria-checked": _ctx.checked,
            "data-key": (_a2 = _ctx.node) == null ? void 0 : _a2.key,
            onClick: withModifiers(handleClick, ["stop"]),
            onContextmenu: handleContextMenu
          }, [
            createBaseVNode("div", {
              class: normalizeClass(unref(ns).be("node", "content")),
              style: normalizeStyle({
                paddingLeft: `${(_ctx.node.level - 1) * unref(indent)}px`,
                height: _ctx.itemSize + "px"
              })
            }, [
              unref(icon) ? (openBlock(), createBlock(unref(ElIcon), {
                key: 0,
                class: normalizeClass([
                  unref(ns).is("leaf", !!((_b = _ctx.node) == null ? void 0 : _b.isLeaf)),
                  unref(ns).is("hidden", _ctx.hiddenExpandIcon),
                  {
                    expanded: !((_c = _ctx.node) == null ? void 0 : _c.isLeaf) && _ctx.expanded
                  },
                  unref(ns).be("node", "expand-icon")
                ]),
                onClick: withModifiers(handleExpandIconClick, ["stop"])
              }, {
                default: withCtx(() => [
                  (openBlock(), createBlock(resolveDynamicComponent(unref(icon))))
                ]),
                _: 1
              }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
              _ctx.showCheckbox ? (openBlock(), createBlock(unref(ElCheckbox), {
                key: 1,
                "model-value": _ctx.checked,
                indeterminate: _ctx.indeterminate,
                disabled: _ctx.disabled,
                onChange: handleCheckChange,
                onClick: _cache[0] || (_cache[0] = withModifiers(() => {
                }, ["stop"]))
              }, null, 8, ["model-value", "indeterminate", "disabled"])) : createCommentVNode("v-if", true),
              createVNode(unref(ElNodeContent), { node: _ctx.node }, null, 8, ["node"])
            ], 6)
          ], 42, _hoisted_1$8);
        };
      }
    });
    var ElTreeNode = /* @__PURE__ */ _export_sfc$1(_sfc_main$d, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree-v2/src/tree-node.vue"]]);
    const __default__$7 = /* @__PURE__ */ defineComponent({
      name: "ElTreeV2"
    });
    const _sfc_main$c = /* @__PURE__ */ defineComponent({
      ...__default__$7,
      props: treeProps,
      emits: treeEmits,
      setup(__props, { expose, emit: emit2 }) {
        const props = __props;
        const slots = useSlots();
        const treeNodeSize = computed(() => props.itemSize);
        provide(ROOT_TREE_INJECTION_KEY, {
          ctx: {
            emit: emit2,
            slots
          },
          props,
          instance: getCurrentInstance()
        });
        provide(formItemContextKey, void 0);
        const { t } = useLocale();
        const ns = useNamespace("tree");
        const {
          flattenTree,
          isNotEmpty,
          toggleExpand,
          isExpanded,
          isIndeterminate,
          isChecked,
          isDisabled,
          isCurrent,
          isForceHiddenExpandIcon,
          handleNodeClick,
          handleNodeCheck,
          toggleCheckbox,
          getCurrentNode,
          getCurrentKey,
          setCurrentKey,
          getCheckedKeys,
          getCheckedNodes,
          getHalfCheckedKeys,
          getHalfCheckedNodes,
          setChecked: setChecked2,
          setCheckedKeys,
          filter,
          setData,
          getNode,
          expandNode,
          collapseNode,
          setExpandedKeys
        } = useTree(props, emit2);
        expose({
          toggleCheckbox,
          getCurrentNode,
          getCurrentKey,
          setCurrentKey,
          getCheckedKeys,
          getCheckedNodes,
          getHalfCheckedKeys,
          getHalfCheckedNodes,
          setChecked: setChecked2,
          setCheckedKeys,
          filter,
          setData,
          getNode,
          expandNode,
          collapseNode,
          setExpandedKeys
        });
        return (_ctx, _cache) => {
          var _a2;
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).b(), { [unref(ns).m("highlight-current")]: _ctx.highlightCurrent }]),
            role: "tree"
          }, [
            unref(isNotEmpty) ? (openBlock(), createBlock(unref(FixedSizeList), {
              key: 0,
              "class-name": unref(ns).b("virtual-list"),
              data: unref(flattenTree),
              total: unref(flattenTree).length,
              height: _ctx.height,
              "item-size": unref(treeNodeSize),
              "perf-mode": _ctx.perfMode
            }, {
              default: withCtx(({ data, index: index2, style }) => [
                (openBlock(), createBlock(ElTreeNode, {
                  key: data[index2].key,
                  style: normalizeStyle(style),
                  node: data[index2],
                  expanded: unref(isExpanded)(data[index2]),
                  "show-checkbox": _ctx.showCheckbox,
                  checked: unref(isChecked)(data[index2]),
                  indeterminate: unref(isIndeterminate)(data[index2]),
                  "item-size": unref(treeNodeSize),
                  disabled: unref(isDisabled)(data[index2]),
                  current: unref(isCurrent)(data[index2]),
                  "hidden-expand-icon": unref(isForceHiddenExpandIcon)(data[index2]),
                  onClick: unref(handleNodeClick),
                  onToggle: unref(toggleExpand),
                  onCheck: unref(handleNodeCheck)
                }, null, 8, ["style", "node", "expanded", "show-checkbox", "checked", "indeterminate", "item-size", "disabled", "current", "hidden-expand-icon", "onClick", "onToggle", "onCheck"]))
              ]),
              _: 1
            }, 8, ["class-name", "data", "total", "height", "item-size", "perf-mode"])) : (openBlock(), createElementBlock("div", {
              key: 1,
              class: normalizeClass(unref(ns).e("empty-block"))
            }, [
              createBaseVNode("span", {
                class: normalizeClass(unref(ns).e("empty-text"))
              }, toDisplayString((_a2 = _ctx.emptyText) != null ? _a2 : unref(t)("el.tree.emptyText")), 3)
            ], 2))
          ], 2);
        };
      }
    });
    var TreeV2 = /* @__PURE__ */ _export_sfc$1(_sfc_main$c, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree-v2/src/tree.vue"]]);
    const ElTreeV2 = withInstall(TreeV2);
    const uploadContextKey = Symbol("uploadContextKey");
    const SCOPE$2 = "ElUpload";
    class UploadAjaxError extends Error {
      constructor(message2, status, method2, url) {
        super(message2);
        this.name = "UploadAjaxError";
        this.status = status;
        this.method = method2;
        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$3(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: {
        type: Boolean,
        default: false
      },
      name: {
        type: String,
        default: "file"
      },
      drag: {
        type: Boolean,
        default: false
      },
      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
      }
    });
    const uploadListProps = buildProps({
      files: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      disabled: {
        type: Boolean,
        default: false
      },
      handlePreview: {
        type: definePropType(Function),
        default: NOOP
      },
      listType: {
        type: String,
        values: uploadListTypes,
        default: "text"
      }
    });
    const uploadListEmits = {
      remove: (file) => !!file
    };
    const _hoisted_1$7 = ["onKeydown"];
    const _hoisted_2$5 = ["src"];
    const _hoisted_3$2 = ["onClick"];
    const _hoisted_4$1 = ["title"];
    const _hoisted_5 = ["onClick"];
    const _hoisted_6 = ["onClick"];
    const __default__$6 = /* @__PURE__ */ defineComponent({
      name: "ElUploadList"
    });
    const _sfc_main$b = /* @__PURE__ */ defineComponent({
      ...__default__$6,
      props: uploadListProps,
      emits: uploadListEmits,
      setup(__props, { emit: emit2 }) {
        const props = __props;
        const { t } = useLocale();
        const nsUpload = useNamespace("upload");
        const nsIcon = useNamespace("icon");
        const nsList = useNamespace("list");
        const disabled = useFormDisabled();
        const focusing = ref(false);
        const containerKls = computed(() => [
          nsUpload.b("list"),
          nsUpload.bm("list", props.listType),
          nsUpload.is("disabled", props.disabled)
        ]);
        const handleRemove = (file) => {
          emit2("remove", file);
        };
        return (_ctx, _cache) => {
          return openBlock(), createBlock(TransitionGroup, {
            tag: "ul",
            class: normalizeClass(unref(containerKls)),
            name: unref(nsList).b()
          }, {
            default: withCtx(() => [
              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.files, (file) => {
                return openBlock(), createElementBlock("li", {
                  key: file.uid || file.name,
                  class: normalizeClass([
                    unref(nsUpload).be("list", "item"),
                    unref(nsUpload).is(file.status),
                    { focusing: focusing.value }
                  ]),
                  tabindex: "0",
                  onKeydown: withKeys(($event) => !unref(disabled) && handleRemove(file), ["delete"]),
                  onFocus: _cache[0] || (_cache[0] = ($event) => focusing.value = true),
                  onBlur: _cache[1] || (_cache[1] = ($event) => focusing.value = false),
                  onClick: _cache[2] || (_cache[2] = ($event) => focusing.value = false)
                }, [
                  renderSlot(_ctx.$slots, "default", { file }, () => [
                    _ctx.listType === "picture" || file.status !== "uploading" && _ctx.listType === "picture-card" ? (openBlock(), createElementBlock("img", {
                      key: 0,
                      class: normalizeClass(unref(nsUpload).be("list", "item-thumbnail")),
                      src: file.url,
                      alt: ""
                    }, null, 10, _hoisted_2$5)) : createCommentVNode("v-if", true),
                    file.status === "uploading" || _ctx.listType !== "picture-card" ? (openBlock(), createElementBlock("div", {
                      key: 1,
                      class: normalizeClass(unref(nsUpload).be("list", "item-info"))
                    }, [
                      createBaseVNode("a", {
                        class: normalizeClass(unref(nsUpload).be("list", "item-name")),
                        onClick: withModifiers(($event) => _ctx.handlePreview(file), ["prevent"])
                      }, [
                        createVNode(unref(ElIcon), {
                          class: normalizeClass(unref(nsIcon).m("document"))
                        }, {
                          default: withCtx(() => [
                            createVNode(unref(document_default))
                          ]),
                          _: 1
                        }, 8, ["class"]),
                        createBaseVNode("span", {
                          class: normalizeClass(unref(nsUpload).be("list", "item-file-name")),
                          title: file.name
                        }, toDisplayString(file.name), 11, _hoisted_4$1)
                      ], 10, _hoisted_3$2),
                      file.status === "uploading" ? (openBlock(), createBlock(unref(ElProgress), {
                        key: 0,
                        type: _ctx.listType === "picture-card" ? "circle" : "line",
                        "stroke-width": _ctx.listType === "picture-card" ? 6 : 2,
                        percentage: Number(file.percentage),
                        style: normalizeStyle(_ctx.listType === "picture-card" ? "" : "margin-top: 0.5rem")
                      }, null, 8, ["type", "stroke-width", "percentage", "style"])) : createCommentVNode("v-if", true)
                    ], 2)) : createCommentVNode("v-if", true),
                    createBaseVNode("label", {
                      class: normalizeClass(unref(nsUpload).be("list", "item-status-label"))
                    }, [
                      _ctx.listType === "text" ? (openBlock(), createBlock(unref(ElIcon), {
                        key: 0,
                        class: normalizeClass([unref(nsIcon).m("upload-success"), unref(nsIcon).m("circle-check")])
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(circle_check_default))
                        ]),
                        _: 1
                      }, 8, ["class"])) : ["picture-card", "picture"].includes(_ctx.listType) ? (openBlock(), createBlock(unref(ElIcon), {
                        key: 1,
                        class: normalizeClass([unref(nsIcon).m("upload-success"), unref(nsIcon).m("check")])
                      }, {
                        default: withCtx(() => [
                          createVNode(unref(check_default))
                        ]),
                        _: 1
                      }, 8, ["class"])) : createCommentVNode("v-if", true)
                    ], 2),
                    !unref(disabled) ? (openBlock(), createBlock(unref(ElIcon), {
                      key: 2,
                      class: normalizeClass(unref(nsIcon).m("close")),
                      onClick: ($event) => handleRemove(file)
                    }, {
                      default: withCtx(() => [
                        createVNode(unref(close_default))
                      ]),
                      _: 2
                    }, 1032, ["class", "onClick"])) : createCommentVNode("v-if", true),
                    createCommentVNode(" Due to close btn only appears when li gets focused disappears after li gets blurred, thus keyboard navigation can never reach close btn"),
                    createCommentVNode(" This is a bug which needs to be fixed "),
                    createCommentVNode(" TODO: Fix the incorrect navigation interaction "),
                    !unref(disabled) ? (openBlock(), createElementBlock("i", {
                      key: 3,
                      class: normalizeClass(unref(nsIcon).m("close-tip"))
                    }, toDisplayString(unref(t)("el.upload.deleteTip")), 3)) : createCommentVNode("v-if", true),
                    _ctx.listType === "picture-card" ? (openBlock(), createElementBlock("span", {
                      key: 4,
                      class: normalizeClass(unref(nsUpload).be("list", "item-actions"))
                    }, [
                      createBaseVNode("span", {
                        class: normalizeClass(unref(nsUpload).be("list", "item-preview")),
                        onClick: ($event) => _ctx.handlePreview(file)
                      }, [
                        createVNode(unref(ElIcon), {
                          class: normalizeClass(unref(nsIcon).m("zoom-in"))
                        }, {
                          default: withCtx(() => [
                            createVNode(unref(zoom_in_default))
                          ]),
                          _: 1
                        }, 8, ["class"])
                      ], 10, _hoisted_5),
                      !unref(disabled) ? (openBlock(), createElementBlock("span", {
                        key: 0,
                        class: normalizeClass(unref(nsUpload).be("list", "item-delete")),
                        onClick: ($event) => handleRemove(file)
                      }, [
                        createVNode(unref(ElIcon), {
                          class: normalizeClass(unref(nsIcon).m("delete"))
                        }, {
                          default: withCtx(() => [
                            createVNode(unref(delete_default))
                          ]),
                          _: 1
                        }, 8, ["class"])
                      ], 10, _hoisted_6)) : createCommentVNode("v-if", true)
                    ], 2)) : createCommentVNode("v-if", true)
                  ])
                ], 42, _hoisted_1$7);
              }), 128)),
              renderSlot(_ctx.$slots, "append")
            ]),
            _: 3
          }, 8, ["class", "name"]);
        };
      }
    });
    var UploadList = /* @__PURE__ */ _export_sfc$1(_sfc_main$b, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/upload/src/upload-list.vue"]]);
    const uploadDraggerProps = buildProps({
      disabled: {
        type: Boolean,
        default: false
      }
    });
    const uploadDraggerEmits = {
      file: (file) => isArray$3(file)
    };
    const _hoisted_1$6 = ["onDrop", "onDragover"];
    const COMPONENT_NAME = "ElUploadDrag";
    const __default__$5 = /* @__PURE__ */ defineComponent({
      name: COMPONENT_NAME
    });
    const _sfc_main$a = /* @__PURE__ */ defineComponent({
      ...__default__$5,
      props: uploadDraggerProps,
      emits: uploadDraggerEmits,
      setup(__props, { emit: emit2 }) {
        const uploaderContext = inject(uploadContextKey);
        if (!uploaderContext) {
          throwError(COMPONENT_NAME, "usage: <el-upload><el-upload-dragger /></el-upload>");
        }
        const ns = useNamespace("upload");
        const dragover = 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 accept = uploaderContext.accept.value;
          if (!accept) {
            emit2("file", files);
            return;
          }
          const filesFiltered = files.filter((file) => {
            const { type: type2, name } = file;
            const extension = name.includes(".") ? `.${name.split(".").pop()}` : "";
            const baseType = type2.replace(/\/.*$/, "");
            return accept.split(",").map((type22) => type22.trim()).filter((type22) => type22).some((acceptedType) => {
              if (acceptedType.startsWith(".")) {
                return extension === acceptedType;
              }
              if (/\/\*$/.test(acceptedType)) {
                return baseType === acceptedType.replace(/\/\*$/, "");
              }
              if (/^[^/]+\/[^/]+$/.test(acceptedType)) {
                return type2 === acceptedType;
              }
              return false;
            });
          });
          emit2("file", filesFiltered);
        };
        const onDragover = () => {
          if (!disabled.value)
            dragover.value = true;
        };
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).b("dragger"), unref(ns).is("dragover", dragover.value)]),
            onDrop: withModifiers(onDrop, ["prevent"]),
            onDragover: withModifiers(onDragover, ["prevent"]),
            onDragleave: _cache[0] || (_cache[0] = withModifiers(($event) => dragover.value = false, ["prevent"]))
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 42, _hoisted_1$6);
        };
      }
    });
    var UploadDragger = /* @__PURE__ */ _export_sfc$1(_sfc_main$a, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/upload/src/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 _hoisted_1$5 = ["onKeydown"];
    const _hoisted_2$4 = ["name", "multiple", "accept"];
    const __default__$4 = /* @__PURE__ */ defineComponent({
      name: "ElUploadContent",
      inheritAttrs: false
    });
    const _sfc_main$9 = /* @__PURE__ */ defineComponent({
      ...__default__$4,
      props: uploadContentProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("upload");
        const disabled = useFormDisabled();
        const requests = shallowRef({});
        const inputRef = 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$2(props.data) ? cloneDeep(props.data) : props.data;
            hookResult = await beforeUploadPromise;
            if (isPlainObject$2(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$2(data)) {
            return data(rawFile);
          }
          return data;
        };
        const doUpload = async (rawFile, beforeData) => {
          const {
            headers,
            data,
            method: method2,
            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: uid2 } = rawFile;
          const options = {
            headers: headers || {},
            withCredentials,
            file: rawFile,
            data: beforeData,
            method: method2,
            filename,
            action,
            onProgress: (evt) => {
              onProgress(evt, rawFile);
            },
            onSuccess: (res) => {
              onSuccess(res, rawFile);
              delete requests.value[uid2];
            },
            onError: (err) => {
              onError(err, rawFile);
              delete requests.value[uid2];
            }
          };
          const request = httpRequest(options);
          requests.value[uid2] = 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 ? ([uid2]) => String(file.uid) === uid2 : () => true);
          _reqs.forEach(([uid2, req]) => {
            if (req instanceof XMLHttpRequest)
              req.abort();
            delete requests.value[uid2];
          });
        };
        expose({
          abort,
          upload
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.listType), unref(ns).is("drag", _ctx.drag)]),
            tabindex: "0",
            onClick: handleClick,
            onKeydown: withKeys(withModifiers(handleKeydown, ["self"]), ["enter", "space"])
          }, [
            _ctx.drag ? (openBlock(), createBlock(UploadDragger, {
              key: 0,
              disabled: unref(disabled),
              onFile: uploadFiles
            }, {
              default: withCtx(() => [
                renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 8, ["disabled"])) : renderSlot(_ctx.$slots, "default", { key: 1 }),
            createBaseVNode("input", {
              ref_key: "inputRef",
              ref: inputRef,
              class: normalizeClass(unref(ns).e("input")),
              name: _ctx.name,
              multiple: _ctx.multiple,
              accept: _ctx.accept,
              type: "file",
              onChange: handleChange,
              onClick: _cache[0] || (_cache[0] = withModifiers(() => {
              }, ["stop"]))
            }, null, 42, _hoisted_2$4)
          ], 42, _hoisted_1$5);
        };
      }
    });
    var UploadContent = /* @__PURE__ */ _export_sfc$1(_sfc_main$9, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/upload/src/upload-content.vue"]]);
    const SCOPE$1 = "ElUpload";
    const revokeFileObjectURL = (file) => {
      var _a2;
      if ((_a2 = file.url) == null ? void 0 : _a2.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 _a2;
        (_a2 = uploadRef.value) == null ? void 0 : _a2.abort(file);
      }
      function clearFiles(states = ["ready", "uploading", "success", "fail"]) {
        uploadFiles.value = uploadFiles.value.filter((row) => !states.includes(row.status));
      }
      const handleError2 = (err, rawFile) => {
        const file = getFile(rawFile);
        if (!file)
          return;
        console.error(err);
        file.status = "fail";
        uploadFiles.value.splice(uploadFiles.value.indexOf(file), 1);
        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);
          const fileList = uploadFiles.value;
          fileList.splice(fileList.indexOf(file2), 1);
          props.onRemove(file2, fileList);
          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 _a2;
          return raw && ((_a2 = uploadRef.value) == null ? void 0 : _a2.upload(raw));
        });
      }
      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;
        });
      });
      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: handleError2,
        handleProgress,
        handleStart,
        handleSuccess,
        handleRemove,
        submit,
        revokeFileObjectURL
      };
    };
    const __default__$3 = /* @__PURE__ */ defineComponent({
      name: "ElUpload"
    });
    const _sfc_main$8 = /* @__PURE__ */ defineComponent({
      ...__default__$3,
      props: uploadProps,
      setup(__props, { expose }) {
        const props = __props;
        const disabled = useFormDisabled();
        const uploadRef = shallowRef();
        const {
          abort,
          submit,
          clearFiles,
          uploadFiles,
          handleStart,
          handleError: handleError2,
          handleRemove,
          handleSuccess,
          handleProgress,
          revokeFileObjectURL: revokeFileObjectURL2
        } = useHandlers(props, uploadRef);
        const isPictureCard = computed(() => props.listType === "picture-card");
        const uploadContentProps2 = computed(() => ({
          ...props,
          fileList: uploadFiles.value,
          onStart: handleStart,
          onProgress: handleProgress,
          onSuccess: handleSuccess,
          onError: handleError2,
          onRemove: handleRemove
        }));
        onBeforeUnmount(() => {
          uploadFiles.value.forEach(revokeFileObjectURL2);
        });
        provide(uploadContextKey, {
          accept: toRef(props, "accept")
        });
        expose({
          abort,
          submit,
          clearFiles,
          handleStart,
          handleRemove
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", null, [
            unref(isPictureCard) && _ctx.showFileList ? (openBlock(), createBlock(UploadList, {
              key: 0,
              disabled: unref(disabled),
              "list-type": _ctx.listType,
              files: unref(uploadFiles),
              "handle-preview": _ctx.onPreview,
              onRemove: unref(handleRemove)
            }, createSlots({
              append: withCtx(() => [
                createVNode(UploadContent, mergeProps({
                  ref_key: "uploadRef",
                  ref: uploadRef
                }, unref(uploadContentProps2)), {
                  default: withCtx(() => [
                    _ctx.$slots.trigger ? renderSlot(_ctx.$slots, "trigger", { key: 0 }) : createCommentVNode("v-if", true),
                    !_ctx.$slots.trigger && _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 1 }) : createCommentVNode("v-if", true)
                  ]),
                  _: 3
                }, 16)
              ]),
              _: 2
            }, [
              _ctx.$slots.file ? {
                name: "default",
                fn: withCtx(({ file }) => [
                  renderSlot(_ctx.$slots, "file", { file })
                ])
              } : void 0
            ]), 1032, ["disabled", "list-type", "files", "handle-preview", "onRemove"])) : createCommentVNode("v-if", true),
            !unref(isPictureCard) || unref(isPictureCard) && !_ctx.showFileList ? (openBlock(), createBlock(UploadContent, mergeProps({
              key: 1,
              ref_key: "uploadRef",
              ref: uploadRef
            }, unref(uploadContentProps2)), {
              default: withCtx(() => [
                _ctx.$slots.trigger ? renderSlot(_ctx.$slots, "trigger", { key: 0 }) : createCommentVNode("v-if", true),
                !_ctx.$slots.trigger && _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 1 }) : createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 16)) : createCommentVNode("v-if", true),
            _ctx.$slots.trigger ? renderSlot(_ctx.$slots, "default", { key: 2 }) : createCommentVNode("v-if", true),
            renderSlot(_ctx.$slots, "tip"),
            !unref(isPictureCard) && _ctx.showFileList ? (openBlock(), createBlock(UploadList, {
              key: 3,
              disabled: unref(disabled),
              "list-type": _ctx.listType,
              files: unref(uploadFiles),
              "handle-preview": _ctx.onPreview,
              onRemove: unref(handleRemove)
            }, createSlots({ _: 2 }, [
              _ctx.$slots.file ? {
                name: "default",
                fn: withCtx(({ file }) => [
                  renderSlot(_ctx.$slots, "file", { file })
                ])
              } : void 0
            ]), 1032, ["disabled", "list-type", "files", "handle-preview", "onRemove"])) : createCommentVNode("v-if", true)
          ]);
        };
      }
    });
    var Upload = /* @__PURE__ */ _export_sfc$1(_sfc_main$8, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/upload/src/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 FontGap = 3;
    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) {
        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 = Array.isArray(content) ? content : [content];
          contents == null ? void 0 : contents.forEach((item, index2) => {
            ctx.fillText(item != null ? item : "", contentWidth / 2, index2 * (mergedFontSize + 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(x2, y) {
          const targetX = x2 * Math.cos(angle) - y * Math.sin(angle);
          const targetY = x2 * Math.sin(angle) + y * Math.cos(angle);
          return [targetX, targetY];
        }
        let left2 = 0;
        let right2 = 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(([x2, y]) => {
          const [targetX, targetY] = getRotatePos(x2, y);
          left2 = Math.min(left2, targetX);
          right2 = Math.max(right2, targetX);
          top = Math.min(top, targetY);
          bottom = Math.max(bottom, targetY);
        });
        const cutLeft = left2 + realMaxSize / 2;
        const cutTop = top + realMaxSize / 2;
        const cutWidth = right2 - left2;
        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__$2 = /* @__PURE__ */ defineComponent({
      name: "ElWatermark"
    });
    const _sfc_main$7 = /* @__PURE__ */ defineComponent({
      ...__default__$2,
      props: watermarkProps,
      setup(__props) {
        const props = __props;
        const style = {
          position: "relative"
        };
        const color = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.font) == null ? void 0 : _a2.color) != null ? _b : "rgba(0,0,0,.15)";
        });
        const fontSize = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.font) == null ? void 0 : _a2.fontSize) != null ? _b : 16;
        });
        const fontWeight = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.font) == null ? void 0 : _a2.fontWeight) != null ? _b : "normal";
        });
        const fontStyle = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.font) == null ? void 0 : _a2.fontStyle) != null ? _b : "normal";
        });
        const fontFamily = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.font) == null ? void 0 : _a2.fontFamily) != null ? _b : "sans-serif";
        });
        const textAlign = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.font) == null ? void 0 : _a2.textAlign) != null ? _b : "center";
        });
        const textBaseline = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.font) == null ? void 0 : _a2.textBaseline) != null ? _b : "top";
        });
        const gapX = computed(() => props.gap[0]);
        const gapY = computed(() => props.gap[1]);
        const gapXCenter = computed(() => gapX.value / 2);
        const gapYCenter = computed(() => gapY.value / 2);
        const offsetLeft = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.offset) == null ? void 0 : _a2[0]) != null ? _b : gapXCenter.value;
        });
        const offsetTop = computed(() => {
          var _a2, _b;
          return (_b = (_a2 = props.offset) == null ? void 0 : _a2[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 = shallowRef(null);
        const watermarkRef = shallowRef();
        const stopObservation = ref(false);
        const destroyWatermark = () => {
          if (watermarkRef.value) {
            watermarkRef.value.remove();
            watermarkRef.value = void 0;
          }
        };
        const appendWatermark = (base64Url, markWidth) => {
          var _a2;
          if (containerRef.value && watermarkRef.value) {
            stopObservation.value = true;
            watermarkRef.value.setAttribute("style", getStyleStr({
              ...getMarkStyle(),
              backgroundImage: `url('${base64Url}')`,
              backgroundSize: `${Math.floor(markWidth)}px`
            }));
            (_a2 = containerRef.value) == null ? void 0 : _a2.append(watermarkRef.value);
            setTimeout(() => {
              stopObservation.value = false;
            });
          }
        };
        const getMarkSize = (ctx) => {
          let defaultWidth = 120;
          let defaultHeight = 64;
          const image = props.image;
          const content = props.content;
          const width = props.width;
          const height = props.height;
          if (!image && ctx.measureText) {
            ctx.font = `${Number(fontSize.value)}px ${fontFamily.value}`;
            const contents = Array.isArray(content) ? content : [content];
            const sizes = contents.map((item) => {
              const metrics = ctx.measureText(item);
              return [
                metrics.width,
                metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent
              ];
            });
            defaultWidth = Math.ceil(Math.max(...sizes.map((size2) => size2[0])));
            defaultHeight = Math.ceil(Math.max(...sizes.map((size2) => size2[1]))) * contents.length + (contents.length - 1) * FontGap;
          }
          return [width != null ? width : defaultWidth, height != null ? height : defaultHeight];
        };
        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] = 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,
                textAlign: textAlign.value,
                textBaseline: textBaseline.value
              }, gapX.value, gapY.value);
              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);
            }
          }
        };
        onMounted(() => {
          renderWatermark();
        });
        watch(() => props, () => {
          renderWatermark();
        }, {
          deep: true,
          flush: "post"
        });
        onBeforeUnmount(() => {
          destroyWatermark();
        });
        const onMutate = (mutations) => {
          if (stopObservation.value) {
            return;
          }
          mutations.forEach((mutation) => {
            if (reRendering(mutation, watermarkRef.value)) {
              destroyWatermark();
              renderWatermark();
            }
          });
        };
        useMutationObserver(containerRef, onMutate, {
          attributes: true
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div", {
            ref_key: "containerRef",
            ref: containerRef,
            style: normalizeStyle([style])
          }, [
            renderSlot(_ctx.$slots, "default")
          ], 4);
        };
      }
    });
    var Watermark = /* @__PURE__ */ _export_sfc$1(_sfc_main$7, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/watermark/src/watermark.vue"]]);
    const ElWatermark = withInstall(Watermark);
    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,
      ElColorPicker,
      ElConfigProvider,
      ElContainer,
      ElAside,
      ElFooter,
      ElHeader,
      ElMain,
      ElDatePicker,
      ElDescriptions,
      ElDescriptionsItem,
      ElDialog,
      ElDivider,
      ElDrawer,
      ElDropdown,
      ElDropdownItem,
      ElDropdownMenu,
      ElEmpty,
      ElForm,
      ElFormItem,
      ElIcon,
      ElImage,
      ElImageViewer,
      ElInput,
      ElInputNumber,
      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,
      ElTooltipV2,
      ElTransfer,
      ElTree,
      ElTreeSelect,
      ElTreeV2,
      ElUpload,
      ElWatermark
    ];
    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 _a2, _b;
        const { type: type2, default: defaultValue } = option;
        const attrVal = el.getAttribute(`infinite-scroll-${name}`);
        let value = (_b = (_a2 = instance[attrVal]) != null ? _a2 : attrVal) != null ? _b : defaultValue;
        value = value === "false" ? false : value;
        value = type2(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;
        if (!isFunction$2(cb)) {
          throwError(SCOPE, "'v-infinite-scroll' binding value must be a function");
        }
        await 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) {
        const { container, onScroll } = el[SCOPE];
        container == null ? void 0 : container.removeEventListener("scroll", onScroll);
        destroyObserver(el);
      },
      async updated(el) {
        if (!el[SCOPE]) {
          await nextTick();
        } else {
          const { containerEl, cb, observer } = el[SCOPE];
          if (containerEl.clientHeight && observer) {
            checkFull(el, cb);
          }
        }
      }
    };
    const _InfiniteScroll = InfiniteScroll;
    _InfiniteScroll.install = (app) => {
      app.directive("InfiniteScroll", _InfiniteScroll);
    };
    const ElInfiniteScroll = _InfiniteScroll;
    function createLoadingComponent(options) {
      let afterLeaveTimer;
      const afterLeaveFlag = ref(false);
      const data = 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 _a2, _b;
        (_b = (_a2 = vm.$el) == null ? void 0 : _a2.parentNode) == null ? void 0 : _b.removeChild(vm.$el);
      }
      function close2() {
        var _a2;
        if (options.beforeClose && !options.beforeClose())
          return;
        afterLeaveFlag.value = true;
        clearTimeout(afterLeaveTimer);
        afterLeaveTimer = window.setTimeout(handleAfterLeave, 400);
        data.visible = false;
        (_a2 = options.closed) == null ? void 0 : _a2.call(options);
      }
      function handleAfterLeave() {
        if (!afterLeaveFlag.value)
          return;
        const target = data.parent;
        afterLeaveFlag.value = false;
        target.vLoadingAddClassList = void 0;
        destroySelf();
      }
      const elLoadingComponent = /* @__PURE__ */ defineComponent({
        name: "ElLoading",
        setup(_2, { expose }) {
          const { ns, zIndex: zIndex2 } = useGlobalComponentSettings("loading");
          expose({
            ns,
            zIndex: zIndex2
          });
          return () => {
            const svg = data.spinner || data.svg;
            const spinner = h$1("svg", {
              class: "circular",
              viewBox: data.svgViewBox ? data.svgViewBox : "0 0 50 50",
              ...svg ? { innerHTML: svg } : {}
            }, [
              h$1("circle", {
                class: "path",
                cx: "25",
                cy: "25",
                r: "20",
                fill: "none"
              })
            ]);
            const spinnerText = data.text ? h$1("p", { class: ns.b("text") }, [data.text]) : void 0;
            return h$1(Transition, {
              name: ns.b("fade"),
              onAfterLeave: handleAfterLeave
            }, {
              default: withCtx(() => [
                withDirectives(createVNode("div", {
                  style: {
                    backgroundColor: data.background || ""
                  },
                  class: [
                    ns.b("mask"),
                    data.customClass,
                    data.fullscreen ? "is-fullscreen" : ""
                  ]
                }, [
                  h$1("div", {
                    class: ns.b("spinner")
                  }, [spinner, spinnerText])
                ]), [[vShow, data.visible]])
              ])
            });
          };
        }
      });
      const loadingInstance = createApp(elLoadingComponent);
      const vm = loadingInstance.mount(document.createElement("div"));
      return {
        ...toRefs(data),
        setText,
        removeElLoadingChild,
        close: close2,
        handleAfterLeave,
        vm,
        get $el() {
          return vm.$el;
        }
      };
    }
    let fullscreenInstance = void 0;
    const Loading = function(options = {}) {
      if (!isClient)
        return void 0;
      const resolved = resolveOptions(options);
      if (resolved.fullscreen && fullscreenInstance) {
        return fullscreenInstance;
      }
      const instance = createLoadingComponent({
        ...resolved,
        closed: () => {
          var _a2;
          (_a2 = resolved.closed) == null ? void 0 : _a2.call(resolved);
          if (resolved.fullscreen)
            fullscreenInstance = void 0;
        }
      });
      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);
      nextTick(() => instance.visible.value = resolved.visible);
      if (resolved.fullscreen) {
        fullscreenInstance = instance;
      }
      return instance;
    };
    const resolveOptions = (options) => {
      var _a2, _b, _c, _d;
      let target;
      if (isString$1(options.target)) {
        target = (_a2 = document.querySelector(options.target)) != null ? _a2 : 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,
        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 nextTick();
        for (const property2 of ["top", "left"]) {
          const scroll = property2 === "top" ? "scrollTop" : "scrollLeft";
          maskStyle[property2] = `${options.target.getBoundingClientRect()[property2] + document.body[scroll] + document.documentElement[scroll] - Number.parseInt(getStyle(document.body, `margin-${property2}`), 10)}px`;
        }
        for (const property2 of ["height", "width"]) {
          maskStyle[property2] = `${options.target.getBoundingClientRect()[property2]}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"));
      }
    };
    const INSTANCE_KEY = Symbol("ElLoading");
    const createInstance = (el, binding) => {
      var _a2, _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;
        if (data)
          return ref(data);
        else
          return data;
      };
      const getProp2 = (name) => resolveExpression(getBindingProp(name) || el.getAttribute(`element-loading-${hyphenate(name)}`));
      const fullscreen = (_a2 = getBindingProp("fullscreen")) != null ? _a2 : binding.modifiers.fullscreen;
      const options = {
        text: getProp2("text"),
        svg: getProp2("svg"),
        svgViewBox: getProp2("svgViewBox"),
        spinner: getProp2("spinner"),
        background: getProp2("background"),
        customClass: getProp2("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
      };
      el[INSTANCE_KEY] = {
        options,
        instance: Loading(options)
      };
    };
    const updateOptions = (newOptions, originalOptions) => {
      for (const key of Object.keys(originalOptions)) {
        if (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.oldValue !== binding.value) {
          if (binding.value && !binding.oldValue) {
            createInstance(el, binding);
          } else if (binding.value && binding.oldValue) {
            if (isObject$1(binding.value))
              updateOptions(binding.value, instance.options);
          } else {
            instance == null ? void 0 : instance.instance.close();
          }
        }
      },
      unmounted(el) {
        var _a2;
        (_a2 = el[INSTANCE_KEY]) == null ? void 0 : _a2.instance.close();
      }
    };
    const ElLoading = {
      install(app) {
        app.directive("loading", vLoading);
        app.config.globalProperties.$loading = Loading;
      },
      directive: vLoading,
      service: Loading
    };
    const messageTypes = ["success", "info", "warning", "error"];
    const messageDefaults = mutable({
      customClass: "",
      center: false,
      dangerouslyUseHTMLString: false,
      duration: 3e3,
      icon: void 0,
      id: "",
      message: "",
      onClose: void 0,
      showClose: false,
      type: "info",
      offset: 16,
      zIndex: 0,
      grouping: false,
      repeatNum: 1,
      appendTo: isClient ? document.body : void 0
    });
    const messageProps = buildProps({
      customClass: {
        type: String,
        default: messageDefaults.customClass
      },
      center: {
        type: Boolean,
        default: messageDefaults.center
      },
      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),
        required: false
      },
      showClose: {
        type: Boolean,
        default: messageDefaults.showClose
      },
      type: {
        type: String,
        values: messageTypes,
        default: messageDefaults.type
      },
      offset: {
        type: Number,
        default: messageDefaults.offset
      },
      zIndex: {
        type: Number,
        default: messageDefaults.zIndex
      },
      grouping: {
        type: Boolean,
        default: messageDefaults.grouping
      },
      repeatNum: {
        type: Number,
        default: messageDefaults.repeatNum
      }
    });
    const messageEmits = {
      destroy: () => true
    };
    const instances = shallowReactive([]);
    const getInstance = (id) => {
      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) => {
      const { prev } = getInstance(id);
      if (!prev)
        return 0;
      return prev.vm.exposed.bottom.value;
    };
    const getOffsetOrSpace = (id, offset2) => {
      const idx = instances.findIndex((instance) => instance.id === id);
      return idx > 0 ? 20 : offset2;
    };
    const _hoisted_1$4 = ["id"];
    const _hoisted_2$3 = ["innerHTML"];
    const __default__$1 = /* @__PURE__ */ defineComponent({
      name: "ElMessage"
    });
    const _sfc_main$6 = /* @__PURE__ */ defineComponent({
      ...__default__$1,
      props: messageProps,
      emits: messageEmits,
      setup(__props, { expose }) {
        const props = __props;
        const { Close } = TypeComponents;
        const { ns, zIndex: zIndex2 } = useGlobalComponentSettings("message");
        const { currentZIndex, nextZIndex } = zIndex2;
        const messageRef = ref();
        const visible = ref(false);
        const height = ref(0);
        let stopTimer = void 0;
        const badgeType = computed(() => props.type ? props.type === "error" ? "danger" : props.type : "info");
        const typeClass = computed(() => {
          const type2 = props.type;
          return { [ns.bm("icon", type2)]: type2 && TypeComponentsMap[type2] };
        });
        const iconComponent = computed(() => props.icon || TypeComponentsMap[props.type] || "");
        const lastOffset = computed(() => getLastOffset(props.id));
        const offset2 = computed(() => getOffsetOrSpace(props.id, props.offset) + lastOffset.value);
        const bottom = computed(() => height.value + offset2.value);
        const customStyle = computed(() => ({
          top: `${offset2.value}px`,
          zIndex: currentZIndex.value
        }));
        function startTimer() {
          if (props.duration === 0)
            return;
          ({ stop: stopTimer } = useTimeoutFn(() => {
            close2();
          }, props.duration));
        }
        function clearTimer() {
          stopTimer == null ? void 0 : stopTimer();
        }
        function close2() {
          visible.value = false;
        }
        function keydown({ code }) {
          if (code === EVENT_CODE.esc) {
            close2();
          }
        }
        onMounted(() => {
          startTimer();
          nextZIndex();
          visible.value = true;
        });
        watch(() => props.repeatNum, () => {
          clearTimer();
          startTimer();
        });
        useEventListener(document, "keydown", keydown);
        useResizeObserver(messageRef, () => {
          height.value = messageRef.value.getBoundingClientRect().height;
        });
        expose({
          visible,
          bottom,
          close: close2
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Transition, {
            name: unref(ns).b("fade"),
            onBeforeLeave: _ctx.onClose,
            onAfterLeave: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("destroy")),
            persisted: ""
          }, {
            default: withCtx(() => [
              withDirectives(createBaseVNode("div", {
                id: _ctx.id,
                ref_key: "messageRef",
                ref: messageRef,
                class: normalizeClass([
                  unref(ns).b(),
                  { [unref(ns).m(_ctx.type)]: _ctx.type && !_ctx.icon },
                  unref(ns).is("center", _ctx.center),
                  unref(ns).is("closable", _ctx.showClose),
                  _ctx.customClass
                ]),
                style: normalizeStyle(unref(customStyle)),
                role: "alert",
                onMouseenter: clearTimer,
                onMouseleave: startTimer
              }, [
                _ctx.repeatNum > 1 ? (openBlock(), createBlock(unref(ElBadge), {
                  key: 0,
                  value: _ctx.repeatNum,
                  type: unref(badgeType),
                  class: normalizeClass(unref(ns).e("badge"))
                }, null, 8, ["value", "type", "class"])) : createCommentVNode("v-if", true),
                unref(iconComponent) ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 1,
                  class: normalizeClass([unref(ns).e("icon"), unref(typeClass)])
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
                  ]),
                  _: 1
                }, 8, ["class"])) : createCommentVNode("v-if", true),
                renderSlot(_ctx.$slots, "default", {}, () => [
                  !_ctx.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", {
                    key: 0,
                    class: normalizeClass(unref(ns).e("content"))
                  }, toDisplayString(_ctx.message), 3)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
                    createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
                    createBaseVNode("p", {
                      class: normalizeClass(unref(ns).e("content")),
                      innerHTML: _ctx.message
                    }, null, 10, _hoisted_2$3)
                  ], 2112))
                ]),
                _ctx.showClose ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 2,
                  class: normalizeClass(unref(ns).e("closeBtn")),
                  onClick: withModifiers(close2, ["stop"])
                }, {
                  default: withCtx(() => [
                    createVNode(unref(Close))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
              ], 46, _hoisted_1$4), [
                [vShow, visible.value]
              ])
            ]),
            _: 3
          }, 8, ["name", "onBeforeLeave"]);
        };
      }
    });
    var MessageConstructor = /* @__PURE__ */ _export_sfc$1(_sfc_main$6, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/message/src/message.vue"]]);
    let seed$1 = 1;
    const normalizeOptions = (params) => {
      const options = !params || isString$1(params) || isVNode(params) || isFunction$2(params) ? { message: params } : params;
      const normalized = {
        ...messageDefaults,
        ...options
      };
      if (!normalized.appendTo) {
        normalized.appendTo = document.body;
      } else if (isString$1(normalized.appendTo)) {
        let appendTo = document.querySelector(normalized.appendTo);
        if (!isElement$1(appendTo)) {
          appendTo = document.body;
        }
        normalized.appendTo = appendTo;
      }
      return normalized;
    };
    const closeMessage = (instance) => {
      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: () => {
          render(null, container);
        }
      };
      const vnode = createVNode(MessageConstructor, props, isFunction$2(props.message) || isVNode(props.message) ? {
        default: isFunction$2(props.message) ? props.message : () => props.message
      } : null);
      vnode.appContext = context || message._context;
      render(vnode, container);
      appendTo.appendChild(container.firstElementChild);
      const vm = vnode.component;
      const handler = {
        close: () => {
          vm.exposed.visible.value = false;
        }
      };
      const instance = {
        id,
        vnode,
        vm,
        handler,
        props: vnode.component.props
      };
      return instance;
    };
    const message = (options = {}, context) => {
      if (!isClient)
        return { close: () => void 0 };
      if (isNumber(messageConfig.max) && instances.length >= messageConfig.max) {
        return { close: () => void 0 };
      }
      const normalized = normalizeOptions(options);
      if (normalized.grouping && instances.length) {
        const instance2 = instances.find(({ vnode: vm }) => {
          var _a2;
          return ((_a2 = vm.props) == null ? void 0 : _a2.message) === normalized.message;
        });
        if (instance2) {
          instance2.props.repeatNum += 1;
          instance2.props.type = normalized.type;
          return instance2.handler;
        }
      }
      const instance = createMessage(normalized, context);
      instances.push(instance);
      return instance.handler;
    };
    messageTypes.forEach((type2) => {
      message[type2] = (options = {}, appContext) => {
        const normalized = normalizeOptions(options);
        return message({ ...normalized, type: type2 }, appContext);
      };
    });
    function closeAll$1(type2) {
      for (const instance of instances) {
        if (!type2 || type2 === instance.props.type) {
          instance.handler.close();
        }
      }
    }
    message.closeAll = closeAll$1;
    message._context = null;
    const ElMessage = withInstallFunction(message, "$message");
    const _sfc_main$5 = /* @__PURE__ */ 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,
        roundButton: {
          default: false,
          type: Boolean
        },
        container: {
          type: String,
          default: "body"
        },
        boxType: {
          type: String,
          default: ""
        }
      },
      emits: ["vanish", "action"],
      setup(props, { emit: emit2 }) {
        const {
          locale,
          zIndex: zIndex2,
          ns,
          size: btnSize
        } = useGlobalComponentSettings("message-box", computed(() => props.buttonSize));
        const { t } = locale;
        const { nextZIndex } = zIndex2;
        const visible = ref(false);
        const state = reactive({
          autofocus: true,
          beforeClose: null,
          callback: null,
          cancelButtonText: "",
          cancelButtonClass: "",
          confirmButtonText: "",
          confirmButtonClass: "",
          customClass: "",
          customStyle: {},
          dangerouslyUseHTMLString: false,
          distinguishCancelAndClose: false,
          icon: "",
          inputPattern: null,
          inputPlaceholder: "",
          inputType: "text",
          inputValue: null,
          inputValidator: null,
          inputErrorMessage: "",
          message: null,
          modalFade: true,
          modalClass: "",
          showCancelButton: false,
          showConfirmButton: true,
          type: "",
          title: void 0,
          showInput: false,
          action: "",
          confirmButtonLoading: false,
          cancelButtonLoading: false,
          confirmButtonDisabled: false,
          editorErrorMessage: "",
          validateError: false,
          zIndex: nextZIndex()
        });
        const typeClass = computed(() => {
          const type2 = state.type;
          return { [ns.bm("icon", type2)]: type2 && TypeComponentsMap[type2] };
        });
        const contentId = useId();
        const inputId = useId();
        const iconComponent = computed(() => state.icon || TypeComponentsMap[state.type] || "");
        const hasMessage = computed(() => !!state.message);
        const rootRef = ref();
        const headerRef = ref();
        const focusStartRef = ref();
        const inputRef = ref();
        const confirmRef = ref();
        const confirmButtonClasses = computed(() => state.confirmButtonClass);
        watch(() => state.inputValue, async (val) => {
          await nextTick();
          if (props.boxType === "prompt" && val !== null) {
            validate();
          }
        }, { immediate: true });
        watch(() => visible.value, (val) => {
          var _a2, _b;
          if (val) {
            if (props.boxType !== "prompt") {
              if (state.autofocus) {
                focusStartRef.value = (_b = (_a2 = confirmRef.value) == null ? void 0 : _a2.$el) != null ? _b : rootRef.value;
              } else {
                focusStartRef.value = rootRef.value;
              }
            }
            state.zIndex = nextZIndex();
          }
          if (props.boxType !== "prompt")
            return;
          if (val) {
            nextTick().then(() => {
              var _a22;
              if (inputRef.value && inputRef.value.$el) {
                if (state.autofocus) {
                  focusStartRef.value = (_a22 = getInputElement()) != null ? _a22 : rootRef.value;
                } else {
                  focusStartRef.value = rootRef.value;
                }
              }
            });
          } else {
            state.editorErrorMessage = "";
            state.validateError = false;
          }
        });
        const draggable2 = computed(() => props.draggable);
        useDraggable(rootRef, headerRef, draggable2);
        onMounted(async () => {
          await nextTick();
          if (props.closeOnHashChange) {
            window.addEventListener("hashchange", doClose);
          }
        });
        onBeforeUnmount(() => {
          if (props.closeOnHashChange) {
            window.removeEventListener("hashchange", doClose);
          }
        });
        function doClose() {
          if (!visible.value)
            return;
          visible.value = false;
          nextTick(() => {
            if (state.action)
              emit2("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 _a2;
          if (props.boxType === "prompt" && action === "confirm" && !validate()) {
            return;
          }
          state.action = action;
          if (state.beforeClose) {
            (_a2 = state.beforeClose) == null ? void 0 : _a2.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 (typeof inputValidator === "function") {
              const validateResult = inputValidator(state.inputValue);
              if (validateResult === false) {
                state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
                state.validateError = true;
                return false;
              }
              if (typeof validateResult === "string") {
                state.editorErrorMessage = validateResult;
                state.validateError = true;
                return false;
              }
            }
          }
          state.editorErrorMessage = "";
          state.validateError = false;
          return true;
        };
        const getInputElement = () => {
          const inputRefs = inputRef.value.$refs;
          return inputRefs.input || inputRefs.textarea;
        };
        const handleClose = () => {
          handleAction("close");
        };
        const onCloseRequested = () => {
          if (props.closeOnPressEscape) {
            handleClose();
          }
        };
        if (props.lockScroll) {
          useLockscreen(visible);
        }
        return {
          ...toRefs(state),
          ns,
          overlayEvent,
          visible,
          hasMessage,
          typeClass,
          contentId,
          inputId,
          btnSize,
          iconComponent,
          confirmButtonClasses,
          rootRef,
          focusStartRef,
          headerRef,
          inputRef,
          confirmRef,
          doClose,
          handleClose,
          onCloseRequested,
          handleWrapperClick,
          handleInputEnter,
          handleAction,
          t
        };
      }
    });
    const _hoisted_1$3 = ["aria-label", "aria-describedby"];
    const _hoisted_2$2 = ["aria-label"];
    const _hoisted_3$1 = ["id"];
    function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_icon = resolveComponent("el-icon");
      const _component_close = resolveComponent("close");
      const _component_el_input = resolveComponent("el-input");
      const _component_el_button = resolveComponent("el-button");
      const _component_el_focus_trap = resolveComponent("el-focus-trap");
      const _component_el_overlay = resolveComponent("el-overlay");
      return openBlock(), createBlock(Transition, {
        name: "fade-in-linear",
        onAfterLeave: _cache[11] || (_cache[11] = ($event) => _ctx.$emit("vanish")),
        persisted: ""
      }, {
        default: withCtx(() => [
          withDirectives(createVNode(_component_el_overlay, {
            "z-index": _ctx.zIndex,
            "overlay-class": [_ctx.ns.is("message-box"), _ctx.modalClass],
            mask: _ctx.modal
          }, {
            default: withCtx(() => [
              createBaseVNode("div", {
                role: "dialog",
                "aria-label": _ctx.title,
                "aria-modal": "true",
                "aria-describedby": !_ctx.showInput ? _ctx.contentId : void 0,
                class: normalizeClass(`${_ctx.ns.namespace.value}-overlay-message-box`),
                onClick: _cache[8] || (_cache[8] = (...args) => _ctx.overlayEvent.onClick && _ctx.overlayEvent.onClick(...args)),
                onMousedown: _cache[9] || (_cache[9] = (...args) => _ctx.overlayEvent.onMousedown && _ctx.overlayEvent.onMousedown(...args)),
                onMouseup: _cache[10] || (_cache[10] = (...args) => _ctx.overlayEvent.onMouseup && _ctx.overlayEvent.onMouseup(...args))
              }, [
                createVNode(_component_el_focus_trap, {
                  loop: "",
                  trapped: _ctx.visible,
                  "focus-trap-el": _ctx.rootRef,
                  "focus-start-el": _ctx.focusStartRef,
                  onReleaseRequested: _ctx.onCloseRequested
                }, {
                  default: withCtx(() => [
                    createBaseVNode("div", {
                      ref: "rootRef",
                      class: normalizeClass([
                        _ctx.ns.b(),
                        _ctx.customClass,
                        _ctx.ns.is("draggable", _ctx.draggable),
                        { [_ctx.ns.m("center")]: _ctx.center }
                      ]),
                      style: normalizeStyle(_ctx.customStyle),
                      tabindex: "-1",
                      onClick: _cache[7] || (_cache[7] = withModifiers(() => {
                      }, ["stop"]))
                    }, [
                      _ctx.title !== null && _ctx.title !== void 0 ? (openBlock(), createElementBlock("div", {
                        key: 0,
                        ref: "headerRef",
                        class: normalizeClass(_ctx.ns.e("header"))
                      }, [
                        createBaseVNode("div", {
                          class: normalizeClass(_ctx.ns.e("title"))
                        }, [
                          _ctx.iconComponent && _ctx.center ? (openBlock(), createBlock(_component_el_icon, {
                            key: 0,
                            class: normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
                          }, {
                            default: withCtx(() => [
                              (openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
                            ]),
                            _: 1
                          }, 8, ["class"])) : createCommentVNode("v-if", true),
                          createBaseVNode("span", null, toDisplayString(_ctx.title), 1)
                        ], 2),
                        _ctx.showClose ? (openBlock(), createElementBlock("button", {
                          key: 0,
                          type: "button",
                          class: normalizeClass(_ctx.ns.e("headerbtn")),
                          "aria-label": _ctx.t("el.messagebox.close"),
                          onClick: _cache[0] || (_cache[0] = ($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel")),
                          onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers(($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel"), ["prevent"]), ["enter"]))
                        }, [
                          createVNode(_component_el_icon, {
                            class: normalizeClass(_ctx.ns.e("close"))
                          }, {
                            default: withCtx(() => [
                              createVNode(_component_close)
                            ]),
                            _: 1
                          }, 8, ["class"])
                        ], 42, _hoisted_2$2)) : createCommentVNode("v-if", true)
                      ], 2)) : createCommentVNode("v-if", true),
                      createBaseVNode("div", {
                        id: _ctx.contentId,
                        class: normalizeClass(_ctx.ns.e("content"))
                      }, [
                        createBaseVNode("div", {
                          class: normalizeClass(_ctx.ns.e("container"))
                        }, [
                          _ctx.iconComponent && !_ctx.center && _ctx.hasMessage ? (openBlock(), createBlock(_component_el_icon, {
                            key: 0,
                            class: normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
                          }, {
                            default: withCtx(() => [
                              (openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
                            ]),
                            _: 1
                          }, 8, ["class"])) : createCommentVNode("v-if", true),
                          _ctx.hasMessage ? (openBlock(), createElementBlock("div", {
                            key: 1,
                            class: normalizeClass(_ctx.ns.e("message"))
                          }, [
                            renderSlot(_ctx.$slots, "default", {}, () => [
                              !_ctx.dangerouslyUseHTMLString ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
                                key: 0,
                                for: _ctx.showInput ? _ctx.inputId : void 0
                              }, {
                                default: withCtx(() => [
                                  createTextVNode(toDisplayString(!_ctx.dangerouslyUseHTMLString ? _ctx.message : ""), 1)
                                ]),
                                _: 1
                              }, 8, ["for"])) : (openBlock(), createBlock(resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
                                key: 1,
                                for: _ctx.showInput ? _ctx.inputId : void 0,
                                innerHTML: _ctx.message
                              }, null, 8, ["for", "innerHTML"]))
                            ])
                          ], 2)) : createCommentVNode("v-if", true)
                        ], 2),
                        withDirectives(createBaseVNode("div", {
                          class: normalizeClass(_ctx.ns.e("input"))
                        }, [
                          createVNode(_component_el_input, {
                            id: _ctx.inputId,
                            ref: "inputRef",
                            modelValue: _ctx.inputValue,
                            "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => _ctx.inputValue = $event),
                            type: _ctx.inputType,
                            placeholder: _ctx.inputPlaceholder,
                            "aria-invalid": _ctx.validateError,
                            class: normalizeClass({ invalid: _ctx.validateError }),
                            onKeydown: withKeys(_ctx.handleInputEnter, ["enter"])
                          }, null, 8, ["id", "modelValue", "type", "placeholder", "aria-invalid", "class", "onKeydown"]),
                          createBaseVNode("div", {
                            class: normalizeClass(_ctx.ns.e("errormsg")),
                            style: normalizeStyle({
                              visibility: !!_ctx.editorErrorMessage ? "visible" : "hidden"
                            })
                          }, toDisplayString(_ctx.editorErrorMessage), 7)
                        ], 2), [
                          [vShow, _ctx.showInput]
                        ])
                      ], 10, _hoisted_3$1),
                      createBaseVNode("div", {
                        class: normalizeClass(_ctx.ns.e("btns"))
                      }, [
                        _ctx.showCancelButton ? (openBlock(), createBlock(_component_el_button, {
                          key: 0,
                          loading: _ctx.cancelButtonLoading,
                          class: normalizeClass([_ctx.cancelButtonClass]),
                          round: _ctx.roundButton,
                          size: _ctx.btnSize,
                          onClick: _cache[3] || (_cache[3] = ($event) => _ctx.handleAction("cancel")),
                          onKeydown: _cache[4] || (_cache[4] = withKeys(withModifiers(($event) => _ctx.handleAction("cancel"), ["prevent"]), ["enter"]))
                        }, {
                          default: withCtx(() => [
                            createTextVNode(toDisplayString(_ctx.cancelButtonText || _ctx.t("el.messagebox.cancel")), 1)
                          ]),
                          _: 1
                        }, 8, ["loading", "class", "round", "size"])) : createCommentVNode("v-if", true),
                        withDirectives(createVNode(_component_el_button, {
                          ref: "confirmRef",
                          type: "primary",
                          loading: _ctx.confirmButtonLoading,
                          class: normalizeClass([_ctx.confirmButtonClasses]),
                          round: _ctx.roundButton,
                          disabled: _ctx.confirmButtonDisabled,
                          size: _ctx.btnSize,
                          onClick: _cache[5] || (_cache[5] = ($event) => _ctx.handleAction("confirm")),
                          onKeydown: _cache[6] || (_cache[6] = withKeys(withModifiers(($event) => _ctx.handleAction("confirm"), ["prevent"]), ["enter"]))
                        }, {
                          default: withCtx(() => [
                            createTextVNode(toDisplayString(_ctx.confirmButtonText || _ctx.t("el.messagebox.confirm")), 1)
                          ]),
                          _: 1
                        }, 8, ["loading", "class", "round", "disabled", "size"]), [
                          [vShow, _ctx.showConfirmButton]
                        ])
                      ], 2)
                    ], 6)
                  ]),
                  _: 3
                }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onReleaseRequested"])
              ], 42, _hoisted_1$3)
            ]),
            _: 3
          }, 8, ["z-index", "overlay-class", "mask"]), [
            [vShow, _ctx.visible]
          ])
        ]),
        _: 3
      });
    }
    var MessageBoxConstructor = /* @__PURE__ */ _export_sfc$1(_sfc_main$5, [["render", _sfc_render], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/message-box/src/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$1(props.appendTo)) {
          appendTo = props.appendTo;
        }
        if (!isElement$1(appendTo)) {
          appendTo = document.body;
        }
      }
      return appendTo;
    };
    const initInstance = (props, container, appContext = null) => {
      const vnode = createVNode(MessageBoxConstructor, props, isFunction$2(props.message) || isVNode(props.message) ? {
        default: isFunction$2(props.message) ? props.message : () => props.message
      } : null);
      vnode.appContext = appContext;
      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 = () => {
        render(null, container);
        messageInstance.delete(vm);
      };
      options.onAction = (action) => {
        const currentMsg = messageInstance.get(vm);
        let resolve2;
        if (options.showInput) {
          resolve2 = { value: vm.inputValue, action };
        } else {
          resolve2 = action;
        }
        if (options.callback) {
          options.callback(resolve2, instance.proxy);
        } else {
          if (action === "cancel" || action === "close") {
            if (options.distinguishCancelAndClose && action !== "cancel") {
              currentMsg.reject("close");
            } else {
              currentMsg.reject("cancel");
            }
          } else {
            currentMsg.resolve(resolve2);
          }
        }
      };
      const instance = initInstance(options, container, appContext);
      const vm = instance.proxy;
      for (const prop in options) {
        if (hasOwn(options, prop) && !hasOwn(vm.$props, prop)) {
          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) || isVNode(options)) {
        options = {
          message: options
        };
      } else {
        callback = options.callback;
      }
      return new Promise((resolve2, reject) => {
        const vm = showMessage(options, appContext != null ? appContext : MessageBox._context);
        messageInstance.set(vm, {
          options,
          callback,
          resolve: resolve2,
          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 (message2, 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: message2,
          type: "",
          ...MESSAGE_BOX_DEFAULT_OPTS[boxType]
        }, options, {
          boxType
        }), appContext);
      };
    }
    MessageBox.close = () => {
      messageInstance.forEach((_2, 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 = [
      "success",
      "info",
      "warning",
      "error"
    ];
    const notificationProps = buildProps({
      customClass: {
        type: String,
        default: ""
      },
      dangerouslyUseHTMLString: {
        type: Boolean,
        default: false
      },
      duration: {
        type: Number,
        default: 4500
      },
      icon: {
        type: iconPropType
      },
      id: {
        type: String,
        default: ""
      },
      message: {
        type: definePropType([String, Object]),
        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
    });
    const notificationEmits = {
      destroy: () => true
    };
    const _hoisted_1$2 = ["id"];
    const _hoisted_2$1 = ["textContent"];
    const _hoisted_3 = { key: 0 };
    const _hoisted_4 = ["innerHTML"];
    const __default__ = /* @__PURE__ */ defineComponent({
      name: "ElNotification"
    });
    const _sfc_main$4 = /* @__PURE__ */ defineComponent({
      ...__default__,
      props: notificationProps,
      emits: notificationEmits,
      setup(__props, { expose }) {
        const props = __props;
        const { ns, zIndex: zIndex2 } = useGlobalComponentSettings("notification");
        const { nextZIndex, currentZIndex } = zIndex2;
        const { Close } = CloseComponents;
        const visible = ref(false);
        let timer = void 0;
        const typeClass = computed(() => {
          const type2 = props.type;
          return type2 && TypeComponentsMap[props.type] ? ns.m(type2) : "";
        });
        const iconComponent = computed(() => {
          if (!props.type)
            return props.icon;
          return TypeComponentsMap[props.type] || props.icon;
        });
        const horizontalClass = computed(() => props.position.endsWith("right") ? "right" : "left");
        const verticalProperty = computed(() => props.position.startsWith("top") ? "top" : "bottom");
        const positionStyle = computed(() => {
          var _a2;
          return {
            [verticalProperty.value]: `${props.offset}px`,
            zIndex: (_a2 = props.zIndex) != null ? _a2 : currentZIndex.value
          };
        });
        function startTimer() {
          if (props.duration > 0) {
            ({ stop: timer } = useTimeoutFn(() => {
              if (visible.value)
                close2();
            }, props.duration));
          }
        }
        function clearTimer() {
          timer == null ? void 0 : timer();
        }
        function close2() {
          visible.value = false;
        }
        function onKeydown({ code }) {
          if (code === EVENT_CODE.delete || code === EVENT_CODE.backspace) {
            clearTimer();
          } else if (code === EVENT_CODE.esc) {
            if (visible.value) {
              close2();
            }
          } else {
            startTimer();
          }
        }
        onMounted(() => {
          startTimer();
          nextZIndex();
          visible.value = true;
        });
        useEventListener(document, "keydown", onKeydown);
        expose({
          visible,
          close: close2
        });
        return (_ctx, _cache) => {
          return openBlock(), createBlock(Transition, {
            name: unref(ns).b("fade"),
            onBeforeLeave: _ctx.onClose,
            onAfterLeave: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("destroy")),
            persisted: ""
          }, {
            default: withCtx(() => [
              withDirectives(createBaseVNode("div", {
                id: _ctx.id,
                class: normalizeClass([unref(ns).b(), _ctx.customClass, unref(horizontalClass)]),
                style: normalizeStyle(unref(positionStyle)),
                role: "alert",
                onMouseenter: clearTimer,
                onMouseleave: startTimer,
                onClick: _cache[0] || (_cache[0] = (...args) => _ctx.onClick && _ctx.onClick(...args))
              }, [
                unref(iconComponent) ? (openBlock(), createBlock(unref(ElIcon), {
                  key: 0,
                  class: normalizeClass([unref(ns).e("icon"), unref(typeClass)])
                }, {
                  default: withCtx(() => [
                    (openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
                  ]),
                  _: 1
                }, 8, ["class"])) : createCommentVNode("v-if", true),
                createBaseVNode("div", {
                  class: normalizeClass(unref(ns).e("group"))
                }, [
                  createBaseVNode("h2", {
                    class: normalizeClass(unref(ns).e("title")),
                    textContent: toDisplayString(_ctx.title)
                  }, null, 10, _hoisted_2$1),
                  withDirectives(createBaseVNode("div", {
                    class: normalizeClass(unref(ns).e("content")),
                    style: normalizeStyle(!!_ctx.title ? void 0 : { margin: 0 })
                  }, [
                    renderSlot(_ctx.$slots, "default", {}, () => [
                      !_ctx.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", _hoisted_3, toDisplayString(_ctx.message), 1)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
                        createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
                        createBaseVNode("p", { innerHTML: _ctx.message }, null, 8, _hoisted_4)
                      ], 2112))
                    ])
                  ], 6), [
                    [vShow, _ctx.message]
                  ]),
                  _ctx.showClose ? (openBlock(), createBlock(unref(ElIcon), {
                    key: 0,
                    class: normalizeClass(unref(ns).e("closeBtn")),
                    onClick: withModifiers(close2, ["stop"])
                  }, {
                    default: withCtx(() => [
                      createVNode(unref(Close))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
                ], 2)
              ], 46, _hoisted_1$2), [
                [vShow, visible.value]
              ])
            ]),
            _: 3
          }, 8, ["name", "onBeforeLeave"]);
        };
      }
    });
    var NotificationConstructor = /* @__PURE__ */ _export_sfc$1(_sfc_main$4, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/notification/src/notification.vue"]]);
    const notifications = {
      "top-left": [],
      "top-right": [],
      "bottom-left": [],
      "bottom-right": []
    };
    const GAP_SIZE = 16;
    let seed = 1;
    const notify = function(options = {}, context = null) {
      if (!isClient)
        return { close: () => void 0 };
      if (typeof options === "string" || isVNode(options)) {
        options = { message: options };
      }
      const position = options.position || "top-right";
      let verticalOffset = options.offset || 0;
      notifications[position].forEach(({ vm: vm2 }) => {
        var _a2;
        verticalOffset += (((_a2 = vm2.el) == null ? void 0 : _a2.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$1(options.appendTo)) {
        appendTo = options.appendTo;
      } else if (isString$1(options.appendTo)) {
        appendTo = document.querySelector(options.appendTo);
      }
      if (!isElement$1(appendTo)) {
        appendTo = document.body;
      }
      const container = document.createElement("div");
      const vm = createVNode(NotificationConstructor, props, isVNode(props.message) ? {
        default: () => props.message
      } : null);
      vm.appContext = context != null ? context : notify._context;
      vm.props.onDestroy = () => {
        render(null, container);
      };
      render(vm, container);
      notifications[position].push({ vm });
      appendTo.appendChild(container.firstElementChild);
      return {
        close: () => {
          vm.component.exposed.visible.value = false;
        }
      };
    };
    notificationTypes.forEach((type2) => {
      notify[type2] = (options = {}) => {
        if (typeof options === "string" || isVNode(options)) {
          options = {
            message: options
          };
        }
        return notify({
          ...options,
          type: type2
        });
      };
    });
    function close(id, position, userOnClose) {
      const orientedNotifications = notifications[position];
      const idx = orientedNotifications.findIndex(({ vm: vm2 }) => {
        var _a2;
        return ((_a2 = vm2.component) == null ? void 0 : _a2.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: component2 } = orientedNotifications[i].vm;
        const pos = Number.parseInt(el.style[verticalPos], 10) - removedHeight - GAP_SIZE;
        component2.props.offset = pos;
      }
    }
    function closeAll() {
      for (const orientedNotifications of Object.values(notifications)) {
        orientedNotifications.forEach(({ vm }) => {
          vm.component.exposed.visible.value = false;
        });
      }
    }
    notify.closeAll = closeAll;
    notify._context = null;
    const ElNotification = withInstallFunction(notify, "$notify");
    var Plugins = [
      ElInfiniteScroll,
      ElLoading,
      ElMessage,
      ElMessageBox,
      ElNotification,
      ElPopoverDirective
    ];
    var installer = makeInstaller([...Components, ...Plugins]);
    const useReservStore = defineStore("reservdata", () => {
      const count = ref(0);
      const mqttstat = ref(false);
      ref("");
      const doubleCount = computed(() => count * 2);
      function increment() {
        count.value++;
      }
      return { count, mqttstat, doubleCount, increment };
    });
    const LoginPage_vue_vue_type_style_index_0_scoped_d565364c_lang = "";
    const _export_sfc = (sfc, props) => {
      const target = sfc.__vccOpts || sfc;
      for (const [key, val] of props) {
        target[key] = val;
      }
      return target;
    };
    const _withScopeId = (n) => (pushScopeId("data-v-d565364c"), n = n(), popScopeId(), n);
    const _hoisted_1$1 = { class: "custom-container" };
    const _hoisted_2 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createBaseVNode("h1", null, "Sign In", -1));
    const _sfc_main$3 = {
      __name: "LoginPage",
      setup(__props) {
        const { ipcRenderer } = window.require("electron");
        const dayjs2 = require("dayjs");
        const utc = require("dayjs/plugin/utc");
        const router2 = useRouter();
        const reservstore = useReservStore();
        const username = ref("886235000025_1");
        const password = ref("");
        const loginStat = ref(0);
        const login = () => {
          console.log(reservstore.mqttstat);
          dayjs2.extend(utc);
          dayjs2().utc().format("YYYY/MM/DD_HH:mm:ss").toString();
          var data = username.value.split("_");
          if (data.length == 2) {
            var cmd2 = {
              action: "loginVerify",
              data: {
                cid: data[0],
                userID: data[1],
                vpasswd: password.value
              }
            };
            loginStat.value = 1;
            ipcRenderer.send("cms:loginVerify", cmd2);
          }
        };
        ipcRenderer.on("cms:loginVerifyReply", (event, param) => {
          DebugLog("LoginPage  接收到 cms:loginVerifyReply : " + JSON.stringify(param));
          if (param.data.code == 200) {
            ElMessage({
              type: "success",
              message: "登錄 成功"
            });
            reservstore.mqttToken = param.data.token;
            loginStat.value = 2;
            router2.push("reserv");
          } else {
            ElMessage.error("登錄 失敗");
            loginStat.value = 0;
          }
        });
        const DebugLog = (item) => {
          ipcRenderer.send("debug-log", item);
        };
        return (_ctx, _cache) => {
          const _component_el_input = resolveComponent("el-input");
          const _component_el_form_item = resolveComponent("el-form-item");
          const _component_el_button = resolveComponent("el-button");
          const _component_el_form = resolveComponent("el-form");
          return openBlock(), createElementBlock("div", _hoisted_1$1, [
            createBaseVNode("div", null, [
              _hoisted_2,
              createVNode(_component_el_form, null, {
                default: withCtx(() => [
                  createVNode(_component_el_form_item, { label: "Username" }, {
                    default: withCtx(() => [
                      createVNode(_component_el_input, {
                        modelValue: username.value,
                        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => username.value = $event),
                        placeholder: "Enter your username"
                      }, null, 8, ["modelValue"])
                    ]),
                    _: 1
                  }),
                  createVNode(_component_el_form_item, { label: "Password" }, {
                    default: withCtx(() => [
                      createVNode(_component_el_input, {
                        modelValue: password.value,
                        "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => password.value = $event),
                        placeholder: "Enter your password",
                        type: "password"
                      }, null, 8, ["modelValue"])
                    ]),
                    _: 1
                  }),
                  createVNode(_component_el_form_item, null, {
                    default: withCtx(() => [
                      createVNode(_component_el_button, {
                        type: "primary",
                        disabled: !unref(reservstore).mqttstat || loginStat.value != 0,
                        onClick: login
                      }, {
                        default: withCtx(() => [
                          createTextVNode("Login")
                        ]),
                        _: 1
                      }, 8, ["disabled"])
                    ]),
                    _: 1
                  })
                ]),
                _: 1
              })
            ])
          ]);
        };
      }
    };
    const Login = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-d565364c"]]);
    const _hoisted_1 = /* @__PURE__ */ createBaseVNode("h1", null, "預約系統", -1);
    const _sfc_main$2 = {
      __name: "ReservMain",
      setup(__props) {
        const { ipcRenderer } = window.require("electron");
        require("@electron/remote");
        require("@electron/remote").getCurrentWindow();
        require("fs");
        const reservstore = useReservStore();
        const btnLogin = async (e) => {
          console.log("btn press");
          reservstore.increment();
          var cmd = {
            action: "setData",
            data: {
              name: "mqttstat",
              user: "",
              type: "Number",
              value: "12345"
            }
          };
          ipcRenderer.send("ipc:setData", cmd);
          var cmd1 = {
            action: "getData",
            data: {
              name: "mqttstat",
              user: "",
              type: "Number"
            }
          };
          ipcRenderer.send("ipc:getData", cmd1);
        };
        const DebugLog = (item) => {
          ipcRenderer.send("debug-log", item);
        };
        ipcRenderer.on("ipc:getDataReply", async (event, param) => {
          DebugLog("ReservMain  接收到 ipc:getDataReply : " + JSON.stringify(param));
        });
        return (_ctx, _cache) => {
          const _component_el_button = resolveComponent("el-button");
          return openBlock(), createElementBlock(Fragment, null, [
            createBaseVNode("div", null, [
              _hoisted_1,
              createBaseVNode("h1", null, "count: " + toDisplayString(unref(reservstore).count), 1)
            ]),
            createBaseVNode("div", null, [
              createVNode(_component_el_button, {
                type: "danger",
                onClick: btnLogin
              }, {
                default: withCtx(() => [
                  createTextVNode("登入")
                ]),
                _: 1
              })
            ])
          ], 64);
        };
      }
    };
    const router = createRouter({
      //history: createWebHistory(),
      history: createWebHashHistory(),
      routes: [
        { path: "/", name: "home", component: Login },
        { path: "/reserv", name: "reserv", component: _sfc_main$2 }
      ]
    });
    const index = "";
    const _sfc_main$1 = {
      __name: "BackGround",
      setup(__props) {
        const { ipcRenderer } = window.require("electron");
        require("@electron/remote");
        require("@electron/remote").getCurrentWindow();
        require("fs");
        console.log("BackGround run ......");
        const reservstore = useReservStore();
        onMounted(() => {
          console.log("onMounted...");
          ipcRenderer.send("renderer:cmd", "onMounted");
        });
        const DebugLog = (item) => {
          ipcRenderer.send("debug-log", item);
        };
        ipcRenderer.on("mqtt:connectReply", async (event, param) => {
          DebugLog("ReservMain  接收到 mqtt:connectReply : " + JSON.stringify(param));
          console.log("ReservMain  接收到 mqtt:connectReply : " + JSON.stringify(param));
          if (param.action == "mqttconnect") {
            if (param.success) {
              if (!reservstore.mqttstat) {
                ElMessage({
                  type: "success",
                  message: "MQTT連線 成功"
                });
                reservstore.mqttstat = true;
              }
            } else {
              if (reservstore.mqttstat) {
                ElMessage.error("MQTT連線 失敗");
                reservstore.mqttstat = false;
              }
            }
          }
        });
        return (_ctx, _cache) => {
          return openBlock(), createElementBlock("div");
        };
      }
    };
    const App_vue_vue_type_style_index_0_lang = "";
    const _sfc_main = {
      __name: "App",
      setup(__props) {
        return (_ctx, _cache) => {
          const _component_router_view = resolveComponent("router-view");
          return openBlock(), createElementBlock(Fragment, null, [
            createVNode(_sfc_main$1),
            createVNode(_component_router_view)
          ], 64);
        };
      }
    };
    createApp(_sfc_main).use(createPinia()).use(router).use(installer).mount("#app");
  }
});
export default require_index_001();