@factoringplus/pl-components-pack-v3 0.1.14 → 0.1.17

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

@@ -1,12 +1,938 @@
-import "vue";
+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, onUnmounted, reactive } 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 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$6 = defineComponent({
+  name: "CircleCheck"
+});
+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$4 = /* @__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$4,
+  _hoisted_3$3
+];
+function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$5, _hoisted_4$1);
+}
+var circleCheck = /* @__PURE__ */ _export_sfc$1(_sfc_main$6, [["render", _sfc_render$4]]);
+const _sfc_main$5 = defineComponent({
+  name: "CircleClose"
+});
+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$3 = /* @__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$3,
+  _hoisted_3$2
+];
+function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$4, _hoisted_4);
+}
+var circleClose = /* @__PURE__ */ _export_sfc$1(_sfc_main$5, [["render", _sfc_render$3]]);
+const _sfc_main$4 = defineComponent({
+  name: "Loading"
+});
+const _hoisted_1$3 = {
+  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 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$2
+];
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$3, _hoisted_3$1);
+}
+var loading = /* @__PURE__ */ _export_sfc$1(_sfc_main$4, [["render", _sfc_render$2]]);
+const _sfc_main$3 = defineComponent({
+  name: "View"
+});
+const _hoisted_1$2 = {
+  class: "icon",
+  width: "200",
+  height: "200",
+  viewBox: "0 0 1024 1024",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2$1 = /* @__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$1
+];
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$2, _hoisted_3);
+}
+var view = /* @__PURE__ */ _export_sfc$1(_sfc_main$3, [["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;
+};
+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 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__$1 = {
+  name: "ElIcon",
+  inheritAttrs: false
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$1), {
+  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$2);
+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$1 = 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$1 = ["type", "disabled", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder"];
+const _hoisted_2 = ["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$1),
+      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),
+      _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$1, [["render", _sfc_render]]);
+const ElInput = withInstall(Input);
 var base = "";
-var button = "";
 var input = "";
 /**
  * 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";
@@ -22,4 +948,538 @@ var ValueScaling;
   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"]);
+    };
+  }
+});
+const PlCurrencyPlugin = {
+  install(app) {
+    app.component(_sfc_main);
+  }
+};
+export { PlCurrencyPlugin as default };