@factoringplus/pl-components-pack-v3 0.1.7 → 0.1.10

package/dist/pl-components-pack-v3.es.js

@@ -0,0 +1,2599 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { defineComponent, openBlock, createElementBlock, createElementVNode, warn, getCurrentInstance, computed, ref, inject, unref, mergeProps, renderSlot, shallowRef, watch, nextTick, onMounted, onUpdated, resolveComponent, withDirectives, normalizeClass, normalizeStyle, createCommentVNode, Fragment, createBlock, withCtx, resolveDynamicComponent, withModifiers, createVNode, toDisplayString, vShow, useSlots, Text, provide, reactive, toRef, createTextVNode, onUnmounted } from "vue";
+function fromPairs(pairs) {
+  var index = -1, length = pairs == null ? 0 : pairs.length, result = {};
+  while (++index < length) {
+    var pair = pairs[index];
+    result[pair[0]] = pair[1];
+  }
+  return result;
+}
+const isClient = typeof window !== "undefined";
+const isNumber = (val) => typeof val === "number";
+const NOOP = () => {
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isString = (val) => typeof val === "string";
+const isObject = (val) => val !== null && typeof val === "object";
+const isUndefined = (val) => val === void 0;
+var _export_sfc$1 = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _sfc_main$9 = defineComponent({
+  name: "CircleCheck"
+});
+const _hoisted_1$7 = {
+  class: "icon",
+  width: "200",
+  height: "200",
+  viewBox: "0 0 1024 1024",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2$5 = /* @__PURE__ */ createElementVNode("path", {
+  fill: "currentColor",
+  d: "M512 896a384 384 0 100-768 384 384 0 000 768zm0 64a448 448 0 110-896 448 448 0 010 896z"
+}, null, -1);
+const _hoisted_3$3 = /* @__PURE__ */ createElementVNode("path", {
+  fill: "currentColor",
+  d: "M745.344 361.344a32 32 0 0145.312 45.312l-288 288a32 32 0 01-45.312 0l-160-160a32 32 0 1145.312-45.312L480 626.752l265.344-265.408z"
+}, null, -1);
+const _hoisted_4$1 = [
+  _hoisted_2$5,
+  _hoisted_3$3
+];
+function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$7, _hoisted_4$1);
+}
+var circleCheck = /* @__PURE__ */ _export_sfc$1(_sfc_main$9, [["render", _sfc_render$4]]);
+const _sfc_main$8 = defineComponent({
+  name: "CircleClose"
+});
+const _hoisted_1$6 = {
+  class: "icon",
+  width: "200",
+  height: "200",
+  viewBox: "0 0 1024 1024",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2$4 = /* @__PURE__ */ createElementVNode("path", {
+  fill: "currentColor",
+  d: "M466.752 512l-90.496-90.496a32 32 0 0145.248-45.248L512 466.752l90.496-90.496a32 32 0 1145.248 45.248L557.248 512l90.496 90.496a32 32 0 11-45.248 45.248L512 557.248l-90.496 90.496a32 32 0 01-45.248-45.248L466.752 512z"
+}, null, -1);
+const _hoisted_3$2 = /* @__PURE__ */ createElementVNode("path", {
+  fill: "currentColor",
+  d: "M512 896a384 384 0 100-768 384 384 0 000 768zm0 64a448 448 0 110-896 448 448 0 010 896z"
+}, null, -1);
+const _hoisted_4 = [
+  _hoisted_2$4,
+  _hoisted_3$2
+];
+function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$6, _hoisted_4);
+}
+var circleClose = /* @__PURE__ */ _export_sfc$1(_sfc_main$8, [["render", _sfc_render$3]]);
+const _sfc_main$7 = defineComponent({
+  name: "Loading"
+});
+const _hoisted_1$5 = {
+  class: "icon",
+  width: "200",
+  height: "200",
+  viewBox: "0 0 1024 1024",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2$3 = /* @__PURE__ */ createElementVNode("path", {
+  fill: "currentColor",
+  d: "M512 64a32 32 0 0132 32v192a32 32 0 01-64 0V96a32 32 0 0132-32zm0 640a32 32 0 0132 32v192a32 32 0 11-64 0V736a32 32 0 0132-32zm448-192a32 32 0 01-32 32H736a32 32 0 110-64h192a32 32 0 0132 32zm-640 0a32 32 0 01-32 32H96a32 32 0 010-64h192a32 32 0 0132 32zM195.2 195.2a32 32 0 0145.248 0L376.32 331.008a32 32 0 01-45.248 45.248L195.2 240.448a32 32 0 010-45.248zm452.544 452.544a32 32 0 0145.248 0L828.8 783.552a32 32 0 01-45.248 45.248L647.744 692.992a32 32 0 010-45.248zM828.8 195.264a32 32 0 010 45.184L692.992 376.32a32 32 0 01-45.248-45.248l135.808-135.808a32 32 0 0145.248 0zm-452.544 452.48a32 32 0 010 45.248L240.448 828.8a32 32 0 01-45.248-45.248l135.808-135.808a32 32 0 0145.248 0z"
+}, null, -1);
+const _hoisted_3$1 = [
+  _hoisted_2$3
+];
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$5, _hoisted_3$1);
+}
+var loading = /* @__PURE__ */ _export_sfc$1(_sfc_main$7, [["render", _sfc_render$2]]);
+const _sfc_main$6 = defineComponent({
+  name: "View"
+});
+const _hoisted_1$4 = {
+  class: "icon",
+  width: "200",
+  height: "200",
+  viewBox: "0 0 1024 1024",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2$2 = /* @__PURE__ */ createElementVNode("path", {
+  fill: "currentColor",
+  d: "M512 160c320 0 512 352 512 352S832 864 512 864 0 512 0 512s192-352 512-352zm0 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 110 448 224 224 0 010-448zm0 64a160.192 160.192 0 00-160 160c0 88.192 71.744 160 160 160s160-71.808 160-160-71.744-160-160-160z"
+}, null, -1);
+const _hoisted_3 = [
+  _hoisted_2$2
+];
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$4, _hoisted_3);
+}
+var view = /* @__PURE__ */ _export_sfc$1(_sfc_main$6, [["render", _sfc_render$1]]);
+const wrapperKey = Symbol();
+const propKey = "__elPropsReservedKey";
+function buildProp(option, key) {
+  if (!isObject(option) || !!option[propKey])
+    return option;
+  const { values, required, default: defaultValue, type, validator } = option;
+  const _validator = values || validator ? (val) => {
+    let valid = false;
+    let allowedValues = [];
+    if (values) {
+      allowedValues = Array.from(values);
+      if (hasOwn(option, "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 prop = {
+    type: isObject(type) && Object.getOwnPropertySymbols(type).includes(wrapperKey) ? type[wrapperKey] : type,
+    required: !!required,
+    validator: _validator,
+    [propKey]: true
+  };
+  if (hasOwn(option, "default"))
+    prop.default = defaultValue;
+  return prop;
+}
+const buildProps = (props) => fromPairs(Object.entries(props).map(([key, option]) => [
+  key,
+  buildProp(option, key)
+]));
+const definePropType = (val) => ({ [wrapperKey]: val });
+const iconPropType = definePropType([
+  String,
+  Object,
+  Function
+]);
+const ValidateComponentsMap = {
+  validating: loading,
+  success: circleCheck,
+  error: circleClose
+};
+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 withNoopInstall = (component) => {
+  component.install = NOOP;
+  return component;
+};
+function addUnit(value, defaultUnit = "px") {
+  if (!value)
+    return "";
+  if (isString(value)) {
+    return value;
+  } else if (isNumber(value)) {
+    return `${value}${defaultUnit}`;
+  }
+}
+const UPDATE_MODEL_EVENT = "update:modelValue";
+const componentSizes = ["default", "small", "large"];
+const isKorean = (text) => /([(\uAC00-\uD7AF)|(\u3130-\u318F)])+/gi.test(text);
+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 = excludeKeys.concat(DEFAULT_EXCLUDE_KEYS);
+  const instance = getCurrentInstance();
+  if (!instance) {
+    return computed(() => ({}));
+  }
+  return computed(() => {
+    var _a;
+    return fromPairs(Object.entries((_a = instance.proxy) == null ? void 0 : _a.$attrs).filter(([key]) => !allExcludeKeys.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
+  });
+};
+const elFormKey = Symbol("elForm");
+const elFormItemKey = Symbol("elFormItem");
+const buttonGroupContextKey = Symbol("buttonGroupContextKey");
+const configProviderContextKey = Symbol();
+const useProp = (name) => {
+  const vm = getCurrentInstance();
+  return computed(() => {
+    var _a, _b;
+    return (_b = (_a = vm.proxy) == null ? void 0 : _a.$props[name]) != null ? _b : void 0;
+  });
+};
+const globalConfig = ref();
+function useGlobalConfig(key, defaultValue = void 0) {
+  const config = getCurrentInstance() ? inject(configProviderContextKey, globalConfig) : globalConfig;
+  if (key) {
+    return computed(() => {
+      var _a, _b;
+      return (_b = (_a = config.value) == null ? void 0 : _a[key]) != null ? _b : defaultValue;
+    });
+  } else {
+    return config;
+  }
+}
+const useSizeProp = buildProp({
+  type: String,
+  values: componentSizes,
+  required: false
+});
+const useSize = (fallback, ignore = {}) => {
+  const emptyRef = ref(void 0);
+  const size = ignore.prop ? emptyRef : useProp("size");
+  const globalConfig2 = ignore.global ? emptyRef : useGlobalConfig("size");
+  const form = ignore.form ? { size: void 0 } : inject(elFormKey, void 0);
+  const formItem = ignore.formItem ? { size: void 0 } : inject(elFormItemKey, void 0);
+  return computed(() => size.value || unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig2.value || "default");
+};
+const useDisabled = (fallback) => {
+  const disabled = useProp("disabled");
+  const form = inject(elFormKey, void 0);
+  return computed(() => disabled.value || unref(fallback) || (form == null ? void 0 : form.disabled) || false);
+};
+const useFormItem = () => {
+  const form = inject(elFormKey, void 0);
+  const formItem = inject(elFormItemKey, void 0);
+  return {
+    form,
+    formItem
+  };
+};
+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 useNamespace = (block) => {
+  const globalConfig2 = useGlobalConfig("namespace");
+  const namespace = computed(() => globalConfig2.value || defaultNamespace);
+  const b = (blockSuffix = "") => _bem(unref(namespace), block, blockSuffix, "", "");
+  const e = (element) => element ? _bem(unref(namespace), block, "", element, "") : "";
+  const m = (modifier) => modifier ? _bem(unref(namespace), block, "", "", modifier) : "";
+  const be = (blockSuffix, element) => blockSuffix && element ? _bem(unref(namespace), block, blockSuffix, element, "") : "";
+  const em = (element, modifier) => element && modifier ? _bem(unref(namespace), block, "", element, modifier) : "";
+  const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(unref(namespace), block, blockSuffix, "", modifier) : "";
+  const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(unref(namespace), block, blockSuffix, element, modifier) : "";
+  const is = (name, ...args) => {
+    const state = args.length >= 1 ? args[0] : true;
+    return name && state ? `${statePrefix}${name}` : "";
+  };
+  return {
+    namespace,
+    b,
+    e,
+    m,
+    be,
+    em,
+    bm,
+    bem,
+    is
+  };
+};
+const iconProps = buildProps({
+  size: {
+    type: definePropType([Number, String])
+  },
+  color: {
+    type: String
+  }
+});
+const __default__$4 = {
+  name: "ElIcon",
+  inheritAttrs: false
+};
+const _sfc_main$5 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$4), {
+  props: iconProps,
+  setup(__props) {
+    const props = __props;
+    const ns = useNamespace("icon");
+    const style = computed(() => {
+      if (!props.size && !props.color)
+        return {};
+      return {
+        fontSize: isUndefined(props.size) ? void 0 : addUnit(props.size),
+        "--color": props.color
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("i", mergeProps({
+        class: unref(ns).b(),
+        style: unref(style)
+      }, _ctx.$attrs), [
+        renderSlot(_ctx.$slots, "default")
+      ], 16);
+    };
+  }
+}));
+const ElIcon = withInstall(_sfc_main$5);
+let hiddenTextarea = void 0;
+const HIDDEN_STYLE = `
+  height:0 !important;
+  visibility:hidden !important;
+  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 = parseFloat(style.getPropertyValue("padding-bottom")) + parseFloat(style.getPropertyValue("padding-top"));
+  const borderSize = parseFloat(style.getPropertyValue("border-bottom-width")) + 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 _a;
+  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`;
+  (_a = hiddenTextarea.parentNode) == null ? void 0 : _a.removeChild(hiddenTextarea);
+  hiddenTextarea = void 0;
+  return result;
+}
+const inputProps = buildProps({
+  size: useSizeProp,
+  disabled: Boolean,
+  modelValue: {
+    type: definePropType(void 0),
+    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"
+  },
+  placeholder: {
+    type: String
+  },
+  form: {
+    type: String,
+    default: ""
+  },
+  readonly: {
+    type: Boolean,
+    default: false
+  },
+  clearable: {
+    type: Boolean,
+    default: false
+  },
+  showPassword: {
+    type: Boolean,
+    default: false
+  },
+  showWordLimit: {
+    type: Boolean,
+    default: false
+  },
+  suffixIcon: {
+    type: iconPropType,
+    default: ""
+  },
+  prefixIcon: {
+    type: iconPropType,
+    default: ""
+  },
+  label: {
+    type: String
+  },
+  tabindex: {
+    type: [Number, String]
+  },
+  validateEvent: {
+    type: Boolean,
+    default: true
+  },
+  inputStyle: {
+    type: definePropType([Object, Array, String]),
+    default: () => mutable({})
+  }
+});
+const inputEmits = {
+  [UPDATE_MODEL_EVENT]: (value) => isString(value),
+  input: (value) => isString(value),
+  change: (value) => isString(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 KeyboardEvent,
+  compositionstart: (evt) => evt instanceof CompositionEvent,
+  compositionupdate: (evt) => evt instanceof CompositionEvent,
+  compositionend: (evt) => evt instanceof CompositionEvent
+};
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const PENDANT_MAP = {
+  suffix: "append",
+  prefix: "prepend"
+};
+const _sfc_main$4 = defineComponent({
+  name: "ElInput",
+  components: { ElIcon, CircleClose: circleClose, IconView: view },
+  inheritAttrs: false,
+  props: inputProps,
+  emits: inputEmits,
+  setup(props, { slots, emit, attrs: rawAttrs }) {
+    const instance = getCurrentInstance();
+    const attrs = useAttrs();
+    const { form, formItem } = useFormItem();
+    const inputSize = useSize();
+    const inputDisabled = useDisabled();
+    const nsInput = useNamespace("input");
+    const nsTextarea = useNamespace("textarea");
+    const input2 = ref();
+    const textarea = ref();
+    const focused = ref(false);
+    const hovering = ref(false);
+    const isComposing = ref(false);
+    const passwordVisible = ref(false);
+    const _textareaCalcStyle = shallowRef(props.inputStyle);
+    const inputOrTextarea = computed(() => input2.value || textarea.value);
+    const needStatusIcon = computed(() => {
+      var _a;
+      return (_a = form == null ? void 0 : form.statusIcon) != null ? _a : false;
+    });
+    const validateState = computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
+    const validateIcon = computed(() => ValidateComponentsMap[validateState.value]);
+    const containerStyle = computed(() => rawAttrs.style);
+    const computedTextareaStyle = computed(() => [
+      props.inputStyle,
+      _textareaCalcStyle.value,
+      { resize: props.resize }
+    ]);
+    const nativeInputValue = computed(() => props.modelValue === null || props.modelValue === void 0 ? "" : String(props.modelValue));
+    const showClear = computed(() => props.clearable && !inputDisabled.value && !props.readonly && !!nativeInputValue.value && (focused.value || hovering.value));
+    const showPwdVisible = computed(() => props.showPassword && !inputDisabled.value && !props.readonly && (!!nativeInputValue.value || focused.value));
+    const isWordLimitVisible = computed(() => props.showWordLimit && !!attrs.value.maxlength && (props.type === "text" || props.type === "textarea") && !inputDisabled.value && !props.readonly && !props.showPassword);
+    const textLength = computed(() => Array.from(nativeInputValue.value).length);
+    const inputExceed = computed(() => !!isWordLimitVisible.value && textLength.value > Number(attrs.value.maxlength));
+    const resizeTextarea = () => {
+      const { type, autosize } = props;
+      if (!isClient || type !== "textarea")
+        return;
+      if (autosize) {
+        const minRows = isObject(autosize) ? autosize.minRows : void 0;
+        const maxRows = isObject(autosize) ? autosize.maxRows : void 0;
+        _textareaCalcStyle.value = __spreadValues({}, calcTextareaHeight(textarea.value, minRows, maxRows));
+      } else {
+        _textareaCalcStyle.value = {
+          minHeight: calcTextareaHeight(textarea.value).minHeight
+        };
+      }
+    };
+    const setNativeInputValue = () => {
+      const input22 = inputOrTextarea.value;
+      if (!input22 || input22.value === nativeInputValue.value)
+        return;
+      input22.value = nativeInputValue.value;
+    };
+    const calcIconOffset = (place) => {
+      const { el } = instance.vnode;
+      if (!el)
+        return;
+      const elList = Array.from(el.querySelectorAll(`.${nsInput.e(place)}`));
+      const target = elList.find((item) => item.parentNode === el);
+      if (!target)
+        return;
+      const pendant = PENDANT_MAP[place];
+      if (slots[pendant]) {
+        target.style.transform = `translateX(${place === "suffix" ? "-" : ""}${el.querySelector(`.${nsInput.be("group", pendant)}`).offsetWidth}px)`;
+      } else {
+        target.removeAttribute("style");
+      }
+    };
+    const updateIconOffset = () => {
+      calcIconOffset("prefix");
+      calcIconOffset("suffix");
+    };
+    const handleInput = (event) => {
+      const { value } = event.target;
+      if (isComposing.value)
+        return;
+      if (value === nativeInputValue.value)
+        return;
+      emit(UPDATE_MODEL_EVENT, value);
+      emit("input", value);
+      nextTick(setNativeInputValue);
+    };
+    const handleChange = (event) => {
+      emit("change", event.target.value);
+    };
+    const focus = () => {
+      nextTick(() => {
+        var _a;
+        (_a = inputOrTextarea.value) == null ? void 0 : _a.focus();
+      });
+    };
+    const blur = () => {
+      var _a;
+      (_a = inputOrTextarea.value) == null ? void 0 : _a.blur();
+    };
+    const handleFocus = (event) => {
+      focused.value = true;
+      emit("focus", event);
+    };
+    const handleBlur = (event) => {
+      var _a;
+      focused.value = false;
+      emit("blur", event);
+      if (props.validateEvent) {
+        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur");
+      }
+    };
+    const select = () => {
+      var _a;
+      (_a = inputOrTextarea.value) == null ? void 0 : _a.select();
+    };
+    const handleCompositionStart = (event) => {
+      emit("compositionstart", event);
+      isComposing.value = true;
+    };
+    const handleCompositionUpdate = (event) => {
+      var _a;
+      emit("compositionupdate", event);
+      const text = (_a = event.target) == null ? void 0 : _a.value;
+      const lastCharacter = text[text.length - 1] || "";
+      isComposing.value = !isKorean(lastCharacter);
+    };
+    const handleCompositionEnd = (event) => {
+      emit("compositionend", event);
+      if (isComposing.value) {
+        isComposing.value = false;
+        handleInput(event);
+      }
+    };
+    const clear = () => {
+      emit(UPDATE_MODEL_EVENT, "");
+      emit("change", "");
+      emit("clear");
+      emit("input", "");
+    };
+    const handlePasswordVisible = () => {
+      passwordVisible.value = !passwordVisible.value;
+      focus();
+    };
+    const suffixVisible = computed(() => !!slots.suffix || !!props.suffixIcon || showClear.value || props.showPassword || isWordLimitVisible.value || !!validateState.value && needStatusIcon.value);
+    watch(() => props.modelValue, () => {
+      var _a;
+      nextTick(resizeTextarea);
+      if (props.validateEvent) {
+        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change");
+      }
+    });
+    watch(nativeInputValue, () => setNativeInputValue());
+    watch(() => props.type, () => {
+      nextTick(() => {
+        setNativeInputValue();
+        resizeTextarea();
+        updateIconOffset();
+      });
+    });
+    onMounted(() => {
+      setNativeInputValue();
+      updateIconOffset();
+      nextTick(resizeTextarea);
+    });
+    onUpdated(() => {
+      nextTick(updateIconOffset);
+    });
+    const onMouseLeave = (evt) => {
+      hovering.value = false;
+      emit("mouseleave", evt);
+    };
+    const onMouseEnter = (evt) => {
+      hovering.value = true;
+      emit("mouseenter", evt);
+    };
+    const handleKeydown = (evt) => {
+      emit("keydown", evt);
+    };
+    return {
+      input: input2,
+      textarea,
+      attrs,
+      inputSize,
+      validateState,
+      validateIcon,
+      containerStyle,
+      computedTextareaStyle,
+      inputDisabled,
+      showClear,
+      showPwdVisible,
+      isWordLimitVisible,
+      textLength,
+      hovering,
+      inputExceed,
+      passwordVisible,
+      inputOrTextarea,
+      suffixVisible,
+      needStatusIcon,
+      resizeTextarea,
+      handleInput,
+      handleChange,
+      handleFocus,
+      handleBlur,
+      handleCompositionStart,
+      handleCompositionUpdate,
+      handleCompositionEnd,
+      handlePasswordVisible,
+      clear,
+      select,
+      focus,
+      blur,
+      onMouseLeave,
+      onMouseEnter,
+      handleKeydown,
+      nsInput,
+      nsTextarea
+    };
+  }
+});
+const _hoisted_1$3 = ["type", "disabled", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder"];
+const _hoisted_2$1 = ["tabindex", "disabled", "readonly", "autocomplete", "aria-label", "placeholder"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_icon = resolveComponent("el-icon");
+  const _component_circle_close = resolveComponent("circle-close");
+  const _component_icon_view = resolveComponent("icon-view");
+  return withDirectives((openBlock(), createElementBlock("div", {
+    class: normalizeClass([
+      _ctx.type === "textarea" ? _ctx.nsTextarea.b() : _ctx.nsInput.b(),
+      _ctx.nsInput.m(_ctx.inputSize),
+      _ctx.nsInput.is("disabled", _ctx.inputDisabled),
+      _ctx.nsInput.is("exceed", _ctx.inputExceed),
+      {
+        [_ctx.nsInput.b("group")]: _ctx.$slots.prepend || _ctx.$slots.append,
+        [_ctx.nsInput.bm("group", "append")]: _ctx.$slots.append,
+        [_ctx.nsInput.bm("group", "prepend")]: _ctx.$slots.prepend,
+        [_ctx.nsInput.m("prefix")]: _ctx.$slots.prefix || _ctx.prefixIcon,
+        [_ctx.nsInput.m("suffix")]: _ctx.$slots.suffix || _ctx.suffixIcon || _ctx.clearable || _ctx.showPassword,
+        [_ctx.nsInput.m("suffix--password-clear")]: _ctx.showClear && _ctx.showPwdVisible
+      },
+      _ctx.$attrs.class
+    ]),
+    style: normalizeStyle(_ctx.containerStyle),
+    onMouseenter: _cache[17] || (_cache[17] = (...args) => _ctx.onMouseEnter && _ctx.onMouseEnter(...args)),
+    onMouseleave: _cache[18] || (_cache[18] = (...args) => _ctx.onMouseLeave && _ctx.onMouseLeave(...args))
+  }, [
+    createCommentVNode(" input "),
+    _ctx.type !== "textarea" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+      createCommentVNode(" prepend slot "),
+      _ctx.$slots.prepend ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        class: normalizeClass(_ctx.nsInput.be("group", "prepend"))
+      }, [
+        renderSlot(_ctx.$slots, "prepend")
+      ], 2)) : createCommentVNode("v-if", true),
+      createElementVNode("input", mergeProps({
+        ref: "input",
+        class: _ctx.nsInput.e("inner")
+      }, _ctx.attrs, {
+        type: _ctx.showPassword ? _ctx.passwordVisible ? "text" : "password" : _ctx.type,
+        disabled: _ctx.inputDisabled,
+        readonly: _ctx.readonly,
+        autocomplete: _ctx.autocomplete,
+        tabindex: _ctx.tabindex,
+        "aria-label": _ctx.label,
+        placeholder: _ctx.placeholder,
+        style: _ctx.inputStyle,
+        onCompositionstart: _cache[0] || (_cache[0] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
+        onCompositionupdate: _cache[1] || (_cache[1] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
+        onCompositionend: _cache[2] || (_cache[2] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
+        onInput: _cache[3] || (_cache[3] = (...args) => _ctx.handleInput && _ctx.handleInput(...args)),
+        onFocus: _cache[4] || (_cache[4] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
+        onBlur: _cache[5] || (_cache[5] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
+        onChange: _cache[6] || (_cache[6] = (...args) => _ctx.handleChange && _ctx.handleChange(...args)),
+        onKeydown: _cache[7] || (_cache[7] = (...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args))
+      }), null, 16, _hoisted_1$3),
+      createCommentVNode(" prefix slot "),
+      _ctx.$slots.prefix || _ctx.prefixIcon ? (openBlock(), createElementBlock("span", {
+        key: 1,
+        class: normalizeClass(_ctx.nsInput.e("prefix"))
+      }, [
+        createElementVNode("span", {
+          class: normalizeClass(_ctx.nsInput.e("prefix-inner"))
+        }, [
+          renderSlot(_ctx.$slots, "prefix"),
+          _ctx.prefixIcon ? (openBlock(), createBlock(_component_el_icon, {
+            key: 0,
+            class: normalizeClass(_ctx.nsInput.e("icon"))
+          }, {
+            default: withCtx(() => [
+              (openBlock(), createBlock(resolveDynamicComponent(_ctx.prefixIcon)))
+            ]),
+            _: 1
+          }, 8, ["class"])) : createCommentVNode("v-if", true)
+        ], 2)
+      ], 2)) : createCommentVNode("v-if", true),
+      createCommentVNode(" suffix slot "),
+      _ctx.suffixVisible ? (openBlock(), createElementBlock("span", {
+        key: 2,
+        class: normalizeClass(_ctx.nsInput.e("suffix"))
+      }, [
+        createElementVNode("span", {
+          class: normalizeClass(_ctx.nsInput.e("suffix-inner"))
+        }, [
+          !_ctx.showClear || !_ctx.showPwdVisible || !_ctx.isWordLimitVisible ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+            renderSlot(_ctx.$slots, "suffix"),
+            _ctx.suffixIcon ? (openBlock(), createBlock(_component_el_icon, {
+              key: 0,
+              class: normalizeClass(_ctx.nsInput.e("icon"))
+            }, {
+              default: withCtx(() => [
+                (openBlock(), createBlock(resolveDynamicComponent(_ctx.suffixIcon)))
+              ]),
+              _: 1
+            }, 8, ["class"])) : createCommentVNode("v-if", true)
+          ], 64)) : createCommentVNode("v-if", true),
+          _ctx.showClear ? (openBlock(), createBlock(_component_el_icon, {
+            key: 1,
+            class: normalizeClass([_ctx.nsInput.e("icon"), _ctx.nsInput.e("clear")]),
+            onMousedown: _cache[8] || (_cache[8] = withModifiers(() => {
+            }, ["prevent"])),
+            onClick: _ctx.clear
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_circle_close)
+            ]),
+            _: 1
+          }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
+          _ctx.showPwdVisible ? (openBlock(), createBlock(_component_el_icon, {
+            key: 2,
+            class: normalizeClass([_ctx.nsInput.e("icon"), _ctx.nsInput.e("clear")]),
+            onClick: _ctx.handlePasswordVisible
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_icon_view)
+            ]),
+            _: 1
+          }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
+          _ctx.isWordLimitVisible ? (openBlock(), createElementBlock("span", {
+            key: 3,
+            class: normalizeClass(_ctx.nsInput.e("count"))
+          }, [
+            createElementVNode("span", {
+              class: normalizeClass(_ctx.nsInput.e("count-inner"))
+            }, toDisplayString(_ctx.textLength) + " / " + toDisplayString(_ctx.attrs.maxlength), 3)
+          ], 2)) : createCommentVNode("v-if", true)
+        ], 2),
+        _ctx.validateState && _ctx.validateIcon && _ctx.needStatusIcon ? (openBlock(), createBlock(_component_el_icon, {
+          key: 0,
+          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)) : createCommentVNode("v-if", true),
+      createCommentVNode(" append slot "),
+      _ctx.$slots.append ? (openBlock(), createElementBlock("div", {
+        key: 3,
+        class: normalizeClass(_ctx.nsInput.be("group", "append"))
+      }, [
+        renderSlot(_ctx.$slots, "append")
+      ], 2)) : createCommentVNode("v-if", true)
+    ], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+      createCommentVNode(" textarea "),
+      createElementVNode("textarea", mergeProps({
+        ref: "textarea",
+        class: _ctx.nsTextarea.e("inner")
+      }, _ctx.attrs, {
+        tabindex: _ctx.tabindex,
+        disabled: _ctx.inputDisabled,
+        readonly: _ctx.readonly,
+        autocomplete: _ctx.autocomplete,
+        style: _ctx.computedTextareaStyle,
+        "aria-label": _ctx.label,
+        placeholder: _ctx.placeholder,
+        onCompositionstart: _cache[9] || (_cache[9] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
+        onCompositionupdate: _cache[10] || (_cache[10] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
+        onCompositionend: _cache[11] || (_cache[11] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
+        onInput: _cache[12] || (_cache[12] = (...args) => _ctx.handleInput && _ctx.handleInput(...args)),
+        onFocus: _cache[13] || (_cache[13] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
+        onBlur: _cache[14] || (_cache[14] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
+        onChange: _cache[15] || (_cache[15] = (...args) => _ctx.handleChange && _ctx.handleChange(...args)),
+        onKeydown: _cache[16] || (_cache[16] = (...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args))
+      }), null, 16, _hoisted_2$1),
+      _ctx.isWordLimitVisible ? (openBlock(), createElementBlock("span", {
+        key: 0,
+        class: normalizeClass(_ctx.nsInput.e("count"))
+      }, toDisplayString(_ctx.textLength) + " / " + toDisplayString(_ctx.attrs.maxlength), 3)) : createCommentVNode("v-if", true)
+    ], 64))
+  ], 38)), [
+    [vShow, _ctx.type !== "hidden"]
+  ]);
+}
+var Input = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["render", _sfc_render]]);
+const ElInput = withInstall(Input);
+function bound01(n, max) {
+  if (isOnePointZero(n)) {
+    n = "100%";
+  }
+  var isPercent = isPercentage(n);
+  n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
+  if (isPercent) {
+    n = parseInt(String(n * max), 10) / 100;
+  }
+  if (Math.abs(n - max) < 1e-6) {
+    return 1;
+  }
+  if (max === 360) {
+    n = (n < 0 ? n % max + max : n % max) / parseFloat(String(max));
+  } else {
+    n = n % max / parseFloat(String(max));
+  }
+  return n;
+}
+function clamp01(val) {
+  return Math.min(1, Math.max(0, val));
+}
+function isOnePointZero(n) {
+  return typeof n === "string" && n.indexOf(".") !== -1 && parseFloat(n) === 1;
+}
+function isPercentage(n) {
+  return typeof n === "string" && n.indexOf("%") !== -1;
+}
+function boundAlpha(a) {
+  a = parseFloat(a);
+  if (isNaN(a) || a < 0 || a > 1) {
+    a = 1;
+  }
+  return a;
+}
+function convertToPercentage(n) {
+  if (n <= 1) {
+    return Number(n) * 100 + "%";
+  }
+  return n;
+}
+function pad2(c) {
+  return c.length === 1 ? "0" + c : String(c);
+}
+function rgbToRgb(r, g, b) {
+  return {
+    r: bound01(r, 255) * 255,
+    g: bound01(g, 255) * 255,
+    b: bound01(b, 255) * 255
+  };
+}
+function rgbToHsl(r, g, b) {
+  r = bound01(r, 255);
+  g = bound01(g, 255);
+  b = bound01(b, 255);
+  var max = Math.max(r, g, b);
+  var min = Math.min(r, g, b);
+  var h = 0;
+  var s = 0;
+  var l = (max + min) / 2;
+  if (max === min) {
+    s = 0;
+    h = 0;
+  } else {
+    var d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+  }
+  return { h, s, l };
+}
+function hue2rgb(p, q, t) {
+  if (t < 0) {
+    t += 1;
+  }
+  if (t > 1) {
+    t -= 1;
+  }
+  if (t < 1 / 6) {
+    return p + (q - p) * (6 * t);
+  }
+  if (t < 1 / 2) {
+    return q;
+  }
+  if (t < 2 / 3) {
+    return p + (q - p) * (2 / 3 - t) * 6;
+  }
+  return p;
+}
+function hslToRgb(h, s, l) {
+  var r;
+  var g;
+  var b;
+  h = bound01(h, 360);
+  s = bound01(s, 100);
+  l = bound01(l, 100);
+  if (s === 0) {
+    g = l;
+    b = l;
+    r = l;
+  } else {
+    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    var p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return { r: r * 255, g: g * 255, b: b * 255 };
+}
+function rgbToHsv(r, g, b) {
+  r = bound01(r, 255);
+  g = bound01(g, 255);
+  b = bound01(b, 255);
+  var max = Math.max(r, g, b);
+  var min = Math.min(r, g, b);
+  var h = 0;
+  var v = max;
+  var d = max - min;
+  var s = max === 0 ? 0 : d / max;
+  if (max === min) {
+    h = 0;
+  } else {
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+  }
+  return { h, s, v };
+}
+function hsvToRgb(h, s, v) {
+  h = bound01(h, 360) * 6;
+  s = bound01(s, 100);
+  v = bound01(v, 100);
+  var i = Math.floor(h);
+  var f = h - i;
+  var p = v * (1 - s);
+  var q = v * (1 - f * s);
+  var t = v * (1 - (1 - f) * s);
+  var mod = i % 6;
+  var r = [v, q, p, p, t, v][mod];
+  var g = [t, v, v, q, p, p][mod];
+  var b = [p, p, t, v, v, q][mod];
+  return { r: r * 255, g: g * 255, b: b * 255 };
+}
+function rgbToHex(r, g, b, allow3Char) {
+  var hex = [
+    pad2(Math.round(r).toString(16)),
+    pad2(Math.round(g).toString(16)),
+    pad2(Math.round(b).toString(16))
+  ];
+  if (allow3Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1))) {
+    return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
+  }
+  return hex.join("");
+}
+function rgbaToHex(r, g, b, a, allow4Char) {
+  var hex = [
+    pad2(Math.round(r).toString(16)),
+    pad2(Math.round(g).toString(16)),
+    pad2(Math.round(b).toString(16)),
+    pad2(convertDecimalToHex(a))
+  ];
+  if (allow4Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1)) && hex[3].startsWith(hex[3].charAt(1))) {
+    return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
+  }
+  return hex.join("");
+}
+function convertDecimalToHex(d) {
+  return Math.round(parseFloat(d) * 255).toString(16);
+}
+function convertHexToDecimal(h) {
+  return parseIntFromHex(h) / 255;
+}
+function parseIntFromHex(val) {
+  return parseInt(val, 16);
+}
+function numberInputToObject(color) {
+  return {
+    r: color >> 16,
+    g: (color & 65280) >> 8,
+    b: color & 255
+  };
+}
+var names = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkgrey: "#a9a9a9",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  goldenrod: "#daa520",
+  gold: "#ffd700",
+  gray: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  grey: "#808080",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavenderblush: "#fff0f5",
+  lavender: "#e6e6fa",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightgrey: "#d3d3d3",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+};
+function inputToRGB(color) {
+  var rgb = { r: 0, g: 0, b: 0 };
+  var a = 1;
+  var s = null;
+  var v = null;
+  var l = null;
+  var ok = false;
+  var format = false;
+  if (typeof color === "string") {
+    color = stringInputToObject(color);
+  }
+  if (typeof color === "object") {
+    if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
+      rgb = rgbToRgb(color.r, color.g, color.b);
+      ok = true;
+      format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
+    } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
+      s = convertToPercentage(color.s);
+      v = convertToPercentage(color.v);
+      rgb = hsvToRgb(color.h, s, v);
+      ok = true;
+      format = "hsv";
+    } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
+      s = convertToPercentage(color.s);
+      l = convertToPercentage(color.l);
+      rgb = hslToRgb(color.h, s, l);
+      ok = true;
+      format = "hsl";
+    }
+    if (Object.prototype.hasOwnProperty.call(color, "a")) {
+      a = color.a;
+    }
+  }
+  a = boundAlpha(a);
+  return {
+    ok,
+    format: color.format || format,
+    r: Math.min(255, Math.max(rgb.r, 0)),
+    g: Math.min(255, Math.max(rgb.g, 0)),
+    b: Math.min(255, Math.max(rgb.b, 0)),
+    a
+  };
+}
+var CSS_INTEGER = "[-\\+]?\\d+%?";
+var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
+var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
+var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+var matchers = {
+  CSS_UNIT: new RegExp(CSS_UNIT),
+  rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
+  rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
+  hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
+  hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
+  hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
+  hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
+  hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+  hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+  hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+  hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
+};
+function stringInputToObject(color) {
+  color = color.trim().toLowerCase();
+  if (color.length === 0) {
+    return false;
+  }
+  var named = false;
+  if (names[color]) {
+    color = names[color];
+    named = true;
+  } else if (color === "transparent") {
+    return { r: 0, g: 0, b: 0, a: 0, format: "name" };
+  }
+  var match = matchers.rgb.exec(color);
+  if (match) {
+    return { r: match[1], g: match[2], b: match[3] };
+  }
+  match = matchers.rgba.exec(color);
+  if (match) {
+    return { r: match[1], g: match[2], b: match[3], a: match[4] };
+  }
+  match = matchers.hsl.exec(color);
+  if (match) {
+    return { h: match[1], s: match[2], l: match[3] };
+  }
+  match = matchers.hsla.exec(color);
+  if (match) {
+    return { h: match[1], s: match[2], l: match[3], a: match[4] };
+  }
+  match = matchers.hsv.exec(color);
+  if (match) {
+    return { h: match[1], s: match[2], v: match[3] };
+  }
+  match = matchers.hsva.exec(color);
+  if (match) {
+    return { h: match[1], s: match[2], v: match[3], a: match[4] };
+  }
+  match = matchers.hex8.exec(color);
+  if (match) {
+    return {
+      r: parseIntFromHex(match[1]),
+      g: parseIntFromHex(match[2]),
+      b: parseIntFromHex(match[3]),
+      a: convertHexToDecimal(match[4]),
+      format: named ? "name" : "hex8"
+    };
+  }
+  match = matchers.hex6.exec(color);
+  if (match) {
+    return {
+      r: parseIntFromHex(match[1]),
+      g: parseIntFromHex(match[2]),
+      b: parseIntFromHex(match[3]),
+      format: named ? "name" : "hex"
+    };
+  }
+  match = matchers.hex4.exec(color);
+  if (match) {
+    return {
+      r: parseIntFromHex(match[1] + match[1]),
+      g: parseIntFromHex(match[2] + match[2]),
+      b: parseIntFromHex(match[3] + match[3]),
+      a: convertHexToDecimal(match[4] + match[4]),
+      format: named ? "name" : "hex8"
+    };
+  }
+  match = matchers.hex3.exec(color);
+  if (match) {
+    return {
+      r: parseIntFromHex(match[1] + match[1]),
+      g: parseIntFromHex(match[2] + match[2]),
+      b: parseIntFromHex(match[3] + match[3]),
+      format: named ? "name" : "hex"
+    };
+  }
+  return false;
+}
+function isValidCSSUnit(color) {
+  return Boolean(matchers.CSS_UNIT.exec(String(color)));
+}
+var TinyColor = function() {
+  function TinyColor2(color, opts) {
+    if (color === void 0) {
+      color = "";
+    }
+    if (opts === void 0) {
+      opts = {};
+    }
+    var _a;
+    if (color instanceof TinyColor2) {
+      return color;
+    }
+    if (typeof color === "number") {
+      color = numberInputToObject(color);
+    }
+    this.originalInput = color;
+    var rgb = inputToRGB(color);
+    this.originalInput = color;
+    this.r = rgb.r;
+    this.g = rgb.g;
+    this.b = rgb.b;
+    this.a = rgb.a;
+    this.roundA = Math.round(100 * this.a) / 100;
+    this.format = (_a = opts.format) !== null && _a !== void 0 ? _a : rgb.format;
+    this.gradientType = opts.gradientType;
+    if (this.r < 1) {
+      this.r = Math.round(this.r);
+    }
+    if (this.g < 1) {
+      this.g = Math.round(this.g);
+    }
+    if (this.b < 1) {
+      this.b = Math.round(this.b);
+    }
+    this.isValid = rgb.ok;
+  }
+  TinyColor2.prototype.isDark = function() {
+    return this.getBrightness() < 128;
+  };
+  TinyColor2.prototype.isLight = function() {
+    return !this.isDark();
+  };
+  TinyColor2.prototype.getBrightness = function() {
+    var rgb = this.toRgb();
+    return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3;
+  };
+  TinyColor2.prototype.getLuminance = function() {
+    var rgb = this.toRgb();
+    var R;
+    var G;
+    var B;
+    var RsRGB = rgb.r / 255;
+    var GsRGB = rgb.g / 255;
+    var BsRGB = rgb.b / 255;
+    if (RsRGB <= 0.03928) {
+      R = RsRGB / 12.92;
+    } else {
+      R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
+    }
+    if (GsRGB <= 0.03928) {
+      G = GsRGB / 12.92;
+    } else {
+      G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
+    }
+    if (BsRGB <= 0.03928) {
+      B = BsRGB / 12.92;
+    } else {
+      B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
+    }
+    return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+  };
+  TinyColor2.prototype.getAlpha = function() {
+    return this.a;
+  };
+  TinyColor2.prototype.setAlpha = function(alpha) {
+    this.a = boundAlpha(alpha);
+    this.roundA = Math.round(100 * this.a) / 100;
+    return this;
+  };
+  TinyColor2.prototype.toHsv = function() {
+    var hsv = rgbToHsv(this.r, this.g, this.b);
+    return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
+  };
+  TinyColor2.prototype.toHsvString = function() {
+    var hsv = rgbToHsv(this.r, this.g, this.b);
+    var h = Math.round(hsv.h * 360);
+    var s = Math.round(hsv.s * 100);
+    var v = Math.round(hsv.v * 100);
+    return this.a === 1 ? "hsv(" + h + ", " + s + "%, " + v + "%)" : "hsva(" + h + ", " + s + "%, " + v + "%, " + this.roundA + ")";
+  };
+  TinyColor2.prototype.toHsl = function() {
+    var hsl = rgbToHsl(this.r, this.g, this.b);
+    return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };
+  };
+  TinyColor2.prototype.toHslString = function() {
+    var hsl = rgbToHsl(this.r, this.g, this.b);
+    var h = Math.round(hsl.h * 360);
+    var s = Math.round(hsl.s * 100);
+    var l = Math.round(hsl.l * 100);
+    return this.a === 1 ? "hsl(" + h + ", " + s + "%, " + l + "%)" : "hsla(" + h + ", " + s + "%, " + l + "%, " + 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.toRgb = function() {
+    return {
+      r: Math.round(this.r),
+      g: Math.round(this.g),
+      b: Math.round(this.b),
+      a: this.a
+    };
+  };
+  TinyColor2.prototype.toRgbString = function() {
+    var r = Math.round(this.r);
+    var g = Math.round(this.g);
+    var b = Math.round(this.b);
+    return this.a === 1 ? "rgb(" + r + ", " + g + ", " + b + ")" : "rgba(" + r + ", " + g + ", " + b + ", " + this.roundA + ")";
+  };
+  TinyColor2.prototype.toPercentageRgb = function() {
+    var fmt = function(x) {
+      return Math.round(bound01(x, 255) * 100) + "%";
+    };
+    return {
+      r: fmt(this.r),
+      g: fmt(this.g),
+      b: fmt(this.b),
+      a: this.a
+    };
+  };
+  TinyColor2.prototype.toPercentageRgbString = function() {
+    var rnd = function(x) {
+      return Math.round(bound01(x, 255) * 100);
+    };
+    return this.a === 1 ? "rgb(" + rnd(this.r) + "%, " + rnd(this.g) + "%, " + rnd(this.b) + "%)" : "rgba(" + rnd(this.r) + "%, " + rnd(this.g) + "%, " + rnd(this.b) + "%, " + this.roundA + ")";
+  };
+  TinyColor2.prototype.toName = function() {
+    if (this.a === 0) {
+      return "transparent";
+    }
+    if (this.a < 1) {
+      return false;
+    }
+    var hex = "#" + rgbToHex(this.r, this.g, this.b, false);
+    for (var _i = 0, _a = Object.entries(names); _i < _a.length; _i++) {
+      var _b = _a[_i], key = _b[0], value = _b[1];
+      if (hex === value) {
+        return key;
+      }
+    }
+    return false;
+  };
+  TinyColor2.prototype.toString = function(format) {
+    var formatSet = Boolean(format);
+    format = format !== null && format !== void 0 ? format : this.format;
+    var formattedString = false;
+    var hasAlpha = this.a < 1 && this.a >= 0;
+    var needsAlphaFormat = !formatSet && hasAlpha && (format.startsWith("hex") || format === "name");
+    if (needsAlphaFormat) {
+      if (format === "name" && this.a === 0) {
+        return this.toName();
+      }
+      return this.toRgbString();
+    }
+    if (format === "rgb") {
+      formattedString = this.toRgbString();
+    }
+    if (format === "prgb") {
+      formattedString = this.toPercentageRgbString();
+    }
+    if (format === "hex" || format === "hex6") {
+      formattedString = this.toHexString();
+    }
+    if (format === "hex3") {
+      formattedString = this.toHexString(true);
+    }
+    if (format === "hex4") {
+      formattedString = this.toHex8String(true);
+    }
+    if (format === "hex8") {
+      formattedString = this.toHex8String();
+    }
+    if (format === "name") {
+      formattedString = this.toName();
+    }
+    if (format === "hsl") {
+      formattedString = this.toHslString();
+    }
+    if (format === "hsv") {
+      formattedString = this.toHsvString();
+    }
+    return formattedString || this.toHexString();
+  };
+  TinyColor2.prototype.toNumber = function() {
+    return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
+  };
+  TinyColor2.prototype.clone = function() {
+    return new TinyColor2(this.toString());
+  };
+  TinyColor2.prototype.lighten = function(amount) {
+    if (amount === void 0) {
+      amount = 10;
+    }
+    var hsl = this.toHsl();
+    hsl.l += amount / 100;
+    hsl.l = clamp01(hsl.l);
+    return new TinyColor2(hsl);
+  };
+  TinyColor2.prototype.brighten = function(amount) {
+    if (amount === void 0) {
+      amount = 10;
+    }
+    var rgb = this.toRgb();
+    rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
+    rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
+    rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
+    return new TinyColor2(rgb);
+  };
+  TinyColor2.prototype.darken = function(amount) {
+    if (amount === void 0) {
+      amount = 10;
+    }
+    var hsl = this.toHsl();
+    hsl.l -= amount / 100;
+    hsl.l = clamp01(hsl.l);
+    return new TinyColor2(hsl);
+  };
+  TinyColor2.prototype.tint = function(amount) {
+    if (amount === void 0) {
+      amount = 10;
+    }
+    return this.mix("white", amount);
+  };
+  TinyColor2.prototype.shade = function(amount) {
+    if (amount === void 0) {
+      amount = 10;
+    }
+    return this.mix("black", amount);
+  };
+  TinyColor2.prototype.desaturate = function(amount) {
+    if (amount === void 0) {
+      amount = 10;
+    }
+    var hsl = this.toHsl();
+    hsl.s -= amount / 100;
+    hsl.s = clamp01(hsl.s);
+    return new TinyColor2(hsl);
+  };
+  TinyColor2.prototype.saturate = function(amount) {
+    if (amount === void 0) {
+      amount = 10;
+    }
+    var hsl = this.toHsl();
+    hsl.s += amount / 100;
+    hsl.s = clamp01(hsl.s);
+    return new TinyColor2(hsl);
+  };
+  TinyColor2.prototype.greyscale = function() {
+    return this.desaturate(100);
+  };
+  TinyColor2.prototype.spin = function(amount) {
+    var hsl = this.toHsl();
+    var hue = (hsl.h + amount) % 360;
+    hsl.h = hue < 0 ? 360 + hue : hue;
+    return new TinyColor2(hsl);
+  };
+  TinyColor2.prototype.mix = function(color, amount) {
+    if (amount === void 0) {
+      amount = 50;
+    }
+    var rgb1 = this.toRgb();
+    var rgb2 = new TinyColor2(color).toRgb();
+    var p = amount / 100;
+    var rgba = {
+      r: (rgb2.r - rgb1.r) * p + rgb1.r,
+      g: (rgb2.g - rgb1.g) * p + rgb1.g,
+      b: (rgb2.b - rgb1.b) * p + rgb1.b,
+      a: (rgb2.a - rgb1.a) * p + rgb1.a
+    };
+    return new TinyColor2(rgba);
+  };
+  TinyColor2.prototype.analogous = function(results, slices) {
+    if (results === void 0) {
+      results = 6;
+    }
+    if (slices === void 0) {
+      slices = 30;
+    }
+    var hsl = this.toHsl();
+    var part = 360 / slices;
+    var ret = [this];
+    for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results; ) {
+      hsl.h = (hsl.h + part) % 360;
+      ret.push(new TinyColor2(hsl));
+    }
+    return ret;
+  };
+  TinyColor2.prototype.complement = function() {
+    var hsl = this.toHsl();
+    hsl.h = (hsl.h + 180) % 360;
+    return new TinyColor2(hsl);
+  };
+  TinyColor2.prototype.monochromatic = function(results) {
+    if (results === void 0) {
+      results = 6;
+    }
+    var hsv = this.toHsv();
+    var h = hsv.h;
+    var s = hsv.s;
+    var v = hsv.v;
+    var res = [];
+    var modification = 1 / results;
+    while (results--) {
+      res.push(new TinyColor2({ h, s, v }));
+      v = (v + modification) % 1;
+    }
+    return res;
+  };
+  TinyColor2.prototype.splitcomplement = function() {
+    var hsl = this.toHsl();
+    var h = hsl.h;
+    return [
+      this,
+      new TinyColor2({ h: (h + 72) % 360, s: hsl.s, l: hsl.l }),
+      new TinyColor2({ h: (h + 216) % 360, s: hsl.s, l: hsl.l })
+    ];
+  };
+  TinyColor2.prototype.onBackground = function(background) {
+    var fg = this.toRgb();
+    var bg = new TinyColor2(background).toRgb();
+    return new TinyColor2({
+      r: bg.r + (fg.r - bg.r) * fg.a,
+      g: bg.g + (fg.g - bg.g) * fg.a,
+      b: bg.b + (fg.b - bg.b) * fg.a
+    });
+  };
+  TinyColor2.prototype.triad = function() {
+    return this.polyad(3);
+  };
+  TinyColor2.prototype.tetrad = function() {
+    return this.polyad(4);
+  };
+  TinyColor2.prototype.polyad = function(n) {
+    var hsl = this.toHsl();
+    var h = hsl.h;
+    var result = [this];
+    var increment = 360 / n;
+    for (var i = 1; i < n; i++) {
+      result.push(new TinyColor2({ h: (h + i * increment) % 360, s: hsl.s, l: hsl.l }));
+    }
+    return result;
+  };
+  TinyColor2.prototype.equals = function(color) {
+    return this.toRgbString() === new TinyColor2(color).toRgbString();
+  };
+  return TinyColor2;
+}();
+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,
+    default: ""
+  },
+  nativeType: {
+    type: String,
+    values: buttonNativeTypes,
+    default: "button"
+  },
+  loading: Boolean,
+  loadingIcon: {
+    type: iconPropType,
+    default: () => loading
+  },
+  plain: Boolean,
+  autofocus: Boolean,
+  round: Boolean,
+  circle: Boolean,
+  color: String,
+  autoInsertSpace: {
+    type: Boolean,
+    default: void 0
+  }
+});
+const buttonEmits = {
+  click: (evt) => evt instanceof MouseEvent
+};
+const _hoisted_1$2 = ["disabled", "autofocus", "type"];
+const __default__$3 = {
+  name: "ElButton"
+};
+const _sfc_main$3 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$3), {
+  props: buttonProps,
+  emits: buttonEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const slots = useSlots();
+    const buttonGroupContext = inject(buttonGroupContextKey, void 0);
+    const globalConfig2 = useGlobalConfig("button");
+    const ns = useNamespace("button");
+    const { form } = useFormItem();
+    const _size = useSize(computed(() => buttonGroupContext == null ? void 0 : buttonGroupContext.size));
+    const _disabled = useDisabled();
+    const _ref = ref();
+    const _type = computed(() => props.type || (buttonGroupContext == null ? void 0 : buttonGroupContext.type) || "");
+    const autoInsertSpace = computed(() => {
+      var _a, _b, _c;
+      return (_c = (_b = props.autoInsertSpace) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.autoInsertSpace) != null ? _c : false;
+    });
+    const shouldAddSpace = computed(() => {
+      var _a;
+      const defaultSlot = (_a = slots.default) == null ? void 0 : _a.call(slots);
+      if (autoInsertSpace.value && (defaultSlot == null ? void 0 : defaultSlot.length) === 1) {
+        const slot = defaultSlot[0];
+        if ((slot == null ? void 0 : slot.type) === Text) {
+          const text = slot.children;
+          return /^\p{Unified_Ideograph}{2}$/u.test(text);
+        }
+      }
+      return false;
+    });
+    const buttonStyle = computed(() => {
+      let styles = {};
+      const buttonColor = props.color;
+      if (buttonColor) {
+        const color = new TinyColor(buttonColor);
+        const shadeBgColor = color.shade(20).toString();
+        if (props.plain) {
+          styles = {
+            "--el-button-bg-color": color.tint(90).toString(),
+            "--el-button-text-color": buttonColor,
+            "--el-button-hover-text-color": "var(--el-color-white)",
+            "--el-button-hover-bg-color": buttonColor,
+            "--el-button-hover-border-color": buttonColor,
+            "--el-button-active-bg-color": shadeBgColor,
+            "--el-button-active-text-color": "var(--el-color-white)",
+            "--el-button-active-border-color": shadeBgColor
+          };
+        } else {
+          const tintBgColor = color.tint(30).toString();
+          styles = {
+            "--el-button-bg-color": buttonColor,
+            "--el-button-border-color": buttonColor,
+            "--el-button-hover-bg-color": tintBgColor,
+            "--el-button-hover-border-color": tintBgColor,
+            "--el-button-active-bg-color": shadeBgColor,
+            "--el-button-active-border-color": shadeBgColor
+          };
+        }
+        if (_disabled.value) {
+          const disabledButtonColor = color.tint(50).toString();
+          styles["--el-button-disabled-bg-color"] = disabledButtonColor;
+          styles["--el-button-disabled-border-color"] = disabledButtonColor;
+        }
+      }
+      return styles;
+    });
+    const handleClick = (evt) => {
+      if (props.nativeType === "reset") {
+        form == null ? void 0 : form.resetFields();
+      }
+      emit("click", evt);
+    };
+    expose({
+      ref: _ref,
+      size: _size,
+      type: _type,
+      disabled: _disabled,
+      shouldAddSpace
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        ref_key: "_ref",
+        ref: _ref,
+        class: normalizeClass([
+          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)
+        ]),
+        disabled: unref(_disabled) || _ctx.loading,
+        autofocus: _ctx.autofocus,
+        type: _ctx.nativeType,
+        style: normalizeStyle(unref(buttonStyle)),
+        onClick: handleClick
+      }, [
+        _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"]))
+        ], 2112)) : _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
+          default: withCtx(() => [
+            (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
+          ]),
+          _: 1
+        })) : 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)
+      ], 14, _hoisted_1$2);
+    };
+  }
+}));
+const buttonGroupProps = {
+  size: buttonProps.size,
+  type: buttonProps.type
+};
+const __default__$2 = {
+  name: "ElButtonGroup"
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$2), {
+  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);
+    };
+  }
+}));
+const ElButton = withInstall(_sfc_main$3, {
+  ButtonGroup: _sfc_main$2
+});
+withNoopInstall(_sfc_main$2);
+var base = "";
+var button = "";
+var input = "";
+const _hoisted_1$1 = /* @__PURE__ */ createElementVNode("p", null, "Hello NPM!", -1);
+const _hoisted_2 = /* @__PURE__ */ createTextVNode("Increment count");
+const __default__$1 = {
+  name: "TestViteNpmComponent"
+};
+const _sfc_main$1 = /* @__PURE__ */ Object.assign(__default__$1, {
+  setup(__props) {
+    const msg = ref("");
+    const count2 = ref(0);
+    const incrementCount = () => count2.value++;
+    return (_ctx, _cache) => {
+      const _component_el_input = ElInput;
+      const _component_el_button = ElButton;
+      return openBlock(), createElementBlock(Fragment, null, [
+        _hoisted_1$1,
+        createElementVNode("div", null, [
+          createVNode(_component_el_input, {
+            modelValue: msg.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => msg.value = $event),
+            style: { "width": "40%" }
+          }, null, 8, ["modelValue"]),
+          createElementVNode("div", null, "This is input message: " + toDisplayString(msg.value), 1)
+        ]),
+        createElementVNode("div", null, [
+          createVNode(_component_el_button, {
+            type: "primary",
+            onClick: incrementCount
+          }, {
+            default: withCtx(() => [
+              _hoisted_2
+            ]),
+            _: 1
+          }),
+          createElementVNode("div", null, "This is count: " + toDisplayString(count2.value), 1)
+        ])
+      ], 64);
+    };
+  }
+});
+/**
+ * Vue Currency Input 2.4.0
+ * (c) 2018-2022 Matthias Stiller
+ * @license MIT
+ */
+const escapeRegExp = (str) => {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+const removeLeadingZeros = (str) => {
+  return str.replace(/^0+(0$|[^0])/, "$1");
+};
+const count = (str, search) => {
+  return (str.match(new RegExp(escapeRegExp(search), "g")) || []).length;
+};
+const substringBefore = (str, search) => {
+  return str.substring(0, str.indexOf(search));
+};
+var CurrencyDisplay;
+(function(CurrencyDisplay2) {
+  CurrencyDisplay2["symbol"] = "symbol";
+  CurrencyDisplay2["narrowSymbol"] = "narrowSymbol";
+  CurrencyDisplay2["code"] = "code";
+  CurrencyDisplay2["name"] = "name";
+  CurrencyDisplay2["hidden"] = "hidden";
+})(CurrencyDisplay || (CurrencyDisplay = {}));
+var ValueScaling;
+(function(ValueScaling2) {
+  ValueScaling2["precision"] = "precision";
+  ValueScaling2["thousands"] = "thousands";
+  ValueScaling2["millions"] = "millions";
+  ValueScaling2["billions"] = "billions";
+})(ValueScaling || (ValueScaling = {}));
+const DECIMAL_SEPARATORS = [",", ".", "\u066B"];
+const INTEGER_PATTERN = "(0|[1-9]\\d*)";
+class CurrencyFormat {
+  constructor(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const { currency, currencyDisplay, locale, precision, accountingSign } = options;
+    this.locale = locale;
+    this.options = {
+      style: "currency",
+      currency,
+      currencySign: accountingSign ? "accounting" : void 0,
+      currencyDisplay: currencyDisplay !== CurrencyDisplay.hidden ? currencyDisplay : void 0
+    };
+    const numberFormat = new Intl.NumberFormat(locale, this.options);
+    const formatParts = numberFormat.formatToParts(123456);
+    this.currency = (_a = formatParts.find(({ type }) => type === "currency")) === null || _a === void 0 ? void 0 : _a.value;
+    this.digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map((i) => i.toLocaleString(locale));
+    this.decimalSymbol = (_b = formatParts.find(({ type }) => type === "decimal")) === null || _b === void 0 ? void 0 : _b.value;
+    this.groupingSymbol = (_c = formatParts.find(({ type }) => type === "group")) === null || _c === void 0 ? void 0 : _c.value;
+    this.minusSign = (_d = numberFormat.formatToParts(-1).find(({ type }) => type === "minusSign")) === null || _d === void 0 ? void 0 : _d.value;
+    if (this.decimalSymbol === void 0) {
+      this.minimumFractionDigits = this.maximumFractionDigits = 0;
+    } else if (typeof precision === "number") {
+      this.minimumFractionDigits = this.maximumFractionDigits = precision;
+    } else {
+      this.minimumFractionDigits = (_e = precision === null || precision === void 0 ? void 0 : precision.min) !== null && _e !== void 0 ? _e : numberFormat.resolvedOptions().minimumFractionDigits;
+      this.maximumFractionDigits = (_f = precision === null || precision === void 0 ? void 0 : precision.max) !== null && _f !== void 0 ? _f : numberFormat.resolvedOptions().maximumFractionDigits;
+    }
+    const getPrefix = (str) => {
+      return substringBefore(str, this.digits[1]);
+    };
+    const getSuffix = (str) => {
+      return str.substring(str.lastIndexOf(this.decimalSymbol ? this.digits[0] : this.digits[1]) + 1);
+    };
+    this.prefix = getPrefix(numberFormat.format(1));
+    this.suffix = getSuffix(numberFormat.format(1));
+    this.negativePrefix = getPrefix(numberFormat.format(-1));
+    this.negativeSuffix = getSuffix(numberFormat.format(-1));
+  }
+  parse(str) {
+    if (str) {
+      const negative = this.isNegative(str);
+      str = this.normalizeDigits(str);
+      str = this.stripCurrency(str, negative);
+      str = this.stripSignLiterals(str);
+      const fraction = this.decimalSymbol ? `(?:${escapeRegExp(this.decimalSymbol)}(\\d*))?` : "";
+      const match = this.stripGroupingSeparator(str).match(new RegExp(`^${INTEGER_PATTERN}${fraction}$`));
+      if (match && this.isValidIntegerFormat(this.decimalSymbol ? str.split(this.decimalSymbol)[0] : str, Number(match[1]))) {
+        return Number(`${negative ? "-" : ""}${this.onlyDigits(match[1])}.${this.onlyDigits(match[2] || "")}`);
+      }
+    }
+    return null;
+  }
+  isValidIntegerFormat(formattedNumber, integerNumber) {
+    const options = __spreadProps(__spreadValues({}, this.options), { minimumFractionDigits: 0 });
+    return [
+      this.stripCurrency(this.normalizeDigits(integerNumber.toLocaleString(this.locale, __spreadProps(__spreadValues({}, options), {
+        useGrouping: true
+      }))), false),
+      this.stripCurrency(this.normalizeDigits(integerNumber.toLocaleString(this.locale, __spreadProps(__spreadValues({}, options), {
+        useGrouping: false
+      }))), false)
+    ].includes(formattedNumber);
+  }
+  format(value, options = {
+    minimumFractionDigits: this.minimumFractionDigits,
+    maximumFractionDigits: this.maximumFractionDigits
+  }) {
+    return value != null ? value.toLocaleString(this.locale, __spreadValues(__spreadValues({}, this.options), options)) : "";
+  }
+  toFraction(str) {
+    return `${this.digits[0]}${this.decimalSymbol}${this.onlyLocaleDigits(str.substr(1)).substr(0, this.maximumFractionDigits)}`;
+  }
+  isFractionIncomplete(str) {
+    return !!this.normalizeDigits(this.stripGroupingSeparator(str)).match(new RegExp(`^${INTEGER_PATTERN}${escapeRegExp(this.decimalSymbol)}$`));
+  }
+  isNegative(str) {
+    return str.startsWith(this.negativePrefix) || this.minusSign === void 0 && (str.startsWith("(") || str.startsWith("-")) || this.minusSign !== void 0 && str.replace("-", this.minusSign).startsWith(this.minusSign);
+  }
+  insertCurrency(str, negative) {
+    return `${negative ? this.negativePrefix : this.prefix}${str}${negative ? this.negativeSuffix : this.suffix}`;
+  }
+  stripGroupingSeparator(str) {
+    return this.groupingSymbol !== void 0 ? str.replace(new RegExp(escapeRegExp(this.groupingSymbol), "g"), "") : str;
+  }
+  stripSignLiterals(str) {
+    if (this.minusSign !== void 0) {
+      return str.replace("-", this.minusSign).replace(this.minusSign, "");
+    } else {
+      return str.replace(/[-()]/g, "");
+    }
+  }
+  stripCurrency(str, negative) {
+    return str.replace(negative ? this.negativePrefix : this.prefix, "").replace(negative ? this.negativeSuffix : this.suffix, "");
+  }
+  normalizeDecimalSeparator(str, from) {
+    DECIMAL_SEPARATORS.forEach((s) => {
+      str = str.substr(0, from) + str.substr(from).replace(s, this.decimalSymbol);
+    });
+    return str;
+  }
+  normalizeDigits(str) {
+    if (this.digits[0] !== "0") {
+      this.digits.forEach((digit, index) => {
+        str = str.replace(new RegExp(digit, "g"), String(index));
+      });
+    }
+    return str;
+  }
+  onlyDigits(str) {
+    return this.normalizeDigits(str).replace(/\D+/g, "");
+  }
+  onlyLocaleDigits(str) {
+    return str.replace(new RegExp(`[^${this.digits.join("")}]*`, "g"), "");
+  }
+}
+class AbstractInputMask {
+  constructor(currencyFormat) {
+    this.currencyFormat = currencyFormat;
+  }
+}
+class DefaultInputMask extends AbstractInputMask {
+  conformToMask(str, previousConformedValue = "") {
+    const negative = this.currencyFormat.isNegative(str);
+    const isEmptyNegativeValue = (str2) => str2 === "" && negative && !(this.currencyFormat.minusSign === void 0 ? previousConformedValue === this.currencyFormat.negativePrefix + this.currencyFormat.negativeSuffix : previousConformedValue === this.currencyFormat.negativePrefix);
+    const checkIncompleteValue = (str2) => {
+      if (isEmptyNegativeValue(str2)) {
+        return "";
+      } else if (this.currencyFormat.maximumFractionDigits > 0) {
+        if (this.currencyFormat.isFractionIncomplete(str2)) {
+          return str2;
+        } else if (str2.startsWith(this.currencyFormat.decimalSymbol)) {
+          return this.currencyFormat.toFraction(str2);
+        }
+      }
+      return null;
+    };
+    let value = str;
+    value = this.currencyFormat.stripCurrency(value, negative);
+    value = this.currencyFormat.stripSignLiterals(value);
+    const incompleteValue = checkIncompleteValue(value);
+    if (incompleteValue != null) {
+      return this.currencyFormat.insertCurrency(incompleteValue, negative);
+    }
+    const [integer, ...fraction] = value.split(this.currencyFormat.decimalSymbol);
+    const integerDigits = removeLeadingZeros(this.currencyFormat.onlyDigits(integer));
+    const fractionDigits = this.currencyFormat.onlyDigits(fraction.join("")).substr(0, this.currencyFormat.maximumFractionDigits);
+    const invalidFraction = fraction.length > 0 && fractionDigits.length === 0;
+    const invalidNegativeValue = integerDigits === "" && negative && (this.currencyFormat.minusSign === void 0 ? previousConformedValue === str.slice(0, -2) + this.currencyFormat.negativeSuffix : previousConformedValue === str.slice(0, -1));
+    if (invalidFraction || invalidNegativeValue || isEmptyNegativeValue(integerDigits)) {
+      return previousConformedValue;
+    } else if (integerDigits.match(/\d+/)) {
+      return {
+        numberValue: Number(`${negative ? "-" : ""}${integerDigits}.${fractionDigits}`),
+        fractionDigits
+      };
+    } else {
+      return "";
+    }
+  }
+}
+class AutoDecimalDigitsInputMask extends AbstractInputMask {
+  conformToMask(str, previousConformedValue = "") {
+    if (str === "" || this.currencyFormat.parse(previousConformedValue) === 0 && this.currencyFormat.stripCurrency(previousConformedValue, true).slice(0, -1) === this.currencyFormat.stripCurrency(str, true)) {
+      return "";
+    }
+    const negative = this.currencyFormat.isNegative(str);
+    const numberValue = this.currencyFormat.stripSignLiterals(str) === "" ? -0 : Number(`${negative ? "-" : ""}${removeLeadingZeros(this.currencyFormat.onlyDigits(str))}`) / Math.pow(10, this.currencyFormat.maximumFractionDigits);
+    return {
+      numberValue,
+      fractionDigits: numberValue.toFixed(this.currencyFormat.maximumFractionDigits).slice(-this.currencyFormat.maximumFractionDigits)
+    };
+  }
+}
+const DEFAULT_OPTIONS = {
+  locale: void 0,
+  currency: void 0,
+  currencyDisplay: void 0,
+  exportValueAsInteger: false,
+  hideGroupingSeparatorOnFocus: true,
+  hideCurrencySymbolOnFocus: true,
+  hideNegligibleDecimalDigitsOnFocus: true,
+  precision: void 0,
+  autoDecimalDigits: false,
+  valueRange: void 0,
+  autoSign: true,
+  useGrouping: true,
+  valueScaling: void 0
+};
+class CurrencyInput {
+  constructor(el, options) {
+    this.el = el;
+    this.numberValue = null;
+    this.addEventListener();
+    this.init(options);
+    this.setValue(this.currencyFormat.parse(this.el.value));
+  }
+  setOptions(options) {
+    this.init(options);
+    this.applyFixedFractionFormat(this.numberValue, true);
+  }
+  getValue() {
+    const numberValue = this.valueScaling && this.numberValue != null ? this.toInteger(this.numberValue, this.valueScaling) : this.numberValue;
+    return { number: numberValue, formatted: this.formattedValue };
+  }
+  setValue(value) {
+    const newValue = this.valueScaling !== void 0 && value != null ? this.toFloat(value, this.valueScaling) : value;
+    if (newValue !== this.numberValue) {
+      this.applyFixedFractionFormat(newValue);
+    }
+  }
+  dispatchEvent(eventName) {
+    this.el.dispatchEvent(new CustomEvent(eventName, { detail: this.getValue() }));
+  }
+  init(options) {
+    this.options = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), options);
+    if (this.options.autoDecimalDigits) {
+      this.options.hideNegligibleDecimalDigitsOnFocus = false;
+      this.el.setAttribute("inputmode", "numeric");
+    } else {
+      this.el.setAttribute("inputmode", "decimal");
+    }
+    this.currencyFormat = new CurrencyFormat(this.options);
+    this.numberMask = this.options.autoDecimalDigits ? new AutoDecimalDigitsInputMask(this.currencyFormat) : new DefaultInputMask(this.currencyFormat);
+    const valueScalingOptions = {
+      [ValueScaling.precision]: this.currencyFormat.maximumFractionDigits,
+      [ValueScaling.thousands]: 3,
+      [ValueScaling.millions]: 6,
+      [ValueScaling.billions]: 9
+    };
+    if (this.options.exportValueAsInteger) {
+      this.valueScaling = valueScalingOptions[ValueScaling.precision];
+    } else {
+      this.valueScaling = this.options.valueScaling ? valueScalingOptions[this.options.valueScaling] : void 0;
+    }
+    this.valueScalingFractionDigits = this.valueScaling !== void 0 && this.options.valueScaling !== ValueScaling.precision ? this.valueScaling + this.currencyFormat.maximumFractionDigits : this.currencyFormat.maximumFractionDigits;
+    this.minValue = this.getMinValue();
+    this.maxValue = this.getMaxValue();
+  }
+  getMinValue() {
+    var _a, _b;
+    let min = this.toFloat(-Number.MAX_SAFE_INTEGER);
+    if (((_a = this.options.valueRange) === null || _a === void 0 ? void 0 : _a.min) !== void 0) {
+      min = Math.max((_b = this.options.valueRange) === null || _b === void 0 ? void 0 : _b.min, this.toFloat(-Number.MAX_SAFE_INTEGER));
+    }
+    if (!this.options.autoSign && min < 0) {
+      min = 0;
+    }
+    return min;
+  }
+  getMaxValue() {
+    var _a, _b;
+    let max = this.toFloat(Number.MAX_SAFE_INTEGER);
+    if (((_a = this.options.valueRange) === null || _a === void 0 ? void 0 : _a.max) !== void 0) {
+      max = Math.min((_b = this.options.valueRange) === null || _b === void 0 ? void 0 : _b.max, this.toFloat(Number.MAX_SAFE_INTEGER));
+    }
+    if (!this.options.autoSign && max < 0) {
+      max = this.toFloat(Number.MAX_SAFE_INTEGER);
+    }
+    return max;
+  }
+  toFloat(value, maxFractionDigits) {
+    return value / Math.pow(10, maxFractionDigits !== null && maxFractionDigits !== void 0 ? maxFractionDigits : this.valueScalingFractionDigits);
+  }
+  toInteger(value, maxFractionDigits) {
+    return Number(value.toFixed(maxFractionDigits !== null && maxFractionDigits !== void 0 ? maxFractionDigits : this.valueScalingFractionDigits).split(".").join(""));
+  }
+  validateValueRange(value) {
+    return value != null ? Math.min(Math.max(value, this.minValue), this.maxValue) : value;
+  }
+  applyFixedFractionFormat(number, forcedChange = false) {
+    this.format(this.currencyFormat.format(this.validateValueRange(number)));
+    if (number !== this.numberValue || forcedChange) {
+      this.dispatchEvent("change");
+    }
+  }
+  format(value, hideNegligibleDecimalDigits = false) {
+    if (value != null) {
+      if (this.decimalSymbolInsertedAt !== void 0) {
+        value = this.currencyFormat.normalizeDecimalSeparator(value, this.decimalSymbolInsertedAt);
+        this.decimalSymbolInsertedAt = void 0;
+      }
+      const conformedValue = this.numberMask.conformToMask(value, this.formattedValue);
+      let formattedValue;
+      if (typeof conformedValue === "object") {
+        const { numberValue, fractionDigits } = conformedValue;
+        let { maximumFractionDigits, minimumFractionDigits } = this.currencyFormat;
+        if (this.focus) {
+          minimumFractionDigits = hideNegligibleDecimalDigits ? fractionDigits.replace(/0+$/, "").length : Math.min(maximumFractionDigits, fractionDigits.length);
+        } else if (Number.isInteger(numberValue) && !this.options.autoDecimalDigits && (this.options.precision === void 0 || minimumFractionDigits === 0)) {
+          minimumFractionDigits = maximumFractionDigits = 0;
+        }
+        formattedValue = this.toInteger(Math.abs(numberValue)) > Number.MAX_SAFE_INTEGER ? this.formattedValue : this.currencyFormat.format(numberValue, {
+          useGrouping: this.options.useGrouping && !(this.focus && this.options.hideGroupingSeparatorOnFocus),
+          minimumFractionDigits,
+          maximumFractionDigits
+        });
+      } else {
+        formattedValue = conformedValue;
+      }
+      if (this.options.autoSign) {
+        if (this.maxValue <= 0 && !this.currencyFormat.isNegative(formattedValue) && this.currencyFormat.parse(formattedValue) !== 0) {
+          formattedValue = formattedValue.replace(this.currencyFormat.prefix, this.currencyFormat.negativePrefix);
+        }
+        if (this.minValue >= 0) {
+          formattedValue = formattedValue.replace(this.currencyFormat.negativePrefix, this.currencyFormat.prefix);
+        }
+      }
+      if (this.options.currencyDisplay === CurrencyDisplay.hidden || this.focus && this.options.hideCurrencySymbolOnFocus) {
+        formattedValue = formattedValue.replace(this.currencyFormat.negativePrefix, this.currencyFormat.minusSign !== void 0 ? this.currencyFormat.minusSign : "(").replace(this.currencyFormat.negativeSuffix, this.currencyFormat.minusSign !== void 0 ? "" : ")").replace(this.currencyFormat.prefix, "").replace(this.currencyFormat.suffix, "");
+      }
+      this.el.value = formattedValue;
+      this.numberValue = this.currencyFormat.parse(formattedValue);
+    } else {
+      this.el.value = "";
+      this.numberValue = null;
+    }
+    this.formattedValue = this.el.value;
+    this.dispatchEvent("input");
+  }
+  addEventListener() {
+    this.el.addEventListener("input", (e) => {
+      if (!e.detail) {
+        const { value, selectionStart } = this.el;
+        const inputEvent = e;
+        if (selectionStart && inputEvent.data && DECIMAL_SEPARATORS.includes(inputEvent.data)) {
+          this.decimalSymbolInsertedAt = selectionStart - 1;
+        }
+        this.format(value);
+        if (this.focus && selectionStart != null) {
+          const getCaretPositionAfterFormat = () => {
+            const { prefix, suffix, decimalSymbol, maximumFractionDigits, groupingSymbol } = this.currencyFormat;
+            let caretPositionFromLeft = value.length - selectionStart;
+            const newValueLength = this.formattedValue.length;
+            if (this.currencyFormat.minusSign === void 0 && (value.startsWith("(") || value.startsWith("-")) && !value.endsWith(")")) {
+              return newValueLength - this.currencyFormat.negativeSuffix.length > 1 ? this.formattedValue.substring(selectionStart).length : 1;
+            }
+            if (this.formattedValue.substr(selectionStart, 1) === groupingSymbol && count(this.formattedValue, groupingSymbol) === count(value, groupingSymbol) + 1) {
+              return newValueLength - caretPositionFromLeft - 1;
+            }
+            if (newValueLength < caretPositionFromLeft) {
+              return selectionStart;
+            }
+            if (decimalSymbol !== void 0 && value.indexOf(decimalSymbol) !== -1) {
+              const decimalSymbolPosition = value.indexOf(decimalSymbol) + 1;
+              if (Math.abs(newValueLength - value.length) > 1 && selectionStart <= decimalSymbolPosition) {
+                return this.formattedValue.indexOf(decimalSymbol) + 1;
+              } else {
+                if (!this.options.autoDecimalDigits && selectionStart > decimalSymbolPosition) {
+                  if (this.currencyFormat.onlyDigits(value.substr(decimalSymbolPosition)).length - 1 === maximumFractionDigits) {
+                    caretPositionFromLeft -= 1;
+                  }
+                }
+              }
+            }
+            return this.options.hideCurrencySymbolOnFocus || this.options.currencyDisplay === CurrencyDisplay.hidden ? newValueLength - caretPositionFromLeft : Math.max(newValueLength - Math.max(caretPositionFromLeft, suffix.length), prefix.length);
+          };
+          this.setCaretPosition(getCaretPositionAfterFormat());
+        }
+      }
+    }, { capture: true });
+    this.el.addEventListener("focus", () => {
+      this.focus = true;
+      setTimeout(() => {
+        const { value, selectionStart, selectionEnd } = this.el;
+        this.format(value, this.options.hideNegligibleDecimalDigitsOnFocus);
+        if (selectionStart != null && selectionEnd != null && Math.abs(selectionStart - selectionEnd) > 0) {
+          this.setCaretPosition(0, this.el.value.length);
+        } else if (selectionStart != null) {
+          const caretPositionOnFocus = this.getCaretPositionOnFocus(value, selectionStart);
+          this.setCaretPosition(caretPositionOnFocus);
+        }
+      });
+    });
+    this.el.addEventListener("blur", () => {
+      this.focus = false;
+      this.applyFixedFractionFormat(this.numberValue);
+    });
+    this.el.addEventListener("change", (e) => {
+      if (!e.detail) {
+        this.dispatchEvent("change");
+      }
+    }, { capture: true });
+  }
+  getCaretPositionOnFocus(value, selectionStart) {
+    if (this.numberValue == null) {
+      return selectionStart;
+    }
+    const { prefix, negativePrefix, suffix, negativeSuffix, groupingSymbol, currency } = this.currencyFormat;
+    const isNegative = this.numberValue < 0;
+    const currentPrefix = isNegative ? negativePrefix : prefix;
+    const prefixLength = currentPrefix.length;
+    if (this.options.hideCurrencySymbolOnFocus || this.options.currencyDisplay === CurrencyDisplay.hidden) {
+      if (isNegative) {
+        if (selectionStart <= 1) {
+          return 1;
+        } else if (value.endsWith(")") && selectionStart > value.indexOf(")")) {
+          return this.formattedValue.length - 1;
+        }
+      }
+    } else {
+      const suffixLength = isNegative ? negativeSuffix.length : suffix.length;
+      if (selectionStart >= value.length - suffixLength) {
+        return this.formattedValue.length - suffixLength;
+      } else if (selectionStart < prefixLength) {
+        return prefixLength;
+      }
+    }
+    let result = selectionStart;
+    if (this.options.hideCurrencySymbolOnFocus && this.options.currencyDisplay !== CurrencyDisplay.hidden && selectionStart >= prefixLength && currency !== void 0 && currentPrefix.includes(currency)) {
+      result -= prefixLength;
+      if (isNegative) {
+        result += 1;
+      }
+    }
+    if (this.options.hideGroupingSeparatorOnFocus && groupingSymbol !== void 0) {
+      result -= count(value.substring(0, selectionStart), groupingSymbol);
+    }
+    return result;
+  }
+  setCaretPosition(start, end = start) {
+    this.el.setSelectionRange(start, end);
+  }
+}
+const findInput = (el) => (el === null || el === void 0 ? void 0 : el.matches("input")) ? el : el === null || el === void 0 ? void 0 : el.querySelector("input");
+var useCurrencyInput = (options) => {
+  var _a;
+  let numberInput;
+  let input2;
+  const inputRef = ref(null);
+  const formattedValue = ref(null);
+  const instance = getCurrentInstance();
+  const emit = (event, value) => instance === null || instance === void 0 ? void 0 : instance.emit(event, value);
+  const lazyModel = (_a = instance === null || instance === void 0 ? void 0 : instance.attrs.modelModifiers) === null || _a === void 0 ? void 0 : _a.lazy;
+  const numberValue = computed(() => instance === null || instance === void 0 ? void 0 : instance.props["modelValue"]);
+  const inputEvent = "update:modelValue";
+  const changeEvent = lazyModel ? "update:modelValue" : "change";
+  const hasInputEventListener = !lazyModel;
+  const hasChangeEventListener = lazyModel || !(instance === null || instance === void 0 ? void 0 : instance.attrs.onChange);
+  const onInput = (e) => {
+    if (e.detail) {
+      if (numberValue.value !== e.detail.number) {
+        emit(inputEvent, e.detail.number);
+      }
+      formattedValue.value = e.detail.formatted;
+    }
+  };
+  const onChange = (e) => {
+    if (e.detail) {
+      emit(changeEvent, e.detail.number);
+      formattedValue.value = e.detail.formatted;
+    }
+  };
+  watch(inputRef, (value) => {
+    var _a2, _b;
+    if (value) {
+      input2 = findInput((_b = (_a2 = value) === null || _a2 === void 0 ? void 0 : _a2.$el) !== null && _b !== void 0 ? _b : value);
+      if (input2) {
+        numberInput = new CurrencyInput(input2, options);
+        if (hasInputEventListener) {
+          input2.addEventListener("input", onInput);
+        }
+        if (hasChangeEventListener) {
+          input2.addEventListener("change", onChange);
+        }
+        numberInput.setValue(numberValue.value);
+      } else {
+        console.error('No input element found. Please make sure that the "inputRef" template ref is properly assigned.');
+      }
+    } else {
+      numberInput = null;
+    }
+  });
+  onUnmounted(() => {
+    if (hasInputEventListener) {
+      input2 === null || input2 === void 0 ? void 0 : input2.removeEventListener("input", onInput);
+    }
+    if (hasChangeEventListener) {
+      input2 === null || input2 === void 0 ? void 0 : input2.removeEventListener("change", onChange);
+    }
+  });
+  return {
+    inputRef,
+    formattedValue,
+    setValue: (value) => numberInput === null || numberInput === void 0 ? void 0 : numberInput.setValue(value),
+    setOptions: (options2) => numberInput === null || numberInput === void 0 ? void 0 : numberInput.setOptions(options2)
+  };
+};
+var plCurrency_vue_vue_type_style_index_0_lang = "";
+const _hoisted_1 = /* @__PURE__ */ createElementVNode("span", { class: "pl-currency__rub-icon" }, "\u20BD", -1);
+const __default__ = {
+  name: "PlCurrency"
+};
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    modelValue: String,
+    width: String
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const innerValue = ref(null);
+    const options = reactive({
+      currency: "EUR",
+      currencyDisplay: "hidden",
+      precision: 2
+    });
+    const { inputRef } = useCurrencyInput(options);
+    watch(innerValue, (newValue) => {
+      emit("update:modelValue", newValue);
+    });
+    return (_ctx, _cache) => {
+      const _component_el_input = ElInput;
+      return openBlock(), createBlock(_component_el_input, mergeProps({
+        style: `width: ${__props.width};`
+      }, _ctx.$attrs, {
+        ref_key: "inputRef",
+        ref: inputRef,
+        modelValue: innerValue.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => innerValue.value = $event),
+        class: "pl-currency"
+      }), {
+        append: withCtx(() => [
+          _hoisted_1
+        ]),
+        _: 1
+      }, 16, ["style", "modelValue"]);
+    };
+  }
+});
+export { _sfc_main as PlCurrency, _sfc_main$1 as TestViteNpmComponent };