vxe-pc-ui 4.20.34 → 4.20.35

package/lib/color-picker/src/color-picker.js

@@ -42,1185 +42,1188 @@ var import_button = __toESM(require("../../button"));
 var import_input = __toESM(require("../../input"));
 var import_number_input = __toESM(require("../../number-input"));
 const { getIcon, getConfig, getI18n, globalEvents, createEvent, useFns, renderEmptyElement } = import_core.VxeUI;
-var color_picker_default = (0, import_comp.defineVxeComponent)({
-  name: "VxeColorPicker",
-  props: {
-    modelValue: String,
-    placeholder: String,
-    clearable: {
-      type: Boolean,
-      default: () => getConfig().colorPicker.clearable
+var color_picker_default = (
+  /* define-vxe-component start */
+  (0, import_comp.defineVxeComponent)({
+    name: "VxeColorPicker",
+    props: {
+      modelValue: String,
+      placeholder: String,
+      clearable: {
+        type: Boolean,
+        default: () => getConfig().colorPicker.clearable
+      },
+      type: {
+        type: String,
+        default: () => getConfig().colorPicker.type
+      },
+      width: [Number, String],
+      size: {
+        type: String,
+        default: () => getConfig().colorPicker.size || getConfig().size
+      },
+      className: [String, Function],
+      popupClassName: [String, Function],
+      colors: {
+        type: Array,
+        default: () => import_xe_utils.default.clone(getConfig().colorPicker.colors, true) || []
+      },
+      showAlpha: {
+        type: Boolean,
+        default: () => getConfig().colorPicker.showAlpha
+      },
+      showEyeDropper: {
+        type: Boolean,
+        default: () => getConfig().colorPicker.showEyeDropper
+      },
+      showColorExtractor: {
+        type: Boolean,
+        default: () => getConfig().colorPicker.showColorExtractor
+      },
+      showQuick: {
+        type: Boolean,
+        default: () => getConfig().colorPicker.showQuick
+      },
+      readonly: {
+        type: Boolean,
+        default: null
+      },
+      disabled: {
+        type: Boolean,
+        default: null
+      },
+      clickToCopy: {
+        type: Boolean,
+        default: () => getConfig().colorPicker.clickToCopy
+      },
+      defaultColor: {
+        type: String,
+        default: () => getConfig().colorPicker.defaultColor
+      },
+      /**
+       * 已废弃，请使用 popupConfig.placement
+       * @deprecated
+       */
+      placement: String,
+      /**
+       * 已废弃，请使用 popupConfig.transfer
+       * @deprecated
+       */
+      transfer: {
+        type: Boolean,
+        default: null
+      },
+      popupConfig: Object
     },
-    type: {
-      type: String,
-      default: () => getConfig().colorPicker.type
-    },
-    width: [Number, String],
-    size: {
-      type: String,
-      default: () => getConfig().colorPicker.size || getConfig().size
-    },
-    className: [String, Function],
-    popupClassName: [String, Function],
-    colors: {
-      type: Array,
-      default: () => import_xe_utils.default.clone(getConfig().colorPicker.colors, true) || []
-    },
-    showAlpha: {
-      type: Boolean,
-      default: () => getConfig().colorPicker.showAlpha
-    },
-    showEyeDropper: {
-      type: Boolean,
-      default: () => getConfig().colorPicker.showEyeDropper
-    },
-    showColorExtractor: {
-      type: Boolean,
-      default: () => getConfig().colorPicker.showColorExtractor
-    },
-    showQuick: {
-      type: Boolean,
-      default: () => getConfig().colorPicker.showQuick
-    },
-    readonly: {
-      type: Boolean,
-      default: null
-    },
-    disabled: {
-      type: Boolean,
-      default: null
-    },
-    clickToCopy: {
-      type: Boolean,
-      default: () => getConfig().colorPicker.clickToCopy
-    },
-    defaultColor: {
-      type: String,
-      default: () => getConfig().colorPicker.defaultColor
-    },
-    /**
-     * 已废弃，请使用 popupConfig.placement
-     * @deprecated
-     */
-    placement: String,
-    /**
-     * 已废弃，请使用 popupConfig.transfer
-     * @deprecated
-     */
-    transfer: {
-      type: Boolean,
-      default: null
-    },
-    popupConfig: Object
-  },
-  emits: ["update:modelValue", "change", "clear", "click"],
-  setup(props, context) {
-    const { emit } = context;
-    const $xeModal = (0, import_vue.inject)("$xeModal", null);
-    const $xeDrawer = (0, import_vue.inject)("$xeDrawer", null);
-    const $xeTable = (0, import_vue.inject)("$xeTable", null);
-    const $xeCard = (0, import_vue.inject)("$xeCard", null);
-    const $xeForm = (0, import_vue.inject)("$xeForm", null);
-    const formItemInfo = (0, import_vue.inject)("xeFormItemInfo", null);
-    const WinEyeDropper = typeof window !== "undefined" ? window.EyeDropper : null;
-    const xID = import_xe_utils.default.uniqueId();
-    const { computeSize } = useFns.useSize(props);
-    const refElem = (0, import_vue.ref)();
-    const refInputTarget = (0, import_vue.ref)();
-    const refOptionPanel = (0, import_vue.ref)();
-    const refHueSliderElem = (0, import_vue.ref)();
-    const refHueSliderBtnElem = (0, import_vue.ref)();
-    const refAlphaSliderElem = (0, import_vue.ref)();
-    const refAlphaSliderBtnElem = (0, import_vue.ref)();
-    const refColorPanelElem = (0, import_vue.ref)();
-    const refColorActiveElem = (0, import_vue.ref)();
-    const reactData = (0, import_vue.reactive)({
-      initialized: false,
-      selectTyle: "hex",
-      selectColor: `${props.modelValue || ""}`,
-      showTypePopup: false,
-      panelColor: "",
-      hexValue: "",
-      rValue: 0,
-      gValue: 0,
-      bValue: 0,
-      aValue: 0,
-      panelIndex: 0,
-      panelStyle: {},
-      panelPlacement: null,
-      visiblePanel: false,
-      isAniVisible: false,
-      isActivated: false
-    });
-    const typeList = [
-      { label: "HEX", value: "hex" },
-      { label: "RGB", value: "rgb" }
-    ];
-    const internalData = {
-      // hpTimeout: undefined
-    };
-    const computeFormReadonly = (0, import_vue.computed)(() => {
-      const { readonly } = props;
-      if (readonly === null) {
-        if ($xeForm) {
-          return $xeForm.props.readonly;
-        }
-        return false;
-      }
-      return readonly;
-    });
-    const computeIsDisabled = (0, import_vue.computed)(() => {
-      const { disabled } = props;
-      if (disabled === null) {
-        if ($xeForm) {
-          return $xeForm.props.disabled;
+    emits: ["update:modelValue", "change", "clear", "click"],
+    setup(props, context) {
+      const { emit } = context;
+      const $xeModal = (0, import_vue.inject)("$xeModal", null);
+      const $xeDrawer = (0, import_vue.inject)("$xeDrawer", null);
+      const $xeTable = (0, import_vue.inject)("$xeTable", null);
+      const $xeCard = (0, import_vue.inject)("$xeCard", null);
+      const $xeForm = (0, import_vue.inject)("$xeForm", null);
+      const formItemInfo = (0, import_vue.inject)("xeFormItemInfo", null);
+      const WinEyeDropper = typeof window !== "undefined" ? window.EyeDropper : null;
+      const xID = import_xe_utils.default.uniqueId();
+      const { computeSize } = useFns.useSize(props);
+      const refElem = (0, import_vue.ref)();
+      const refInputTarget = (0, import_vue.ref)();
+      const refOptionPanel = (0, import_vue.ref)();
+      const refHueSliderElem = (0, import_vue.ref)();
+      const refHueSliderBtnElem = (0, import_vue.ref)();
+      const refAlphaSliderElem = (0, import_vue.ref)();
+      const refAlphaSliderBtnElem = (0, import_vue.ref)();
+      const refColorPanelElem = (0, import_vue.ref)();
+      const refColorActiveElem = (0, import_vue.ref)();
+      const reactData = (0, import_vue.reactive)({
+        initialized: false,
+        selectTyle: "hex",
+        selectColor: `${props.modelValue || ""}`,
+        showTypePopup: false,
+        panelColor: "",
+        hexValue: "",
+        rValue: 0,
+        gValue: 0,
+        bValue: 0,
+        aValue: 0,
+        panelIndex: 0,
+        panelStyle: {},
+        panelPlacement: null,
+        visiblePanel: false,
+        isAniVisible: false,
+        isActivated: false
+      });
+      const typeList = [
+        { label: "HEX", value: "hex" },
+        { label: "RGB", value: "rgb" }
+      ];
+      const internalData = {
+        // hpTimeout: undefined
+      };
+      const computeFormReadonly = (0, import_vue.computed)(() => {
+        const { readonly } = props;
+        if (readonly === null) {
+          if ($xeForm) {
+            return $xeForm.props.readonly;
+          }
+          return false;
         }
-        return false;
-      }
-      return disabled;
-    });
-    const computeBtnTransfer = (0, import_vue.computed)(() => {
-      const { transfer } = props;
-      if (transfer === null) {
-        const globalTransfer = getConfig().colorPicker.transfer;
-        if (import_xe_utils.default.isBoolean(globalTransfer)) {
-          return globalTransfer;
+        return readonly;
+      });
+      const computeIsDisabled = (0, import_vue.computed)(() => {
+        const { disabled } = props;
+        if (disabled === null) {
+          if ($xeForm) {
+            return $xeForm.props.disabled;
+          }
+          return false;
         }
-        if ($xeTable || $xeModal || $xeDrawer || $xeCard || $xeForm) {
-          return true;
+        return disabled;
+      });
+      const computeBtnTransfer = (0, import_vue.computed)(() => {
+        const { transfer } = props;
+        if (transfer === null) {
+          const globalTransfer = getConfig().colorPicker.transfer;
+          if (import_xe_utils.default.isBoolean(globalTransfer)) {
+            return globalTransfer;
+          }
+          if ($xeTable || $xeModal || $xeDrawer || $xeCard || $xeForm) {
+            return true;
+          }
         }
-      }
-      return transfer;
-    });
-    const computeColorList = (0, import_vue.computed)(() => {
-      const { colors } = props;
-      if (colors) {
-        return colors.map((item) => {
-          if (import_xe_utils.default.isString(item)) {
+        return transfer;
+      });
+      const computeColorList = (0, import_vue.computed)(() => {
+        const { colors } = props;
+        if (colors) {
+          return colors.map((item) => {
+            if (import_xe_utils.default.isString(item)) {
+              return {
+                label: item,
+                value: item
+              };
+            }
             return {
-              label: item,
-              value: item
+              label: import_xe_utils.default.eqNull(item.label) ? item.value : item.label,
+              value: item.value
             };
-          }
-          return {
-            label: import_xe_utils.default.eqNull(item.label) ? item.value : item.label,
-            value: item.value
-          };
-        });
-      }
-      return [];
-    });
-    const computeCurrStyle = (0, import_vue.computed)(() => {
-      const { width } = props;
-      const stys = {};
-      if (width) {
-        stys.width = (0, import_dom.toCssUnit)(width);
-      }
-      return stys;
-    });
-    const computePopupOpts = (0, import_vue.computed)(() => {
-      return Object.assign({}, getConfig().colorPicker.popupConfig, props.popupConfig);
-    });
-    const computeIsRgb = (0, import_vue.computed)(() => {
-      const { selectTyle } = reactData;
-      return selectTyle === "rgb";
-    });
-    const computeSelectTypeItem = (0, import_vue.computed)(() => {
-      const { selectTyle } = reactData;
-      return typeList.find((item) => item.value === selectTyle);
-    });
-    const refMaps = {
-      refElem
-    };
-    const computeMaps = {};
-    const $xeColorPicker = {
-      xID,
-      props,
-      context,
-      reactData,
-      getRefMaps: () => refMaps,
-      getComputeMaps: () => computeMaps
-    };
-    const emitModel = (value) => {
-      emit("update:modelValue", value);
-    };
-    const updateMode = () => {
-      const { modelValue } = props;
-      reactData.selectColor = import_xe_utils.default.toValueString(modelValue);
-      updateModelColor();
-    };
-    const updateType = () => {
-      const { type } = props;
-      let selectTyle = "hex";
-      if (type === "rgb" || type === "rgba") {
-        selectTyle = "rgb";
-      }
-      reactData.selectTyle = selectTyle;
-      updateMode();
-    };
-    const updateModelColor = () => {
-      const { defaultColor } = props;
-      const { selectColor, isAniVisible } = reactData;
-      const isRgb = computeIsRgb.value;
-      const hueSliderEl = refHueSliderElem.value;
-      const alphaSliderEl = refAlphaSliderElem.value;
-      const colorRest = (0, import_util.parseValColor)(selectColor || defaultColor);
-      reactData.hexValue = "";
-      reactData.rValue = 0;
-      reactData.gValue = 0;
-      reactData.bValue = 0;
-      reactData.aValue = 1;
-      if (colorRest) {
-        if (colorRest.type === "hex") {
-          reactData.hexValue = colorRest.hex;
-        } else {
-          reactData.rValue = colorRest.r;
-          reactData.gValue = colorRest.g;
-          reactData.bValue = colorRest.b;
-          reactData.aValue = colorRest.a;
+          });
         }
-        if (colorRest.value) {
-          if (isRgb) {
-            if (colorRest.type === "hex") {
-              const rgbRest = (0, import_util.hexToRgb)(colorRest.hex);
-              if (rgbRest) {
-                reactData.rValue = rgbRest.r;
-                reactData.gValue = rgbRest.g;
-                reactData.bValue = rgbRest.b;
-                reactData.aValue = rgbRest.a;
-              }
-            }
+        return [];
+      });
+      const computeCurrStyle = (0, import_vue.computed)(() => {
+        const { width } = props;
+        const stys = {};
+        if (width) {
+          stys.width = (0, import_dom.toCssUnit)(width);
+        }
+        return stys;
+      });
+      const computePopupOpts = (0, import_vue.computed)(() => {
+        return Object.assign({}, getConfig().colorPicker.popupConfig, props.popupConfig);
+      });
+      const computeIsRgb = (0, import_vue.computed)(() => {
+        const { selectTyle } = reactData;
+        return selectTyle === "rgb";
+      });
+      const computeSelectTypeItem = (0, import_vue.computed)(() => {
+        const { selectTyle } = reactData;
+        return typeList.find((item) => item.value === selectTyle);
+      });
+      const refMaps = {
+        refElem
+      };
+      const computeMaps = {};
+      const $xeColorPicker = {
+        xID,
+        props,
+        context,
+        reactData,
+        getRefMaps: () => refMaps,
+        getComputeMaps: () => computeMaps
+      };
+      const emitModel = (value) => {
+        emit("update:modelValue", value);
+      };
+      const updateMode = () => {
+        const { modelValue } = props;
+        reactData.selectColor = import_xe_utils.default.toValueString(modelValue);
+        updateModelColor();
+      };
+      const updateType = () => {
+        const { type } = props;
+        let selectTyle = "hex";
+        if (type === "rgb" || type === "rgba") {
+          selectTyle = "rgb";
+        }
+        reactData.selectTyle = selectTyle;
+        updateMode();
+      };
+      const updateModelColor = () => {
+        const { defaultColor } = props;
+        const { selectColor, isAniVisible } = reactData;
+        const isRgb = computeIsRgb.value;
+        const hueSliderEl = refHueSliderElem.value;
+        const alphaSliderEl = refAlphaSliderElem.value;
+        const colorRest = (0, import_util.parseValColor)(selectColor || defaultColor);
+        reactData.hexValue = "";
+        reactData.rValue = 0;
+        reactData.gValue = 0;
+        reactData.bValue = 0;
+        reactData.aValue = 1;
+        if (colorRest) {
+          if (colorRest.type === "hex") {
+            reactData.hexValue = colorRest.hex;
           } else {
-            if (colorRest.type !== "hex") {
-              reactData.hexValue = (0, import_util.rgbToHexVal)(colorRest.r, colorRest.g, colorRest.b, colorRest.a);
+            reactData.rValue = colorRest.r;
+            reactData.gValue = colorRest.g;
+            reactData.bValue = colorRest.b;
+            reactData.aValue = colorRest.a;
+          }
+          if (colorRest.value) {
+            if (isRgb) {
+              if (colorRest.type === "hex") {
+                const rgbRest = (0, import_util.hexToRgb)(colorRest.hex);
+                if (rgbRest) {
+                  reactData.rValue = rgbRest.r;
+                  reactData.gValue = rgbRest.g;
+                  reactData.bValue = rgbRest.b;
+                  reactData.aValue = rgbRest.a;
+                }
+              }
+            } else {
+              if (colorRest.type !== "hex") {
+                reactData.hexValue = (0, import_util.rgbToHexVal)(colorRest.r, colorRest.g, colorRest.b, colorRest.a);
+              }
             }
           }
         }
-      }
-      if (isAniVisible) {
-        const hsvRest = colorRest ? colorRest.type === "hex" ? (0, import_util.hexToHsv)(colorRest.hex) : (0, import_util.rgbToHsv)(colorRest) : null;
-        const colorPanelEl = refColorPanelElem.value;
-        if (hsvRest) {
-          if (colorPanelEl) {
-            const offsetTop = colorPanelEl.clientHeight * (1 - hsvRest.v);
-            const offsetLeft = colorPanelEl.clientWidth * hsvRest.s;
-            handlePanelColor(offsetLeft, offsetTop);
+        if (isAniVisible) {
+          const hsvRest = colorRest ? colorRest.type === "hex" ? (0, import_util.hexToHsv)(colorRest.hex) : (0, import_util.rgbToHsv)(colorRest) : null;
+          const colorPanelEl = refColorPanelElem.value;
+          if (hsvRest) {
+            if (colorPanelEl) {
+              const offsetTop = colorPanelEl.clientHeight * (1 - hsvRest.v);
+              const offsetLeft = colorPanelEl.clientWidth * hsvRest.s;
+              handlePanelColor(offsetLeft, offsetTop);
+            }
+            if (hueSliderEl) {
+              handleHueColor(import_xe_utils.default.ceil((1 - hsvRest.h / 360) * hueSliderEl.clientWidth) - 1);
+            }
           }
-          if (hueSliderEl) {
-            handleHueColor(import_xe_utils.default.ceil((1 - hsvRest.h / 360) * hueSliderEl.clientWidth) - 1);
+          if (alphaSliderEl) {
+            handleAlphaColor(alphaSliderEl.clientWidth * reactData.aValue);
           }
         }
-        if (alphaSliderEl) {
-          handleAlphaColor(alphaSliderEl.clientWidth * reactData.aValue);
+      };
+      const updateZindex = () => {
+        if (reactData.panelIndex < (0, import_utils.getLastZIndex)()) {
+          reactData.panelIndex = (0, import_utils.nextZIndex)();
         }
-      }
-    };
-    const updateZindex = () => {
-      if (reactData.panelIndex < (0, import_utils.getLastZIndex)()) {
-        reactData.panelIndex = (0, import_utils.nextZIndex)();
-      }
-    };
-    const updatePlacement = () => {
-      const { placement } = props;
-      const { panelIndex } = reactData;
-      const targetElem = refElem.value;
-      const panelElem = refOptionPanel.value;
-      const btnTransfer = computeBtnTransfer.value;
-      const popupOpts = computePopupOpts.value;
-      const handleStyle = () => {
-        const ppObj = (0, import_dom.updatePanelPlacement)(targetElem, panelElem, {
-          placement: popupOpts.placement || placement,
-          defaultPlacement: popupOpts.defaultPlacement,
-          appendTo: popupOpts.appendTo,
-          teleportTo: btnTransfer
-        });
-        const panelStyle = Object.assign(ppObj.style, {
-          zIndex: panelIndex
-        });
-        reactData.panelStyle = panelStyle;
-        reactData.panelPlacement = ppObj.placement;
       };
-      handleStyle();
-      return (0, import_vue.nextTick)().then(handleStyle);
-    };
-    const showOptionPanel = () => {
-      const { hpTimeout } = internalData;
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled) {
-        if (hpTimeout) {
-          clearTimeout(hpTimeout);
-          internalData.hpTimeout = void 0;
+      const updatePlacement = () => {
+        const { placement } = props;
+        const { panelIndex } = reactData;
+        const targetElem = refElem.value;
+        const panelElem = refOptionPanel.value;
+        const btnTransfer = computeBtnTransfer.value;
+        const popupOpts = computePopupOpts.value;
+        const handleStyle = () => {
+          const ppObj = (0, import_dom.updatePanelPlacement)(targetElem, panelElem, {
+            placement: popupOpts.placement || placement,
+            defaultPlacement: popupOpts.defaultPlacement,
+            appendTo: popupOpts.appendTo,
+            teleportTo: btnTransfer
+          });
+          const panelStyle = Object.assign(ppObj.style, {
+            zIndex: panelIndex
+          });
+          reactData.panelStyle = panelStyle;
+          reactData.panelPlacement = ppObj.placement;
+        };
+        handleStyle();
+        return (0, import_vue.nextTick)().then(handleStyle);
+      };
+      const showOptionPanel = () => {
+        const { hpTimeout } = internalData;
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled) {
+          if (hpTimeout) {
+            clearTimeout(hpTimeout);
+            internalData.hpTimeout = void 0;
+          }
+          if (!reactData.initialized) {
+            reactData.initialized = true;
+          }
+          reactData.isActivated = true;
+          reactData.isAniVisible = true;
+          setTimeout(() => {
+            updateModelColor();
+            reactData.visiblePanel = true;
+          }, 10);
+          updateZindex();
+          updatePlacement();
         }
-        if (!reactData.initialized) {
-          reactData.initialized = true;
+      };
+      const hideOptionPanel = () => {
+        reactData.visiblePanel = false;
+        internalData.hpTimeout = setTimeout(() => {
+          reactData.isAniVisible = false;
+        }, 350);
+      };
+      const changeEvent = (evnt, value) => {
+        reactData.selectColor = value;
+        if (value !== props.modelValue) {
+          emitModel(value);
+          dispatchEvent("change", { value }, evnt);
+          if ($xeForm && formItemInfo) {
+            $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
+          }
         }
-        reactData.isActivated = true;
-        reactData.isAniVisible = true;
-        setTimeout(() => {
-          updateModelColor();
-          reactData.visiblePanel = true;
-        }, 10);
-        updateZindex();
-        updatePlacement();
-      }
-    };
-    const hideOptionPanel = () => {
-      reactData.visiblePanel = false;
-      internalData.hpTimeout = setTimeout(() => {
-        reactData.isAniVisible = false;
-      }, 350);
-    };
-    const changeEvent = (evnt, value) => {
-      reactData.selectColor = value;
-      if (value !== props.modelValue) {
-        emitModel(value);
-        dispatchEvent("change", { value }, evnt);
-        if ($xeForm && formItemInfo) {
-          $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
+      };
+      const clearValueEvent = (evnt, selectValue) => {
+        changeEvent(evnt, selectValue);
+        dispatchEvent("clear", { value: selectValue }, evnt);
+      };
+      const focusEvent = () => {
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled) {
+          if (!reactData.visiblePanel) {
+            showOptionPanel();
+          }
         }
-      }
-    };
-    const clearValueEvent = (evnt, selectValue) => {
-      changeEvent(evnt, selectValue);
-      dispatchEvent("clear", { value: selectValue }, evnt);
-    };
-    const focusEvent = () => {
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled) {
-        if (!reactData.visiblePanel) {
+      };
+      const blurEvent = () => {
+        reactData.isActivated = false;
+      };
+      const clearEvent = (evnt) => {
+        clearValueEvent(evnt, null);
+        hideOptionPanel();
+      };
+      const confirmEvent = (evnt) => {
+        const { selectTyle, selectColor, hexValue } = reactData;
+        const value = selectTyle === "hex" ? hexValue : selectColor;
+        changeEvent(evnt, value);
+        hideOptionPanel();
+      };
+      const togglePanelEvent = (evnt) => {
+        evnt.preventDefault();
+        if (reactData.visiblePanel) {
+          hideOptionPanel();
+        } else {
           showOptionPanel();
         }
-      }
-    };
-    const blurEvent = () => {
-      reactData.isActivated = false;
-    };
-    const clearEvent = (evnt) => {
-      clearValueEvent(evnt, null);
-      hideOptionPanel();
-    };
-    const confirmEvent = (evnt) => {
-      const { selectTyle, selectColor, hexValue } = reactData;
-      const value = selectTyle === "hex" ? hexValue : selectColor;
-      changeEvent(evnt, value);
-      hideOptionPanel();
-    };
-    const togglePanelEvent = (evnt) => {
-      evnt.preventDefault();
-      if (reactData.visiblePanel) {
-        hideOptionPanel();
-      } else {
-        showOptionPanel();
-      }
-    };
-    const clickEvent = (evnt) => {
-      togglePanelEvent(evnt);
-      dispatchEvent("click", {}, evnt);
-    };
-    const handlePanelClickEvent = () => {
-      reactData.showTypePopup = false;
-    };
-    const toggleTypeVisibleEvent = (evnt) => {
-      evnt.stopPropagation();
-      reactData.showTypePopup = !reactData.showTypePopup;
-    };
-    const handleChangeType = (type) => {
-      const { selectTyle } = reactData;
-      if (type !== selectTyle) {
-        reactData.selectTyle = type;
-        updateModelColor();
-      }
-      reactData.showTypePopup = false;
-    };
-    const handleHueColor = (offsetLeft) => {
-      const hueSliderEl = refHueSliderElem.value;
-      const hueSliderBtnEl = refHueSliderBtnElem.value;
-      if (hueSliderEl && hueSliderBtnEl) {
-        if (offsetLeft < 0) {
-          offsetLeft = 0;
+      };
+      const clickEvent = (evnt) => {
+        togglePanelEvent(evnt);
+        dispatchEvent("click", {}, evnt);
+      };
+      const handlePanelClickEvent = () => {
+        reactData.showTypePopup = false;
+      };
+      const toggleTypeVisibleEvent = (evnt) => {
+        evnt.stopPropagation();
+        reactData.showTypePopup = !reactData.showTypePopup;
+      };
+      const handleChangeType = (type) => {
+        const { selectTyle } = reactData;
+        if (type !== selectTyle) {
+          reactData.selectTyle = type;
+          updateModelColor();
+        }
+        reactData.showTypePopup = false;
+      };
+      const handleHueColor = (offsetLeft) => {
+        const hueSliderEl = refHueSliderElem.value;
+        const hueSliderBtnEl = refHueSliderBtnElem.value;
+        if (hueSliderEl && hueSliderBtnEl) {
+          if (offsetLeft < 0) {
+            offsetLeft = 0;
+          }
+          const barWidth = import_xe_utils.default.toInteger(hueSliderEl.clientWidth);
+          const itemNum = 255;
+          const countNum = itemNum * 6;
+          const offsetX = import_xe_utils.default.ceil(countNum / barWidth * offsetLeft);
+          const offsetNum = offsetX % itemNum;
+          let rNum = 0;
+          let gNum = 0;
+          let bNum = 0;
+          switch (Math.ceil(offsetX / itemNum)) {
+            case 1:
+              rNum = itemNum;
+              bNum = offsetNum;
+              break;
+            case 2:
+              rNum = itemNum - offsetNum;
+              bNum = itemNum;
+              break;
+            case 3:
+              gNum = offsetNum;
+              bNum = itemNum;
+              break;
+            case 4:
+              gNum = itemNum;
+              bNum = itemNum - offsetNum;
+              break;
+            case 5:
+              rNum = offsetNum;
+              gNum = itemNum;
+              break;
+            case 6:
+              rNum = itemNum;
+              gNum = itemNum - offsetNum;
+              break;
+          }
+          reactData.panelColor = (0, import_util.toValRgb)(rNum, gNum, bNum);
+          hueSliderBtnEl.style.left = (0, import_dom.toCssUnit)(offsetLeft);
         }
-        const barWidth = import_xe_utils.default.toInteger(hueSliderEl.clientWidth);
-        const itemNum = 255;
-        const countNum = itemNum * 6;
-        const offsetX = import_xe_utils.default.ceil(countNum / barWidth * offsetLeft);
-        const offsetNum = offsetX % itemNum;
-        let rNum = 0;
-        let gNum = 0;
-        let bNum = 0;
-        switch (Math.ceil(offsetX / itemNum)) {
-          case 1:
-            rNum = itemNum;
-            bNum = offsetNum;
-            break;
-          case 2:
-            rNum = itemNum - offsetNum;
-            bNum = itemNum;
-            break;
-          case 3:
-            gNum = offsetNum;
-            bNum = itemNum;
-            break;
-          case 4:
-            gNum = itemNum;
-            bNum = itemNum - offsetNum;
-            break;
-          case 5:
-            rNum = offsetNum;
-            gNum = itemNum;
-            break;
-          case 6:
-            rNum = itemNum;
-            gNum = itemNum - offsetNum;
-            break;
+      };
+      const handleHueBarEvent = (evnt) => {
+        const hueSliderEl = refHueSliderElem.value;
+        const hueSliderBtnEl = refHueSliderBtnElem.value;
+        if (hueSliderEl && hueSliderBtnEl) {
+          const hueSliderRect = hueSliderEl.getBoundingClientRect();
+          const barWidth = import_xe_utils.default.toInteger(hueSliderEl.clientWidth);
+          const offsetLeft = import_xe_utils.default.ceil(Math.min(barWidth - 1, Math.max(1, evnt.clientX - hueSliderRect.x)));
+          handleHueColor(offsetLeft);
         }
-        reactData.panelColor = (0, import_util.toValRgb)(rNum, gNum, bNum);
-        hueSliderBtnEl.style.left = (0, import_dom.toCssUnit)(offsetLeft);
-      }
-    };
-    const handleHueBarEvent = (evnt) => {
-      const hueSliderEl = refHueSliderElem.value;
-      const hueSliderBtnEl = refHueSliderBtnElem.value;
-      if (hueSliderEl && hueSliderBtnEl) {
-        const hueSliderRect = hueSliderEl.getBoundingClientRect();
-        const barWidth = import_xe_utils.default.toInteger(hueSliderEl.clientWidth);
-        const offsetLeft = import_xe_utils.default.ceil(Math.min(barWidth - 1, Math.max(1, evnt.clientX - hueSliderRect.x)));
-        handleHueColor(offsetLeft);
-      }
-    };
-    const handleHueSliderMousedownEvent = (evnt) => {
-      evnt.preventDefault();
-      document.onmousemove = (evnt2) => {
-        evnt2.preventDefault();
-        handleHueBarEvent(evnt2);
       };
-      document.onmouseup = (evnt2) => {
-        document.onmousemove = null;
-        document.onmouseup = null;
-        handleHueBarEvent(evnt2);
+      const handleHueSliderMousedownEvent = (evnt) => {
+        evnt.preventDefault();
+        document.onmousemove = (evnt2) => {
+          evnt2.preventDefault();
+          handleHueBarEvent(evnt2);
+        };
+        document.onmouseup = (evnt2) => {
+          document.onmousemove = null;
+          document.onmouseup = null;
+          handleHueBarEvent(evnt2);
+        };
       };
-    };
-    const handleAlphaColor = (offsetLeft) => {
-      const { selectColor } = reactData;
-      const alphaSliderEl = refAlphaSliderElem.value;
-      const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
-      if (alphaSliderEl && alphaSliderBtnEl) {
-        const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
-        const barWidth = alphaSliderRect.width;
-        if (offsetLeft < 0) {
-          offsetLeft = 0;
+      const handleAlphaColor = (offsetLeft) => {
+        const { selectColor } = reactData;
+        const alphaSliderEl = refAlphaSliderElem.value;
+        const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
+        if (alphaSliderEl && alphaSliderBtnEl) {
+          const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
+          const barWidth = alphaSliderRect.width;
+          if (offsetLeft < 0) {
+            offsetLeft = 0;
+          }
+          if (offsetLeft > barWidth) {
+            offsetLeft = barWidth;
+          }
+          const alpha = import_xe_utils.default.ceil(100 / barWidth * offsetLeft / 100, 2);
+          reactData.aValue = alpha;
+          alphaSliderBtnEl.style.left = (0, import_dom.toCssUnit)(offsetLeft);
+          reactData.selectColor = selectColor ? (0, import_util.updateColorAlpha)(selectColor, alpha) : "";
         }
-        if (offsetLeft > barWidth) {
-          offsetLeft = barWidth;
+      };
+      const handleAlphaBarEvent = (evnt) => {
+        const alphaSliderEl = refAlphaSliderElem.value;
+        const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
+        if (alphaSliderEl && alphaSliderBtnEl) {
+          const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
+          const barWidth = alphaSliderRect.width;
+          const offsetLeft = Math.min(barWidth, Math.max(0, evnt.clientX - alphaSliderRect.x));
+          handleAlphaColor(offsetLeft);
+          updateModelColor();
         }
-        const alpha = import_xe_utils.default.ceil(100 / barWidth * offsetLeft / 100, 2);
-        reactData.aValue = alpha;
-        alphaSliderBtnEl.style.left = (0, import_dom.toCssUnit)(offsetLeft);
-        reactData.selectColor = selectColor ? (0, import_util.updateColorAlpha)(selectColor, alpha) : "";
-      }
-    };
-    const handleAlphaBarEvent = (evnt) => {
-      const alphaSliderEl = refAlphaSliderElem.value;
-      const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
-      if (alphaSliderEl && alphaSliderBtnEl) {
-        const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
-        const barWidth = alphaSliderRect.width;
-        const offsetLeft = Math.min(barWidth, Math.max(0, evnt.clientX - alphaSliderRect.x));
-        handleAlphaColor(offsetLeft);
+      };
+      const handleAlphaSliderMousedownEvent = (evnt) => {
+        evnt.preventDefault();
+        document.onmousemove = (evnt2) => {
+          evnt2.preventDefault();
+          handleAlphaBarEvent(evnt2);
+        };
+        document.onmouseup = (evnt2) => {
+          document.onmousemove = null;
+          document.onmouseup = null;
+          handleAlphaBarEvent(evnt2);
+        };
+      };
+      const handleInputRgbEvent = () => {
+        const { rValue, gValue, bValue, aValue } = reactData;
+        reactData.selectColor = (0, import_util.toValRgb)(rValue, gValue, bValue, aValue);
         updateModelColor();
-      }
-    };
-    const handleAlphaSliderMousedownEvent = (evnt) => {
-      evnt.preventDefault();
-      document.onmousemove = (evnt2) => {
-        evnt2.preventDefault();
-        handleAlphaBarEvent(evnt2);
       };
-      document.onmouseup = (evnt2) => {
-        document.onmousemove = null;
-        document.onmouseup = null;
-        handleAlphaBarEvent(evnt2);
+      const handleInputAlphaEvent = () => {
+        const { aValue } = reactData;
+        const alphaSliderEl = refAlphaSliderElem.value;
+        const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
+        if (alphaSliderEl && alphaSliderBtnEl) {
+          const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
+          const barWidth = alphaSliderRect.width;
+          const offsetLeft = barWidth * aValue;
+          handleAlphaColor(offsetLeft);
+        }
+      };
+      const handleQuickEvent = (evnt, item) => {
+        const value = item.value;
+        reactData.selectColor = value;
+        updateModelColor();
+      };
+      const handlePanelColor = (offsetLeft, offsetTop) => {
+        const colorActiveEl = refColorActiveElem.value;
+        if (colorActiveEl) {
+          colorActiveEl.style.top = (0, import_dom.toCssUnit)(offsetTop);
+          colorActiveEl.style.left = (0, import_dom.toCssUnit)(offsetLeft);
+        }
+      };
+      const handleEyeDropperEvent = () => {
+        if (WinEyeDropper) {
+          try {
+            const eyeDropper = new WinEyeDropper();
+            eyeDropper.open().then((rest) => {
+              if (rest && rest.sRGBHex) {
+                reactData.selectColor = rest.sRGBHex;
+                updateModelColor();
+              }
+            }).catch(() => {
+            });
+          } catch (e) {
+          }
+        }
       };
-    };
-    const handleInputRgbEvent = () => {
-      const { rValue, gValue, bValue, aValue } = reactData;
-      reactData.selectColor = (0, import_util.toValRgb)(rValue, gValue, bValue, aValue);
-      updateModelColor();
-    };
-    const handleInputAlphaEvent = () => {
-      const { aValue } = reactData;
-      const alphaSliderEl = refAlphaSliderElem.value;
-      const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
-      if (alphaSliderEl && alphaSliderBtnEl) {
-        const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
-        const barWidth = alphaSliderRect.width;
-        const offsetLeft = barWidth * aValue;
-        handleAlphaColor(offsetLeft);
-      }
-    };
-    const handleQuickEvent = (evnt, item) => {
-      const value = item.value;
-      reactData.selectColor = value;
-      updateModelColor();
-    };
-    const handlePanelColor = (offsetLeft, offsetTop) => {
-      const colorActiveEl = refColorActiveElem.value;
-      if (colorActiveEl) {
-        colorActiveEl.style.top = (0, import_dom.toCssUnit)(offsetTop);
-        colorActiveEl.style.left = (0, import_dom.toCssUnit)(offsetLeft);
-      }
-    };
-    const handleEyeDropperEvent = () => {
-      if (WinEyeDropper) {
-        try {
-          const eyeDropper = new WinEyeDropper();
-          eyeDropper.open().then((rest) => {
-            if (rest && rest.sRGBHex) {
-              reactData.selectColor = rest.sRGBHex;
+      const handleSelectColorByXY = (clientX, clientY) => {
+        const { showAlpha } = props;
+        const { panelColor, aValue } = reactData;
+        const colorPanelEl = refColorPanelElem.value;
+        const colorActiveEl = refColorActiveElem.value;
+        if (colorPanelEl && colorActiveEl) {
+          const { clientWidth, clientHeight } = colorPanelEl;
+          const colorPanelRect = colorPanelEl.getBoundingClientRect();
+          const offsetTop = Math.min(clientHeight, Math.max(0, clientY - colorPanelRect.y));
+          const offsetLeft = Math.min(clientWidth, Math.max(0, clientX - colorPanelRect.x));
+          const colorRest = (0, import_util.parseValColor)(panelColor);
+          if (colorRest) {
+            const hsvRest = colorRest.type === "hex" ? (0, import_util.hexToHsv)(colorRest.hex) : (0, import_util.rgbToHsv)(colorRest);
+            if (hsvRest) {
+              const ragRest = (0, import_util.hsvToRgb)(hsvRest.h, offsetLeft / clientWidth, 1 - offsetTop / clientHeight);
+              reactData.selectColor = (0, import_util.toValRgb)(ragRest.r, ragRest.g, ragRest.b, showAlpha ? aValue : null);
               updateModelColor();
             }
-          }).catch(() => {
-          });
-        } catch (e) {
-        }
-      }
-    };
-    const handleSelectColorByXY = (clientX, clientY) => {
-      const { showAlpha } = props;
-      const { panelColor, aValue } = reactData;
-      const colorPanelEl = refColorPanelElem.value;
-      const colorActiveEl = refColorActiveElem.value;
-      if (colorPanelEl && colorActiveEl) {
-        const { clientWidth, clientHeight } = colorPanelEl;
-        const colorPanelRect = colorPanelEl.getBoundingClientRect();
-        const offsetTop = Math.min(clientHeight, Math.max(0, clientY - colorPanelRect.y));
-        const offsetLeft = Math.min(clientWidth, Math.max(0, clientX - colorPanelRect.x));
-        const colorRest = (0, import_util.parseValColor)(panelColor);
-        if (colorRest) {
-          const hsvRest = colorRest.type === "hex" ? (0, import_util.hexToHsv)(colorRest.hex) : (0, import_util.rgbToHsv)(colorRest);
-          if (hsvRest) {
-            const ragRest = (0, import_util.hsvToRgb)(hsvRest.h, offsetLeft / clientWidth, 1 - offsetTop / clientHeight);
-            reactData.selectColor = (0, import_util.toValRgb)(ragRest.r, ragRest.g, ragRest.b, showAlpha ? aValue : null);
-            updateModelColor();
           }
+          handlePanelColor(offsetLeft, offsetTop);
         }
-        handlePanelColor(offsetLeft, offsetTop);
-      }
-    };
-    const handleSelectColorMousedownEvent = (evnt) => {
-      evnt.stopPropagation();
-      evnt.preventDefault();
-      handleSelectColorByXY(evnt.clientX, evnt.clientY);
-      document.onmousemove = (evnt2) => {
-        handleSelectColorByXY(evnt2.clientX, evnt2.clientY);
       };
-      document.onmouseup = () => {
-        document.onmousemove = null;
-        document.onmouseup = null;
+      const handleSelectColorMousedownEvent = (evnt) => {
+        evnt.stopPropagation();
+        evnt.preventDefault();
+        handleSelectColorByXY(evnt.clientX, evnt.clientY);
+        document.onmousemove = (evnt2) => {
+          handleSelectColorByXY(evnt2.clientX, evnt2.clientY);
+        };
+        document.onmouseup = () => {
+          document.onmousemove = null;
+          document.onmouseup = null;
+        };
       };
-    };
-    const handleCopyColorEvent = () => {
-      const { selectColor } = reactData;
-      if (selectColor) {
-        if (import_core.VxeUI.clipboard.copy(selectColor)) {
-          if (import_core.VxeUI.modal) {
-            import_core.VxeUI.modal.message({
-              content: getI18n("vxe.colorPicker.copySuccess", [selectColor]),
-              status: "success"
-            });
+      const handleCopyColorEvent = () => {
+        const { selectColor } = reactData;
+        if (selectColor) {
+          if (import_core.VxeUI.clipboard.copy(selectColor)) {
+            if (import_core.VxeUI.modal) {
+              import_core.VxeUI.modal.message({
+                content: getI18n("vxe.colorPicker.copySuccess", [selectColor]),
+                status: "success"
+              });
+            }
           }
         }
-      }
-    };
-    const handleGlobalMousedownEvent = (evnt) => {
-      const { visiblePanel } = reactData;
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled) {
-        const el = refElem.value;
-        const panelElem = refOptionPanel.value;
-        reactData.isActivated = (0, import_dom.getEventTargetNode)(evnt, el).flag || (0, import_dom.getEventTargetNode)(evnt, panelElem).flag;
-        if (visiblePanel && !reactData.isActivated) {
+      };
+      const handleGlobalMousedownEvent = (evnt) => {
+        const { visiblePanel } = reactData;
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled) {
+          const el = refElem.value;
+          const panelElem = refOptionPanel.value;
+          reactData.isActivated = (0, import_dom.getEventTargetNode)(evnt, el).flag || (0, import_dom.getEventTargetNode)(evnt, panelElem).flag;
+          if (visiblePanel && !reactData.isActivated) {
+            hideOptionPanel();
+          }
+        }
+      };
+      const handleGlobalBlurEvent = () => {
+        const { visiblePanel, isActivated } = reactData;
+        if (visiblePanel) {
           hideOptionPanel();
         }
-      }
-    };
-    const handleGlobalBlurEvent = () => {
-      const { visiblePanel, isActivated } = reactData;
-      if (visiblePanel) {
-        hideOptionPanel();
-      }
-      if (isActivated) {
-        reactData.isActivated = false;
-      }
-      if (visiblePanel || isActivated) {
-        const targetElem = refInputTarget.value;
-        if (targetElem) {
-          targetElem.blur();
+        if (isActivated) {
+          reactData.isActivated = false;
+        }
+        if (visiblePanel || isActivated) {
+          const targetElem = refInputTarget.value;
+          if (targetElem) {
+            targetElem.blur();
+          }
+        }
+      };
+      const handleGlobalResizeEvent = () => {
+        const { visiblePanel } = reactData;
+        if (visiblePanel) {
+          updatePlacement();
+        }
+      };
+      const handleGlobalScrollEvent = () => {
+        const { visiblePanel } = reactData;
+        if (visiblePanel) {
+          updatePlacement();
+        }
+      };
+      const dispatchEvent = (type, params, evnt) => {
+        emit(type, createEvent(evnt, { $colorPicker: $xeColorPicker }, params));
+      };
+      const colorPickerMethods = {
+        dispatchEvent
+      };
+      const colorPickerPrivateMethods = {};
+      Object.assign($xeColorPicker, colorPickerMethods, colorPickerPrivateMethods);
+      const renderColorWrapper = () => {
+        const { showColorExtractor } = props;
+        const { panelColor } = reactData;
+        if (showColorExtractor) {
+          return (0, import_vue.h)(
+            "div",
+            {
+              ref: refColorPanelElem,
+              class: "vxe-color-picker--color-wrapper",
+              onMousedown: handleSelectColorMousedownEvent
+            },
+            [
+              (0, import_vue.h)("div", {
+                class: "vxe-color-picker--color-bg",
+                style: {
+                  backgroundColor: panelColor
+                }
+              }),
+              (0, import_vue.h)("div", {
+                class: "vxe-color-picker--white-bg"
+              }),
+              (0, import_vue.h)("div", {
+                class: "vxe-color-picker--black-bg"
+              }),
+              (0, import_vue.h)("div", {
+                ref: refColorActiveElem,
+                class: "vxe-color-picker--color-active"
+              })
+            ]
+          );
         }
-      }
-    };
-    const handleGlobalResizeEvent = () => {
-      const { visiblePanel } = reactData;
-      if (visiblePanel) {
-        updatePlacement();
-      }
-    };
-    const handleGlobalScrollEvent = () => {
-      const { visiblePanel } = reactData;
-      if (visiblePanel) {
-        updatePlacement();
-      }
-    };
-    const dispatchEvent = (type, params, evnt) => {
-      emit(type, createEvent(evnt, { $colorPicker: $xeColorPicker }, params));
-    };
-    const colorPickerMethods = {
-      dispatchEvent
-    };
-    const colorPickerPrivateMethods = {};
-    Object.assign($xeColorPicker, colorPickerMethods, colorPickerPrivateMethods);
-    const renderColorWrapper = () => {
-      const { showColorExtractor } = props;
-      const { panelColor } = reactData;
-      if (showColorExtractor) {
+        return renderEmptyElement($xeColorPicker);
+      };
+      const renderColorBar = () => {
+        const { showAlpha, clickToCopy, showEyeDropper } = props;
+        const { selectTyle, showTypePopup, hexValue, rValue, gValue, bValue, aValue, selectColor, panelColor } = reactData;
+        const isRgb = computeIsRgb.value;
+        const selectTypeItem = computeSelectTypeItem.value;
         return (0, import_vue.h)(
           "div",
           {
-            ref: refColorPanelElem,
-            class: "vxe-color-picker--color-wrapper",
-            onMousedown: handleSelectColorMousedownEvent
+            class: "vxe-color-picker--bar-wrapper"
           },
           [
-            (0, import_vue.h)("div", {
-              class: "vxe-color-picker--color-bg",
-              style: {
-                backgroundColor: panelColor
-              }
-            }),
-            (0, import_vue.h)("div", {
-              class: "vxe-color-picker--white-bg"
-            }),
-            (0, import_vue.h)("div", {
-              class: "vxe-color-picker--black-bg"
-            }),
-            (0, import_vue.h)("div", {
-              ref: refColorActiveElem,
-              class: "vxe-color-picker--color-active"
-            })
+            (0, import_vue.h)(
+              "div",
+              {
+                class: "vxe-color-picker--slider-wrapper"
+              },
+              [
+                showEyeDropper && WinEyeDropper ? (0, import_vue.h)(
+                  "div",
+                  {
+                    class: "vxe-color-picker--color-dropper"
+                  },
+                  [
+                    (0, import_vue.h)(
+                      "span",
+                      {
+                        class: "vxe-color-picker--color-dropper-btn",
+                        onClick: handleEyeDropperEvent
+                      },
+                      [
+                        (0, import_vue.h)("i", {
+                          class: getIcon().COLOR_PICKER_EYE_DROPPER
+                        })
+                      ]
+                    )
+                  ]
+                ) : renderEmptyElement($xeColorPicker),
+                (0, import_vue.h)(
+                  "div",
+                  {
+                    class: "vxe-color-picker--slider-preview"
+                  },
+                  [
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-color-picker--preview-btn"
+                      },
+                      [
+                        (0, import_vue.h)(
+                          "div",
+                          {
+                            class: "vxe-color-picker--preview-color",
+                            style: {
+                              backgroundColor: selectColor
+                            }
+                          },
+                          clickToCopy ? [
+                            (0, import_vue.h)(
+                              "span",
+                              {
+                                class: "vxe-color-picker--preview-copy-btn",
+                                onClick: handleCopyColorEvent
+                              },
+                              [
+                                (0, import_vue.h)("i", {
+                                  class: getIcon().COLOR_PICKER_COLOR_COPY
+                                })
+                              ]
+                            )
+                          ] : []
+                        )
+                      ]
+                    )
+                  ]
+                ),
+                (0, import_vue.h)(
+                  "div",
+                  {
+                    class: "vxe-color-picker--slider-handle"
+                  },
+                  [
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        ref: refHueSliderElem,
+                        class: "vxe-color-picker--bar-hue-slider",
+                        onClick: handleHueBarEvent
+                      },
+                      [
+                        (0, import_vue.h)("div", {
+                          ref: refHueSliderBtnElem,
+                          class: "vxe-color-picker--bar-hue-btn",
+                          onMousedown: handleHueSliderMousedownEvent
+                        })
+                      ]
+                    ),
+                    showAlpha ? (0, import_vue.h)(
+                      "div",
+                      {
+                        ref: refAlphaSliderElem,
+                        class: "vxe-color-picker--bar-alpha-slider",
+                        onClick: handleAlphaBarEvent
+                      },
+                      [
+                        (0, import_vue.h)("div", {
+                          class: "vxe-color-picker--bar-alpha-bg",
+                          style: {
+                            background: `linear-gradient(to right, rgba(0, 0, 0, 0), ${panelColor})`
+                          }
+                        }),
+                        (0, import_vue.h)("div", {
+                          ref: refAlphaSliderBtnElem,
+                          class: "vxe-color-picker--bar-alpha-btn",
+                          onMousedown: handleAlphaSliderMousedownEvent
+                        })
+                      ]
+                    ) : renderEmptyElement($xeColorPicker)
+                  ]
+                )
+              ]
+            ),
+            (0, import_vue.h)(
+              "div",
+              {
+                class: "vxe-color-picker--custom-wrapper"
+              },
+              [
+                (0, import_vue.h)(
+                  "div",
+                  {
+                    class: "vxe-color-picker--type-switch"
+                  },
+                  [
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-color-picker--type-label",
+                        onClick: toggleTypeVisibleEvent
+                      },
+                      [
+                        (0, import_vue.h)("span", `${selectTypeItem ? selectTypeItem.label : selectTyle}`),
+                        (0, import_vue.h)(
+                          "span",
+                          {
+                            class: "vxe-color-picker--type-icon"
+                          },
+                          [
+                            (0, import_vue.h)("i", {
+                              class: showTypePopup ? getIcon().COLOR_PICKER_TPTY_OPEN : getIcon().COLOR_PICKER_TPTY_CLOSE
+                            })
+                          ]
+                        )
+                      ]
+                    ),
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: [
+                          "vxe-color-picker--type-popup",
+                          {
+                            "is--visible": showTypePopup
+                          }
+                        ]
+                      },
+                      typeList.map((item) => {
+                        return (0, import_vue.h)(
+                          "div",
+                          {
+                            class: "vxe-color-picker--type-item",
+                            onClick(evnt) {
+                              evnt.stopPropagation();
+                              handleChangeType(item.value);
+                            }
+                          },
+                          item.label
+                        );
+                      })
+                    )
+                  ]
+                ),
+                (0, import_vue.h)(
+                  "div",
+                  {
+                    class: `vxe-color-picker--${selectTyle}-wrapper`
+                  },
+                  isRgb ? [
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-color-picker--input-wrapper"
+                      },
+                      [
+                        (0, import_vue.h)(import_number_input.default, {
+                          type: "integer",
+                          size: "mini",
+                          align: "center",
+                          min: 0,
+                          max: 255,
+                          maxLength: 3,
+                          placeholder: "",
+                          modelValue: rValue,
+                          controlConfig: {
+                            showButton: false
+                          },
+                          "onUpdate:modelValue"(val) {
+                            reactData.rValue = val;
+                          },
+                          onChange: handleInputRgbEvent
+                        }),
+                        (0, import_vue.h)(import_number_input.default, {
+                          type: "integer",
+                          size: "mini",
+                          align: "center",
+                          min: 0,
+                          max: 255,
+                          maxLength: 3,
+                          placeholder: "",
+                          modelValue: gValue,
+                          controlConfig: {
+                            showButton: false
+                          },
+                          "onUpdate:modelValue"(val) {
+                            reactData.gValue = val;
+                          },
+                          onChange: handleInputRgbEvent
+                        }),
+                        (0, import_vue.h)(import_number_input.default, {
+                          type: "integer",
+                          size: "mini",
+                          align: "center",
+                          min: 0,
+                          max: 255,
+                          maxLength: 3,
+                          placeholder: "",
+                          modelValue: bValue,
+                          controlConfig: {
+                            showButton: false
+                          },
+                          "onUpdate:modelValue"(val) {
+                            reactData.bValue = val;
+                          },
+                          onChange: handleInputRgbEvent
+                        }),
+                        (0, import_vue.h)(import_number_input.default, {
+                          type: "number",
+                          size: "mini",
+                          align: "center",
+                          min: 0,
+                          max: 1,
+                          step: 0.01,
+                          maxLength: 4,
+                          placeholder: "",
+                          modelValue: aValue,
+                          controlConfig: {
+                            showButton: false
+                          },
+                          "onUpdate:modelValue"(val) {
+                            reactData.aValue = val;
+                          },
+                          onChange: handleInputAlphaEvent
+                        })
+                      ]
+                    ),
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-color-picker--input-title"
+                      },
+                      [(0, import_vue.h)("span", "R"), (0, import_vue.h)("span", "G"), (0, import_vue.h)("span", "B"), (0, import_vue.h)("span", "A")]
+                    )
+                  ] : [
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-color-picker--input-wrapper"
+                      },
+                      [
+                        (0, import_vue.h)(import_input.default, {
+                          type: "text",
+                          size: "mini",
+                          align: "center",
+                          maxLength: 9,
+                          placeholder: "",
+                          modelValue: hexValue,
+                          "onUpdate:modelValue"(val) {
+                            reactData.hexValue = val;
+                          },
+                          onChange() {
+                            const colorRest = (0, import_util.parseValColor)(reactData.hexValue);
+                            if (colorRest) {
+                              if (colorRest.value) {
+                                reactData.selectColor = colorRest.value;
+                                updateModelColor();
+                              }
+                            }
+                          }
+                        })
+                      ]
+                    ),
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-color-picker--input-title"
+                      },
+                      getI18n("vxe.colorPicker.hex")
+                    )
+                  ]
+                )
+              ]
+            )
           ]
         );
-      }
-      return renderEmptyElement($xeColorPicker);
-    };
-    const renderColorBar = () => {
-      const { showAlpha, clickToCopy, showEyeDropper } = props;
-      const { selectTyle, showTypePopup, hexValue, rValue, gValue, bValue, aValue, selectColor, panelColor } = reactData;
-      const isRgb = computeIsRgb.value;
-      const selectTypeItem = computeSelectTypeItem.value;
-      return (0, import_vue.h)(
-        "div",
-        {
-          class: "vxe-color-picker--bar-wrapper"
-        },
-        [
-          (0, import_vue.h)(
+      };
+      const renderQuickWrapper = () => {
+        const { showQuick } = props;
+        const colorList = computeColorList.value;
+        if (showQuick && colorList.length) {
+          return (0, import_vue.h)(
             "div",
             {
-              class: "vxe-color-picker--slider-wrapper"
+              class: "vxe-color-picker--quick-wrapper"
             },
-            [
-              showEyeDropper && WinEyeDropper ? (0, import_vue.h)(
-                "div",
-                {
-                  class: "vxe-color-picker--color-dropper"
-                },
-                [
-                  (0, import_vue.h)(
-                    "span",
-                    {
-                      class: "vxe-color-picker--color-dropper-btn",
-                      onClick: handleEyeDropperEvent
-                    },
-                    [
-                      (0, import_vue.h)("i", {
-                        class: getIcon().COLOR_PICKER_EYE_DROPPER
-                      })
-                    ]
-                  )
-                ]
-              ) : renderEmptyElement($xeColorPicker),
-              (0, import_vue.h)(
-                "div",
-                {
-                  class: "vxe-color-picker--slider-preview"
-                },
-                [
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-color-picker--preview-btn"
-                    },
-                    [
-                      (0, import_vue.h)(
-                        "div",
-                        {
-                          class: "vxe-color-picker--preview-color",
-                          style: {
-                            backgroundColor: selectColor
-                          }
-                        },
-                        clickToCopy ? [
-                          (0, import_vue.h)(
-                            "span",
-                            {
-                              class: "vxe-color-picker--preview-copy-btn",
-                              onClick: handleCopyColorEvent
-                            },
-                            [
-                              (0, import_vue.h)("i", {
-                                class: getIcon().COLOR_PICKER_COLOR_COPY
-                              })
-                            ]
-                          )
-                        ] : []
-                      )
-                    ]
-                  )
-                ]
-              ),
-              (0, import_vue.h)(
-                "div",
-                {
-                  class: "vxe-color-picker--slider-handle"
+            colorList.map((item, i) => {
+              return (0, import_vue.h)("div", {
+                key: i,
+                class: "vxe-color-picker--quick-item",
+                title: item.label || "",
+                style: {
+                  backgroundColor: item.value
                 },
-                [
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      ref: refHueSliderElem,
-                      class: "vxe-color-picker--bar-hue-slider",
-                      onClick: handleHueBarEvent
-                    },
-                    [
-                      (0, import_vue.h)("div", {
-                        ref: refHueSliderBtnElem,
-                        class: "vxe-color-picker--bar-hue-btn",
-                        onMousedown: handleHueSliderMousedownEvent
-                      })
-                    ]
-                  ),
-                  showAlpha ? (0, import_vue.h)(
-                    "div",
-                    {
-                      ref: refAlphaSliderElem,
-                      class: "vxe-color-picker--bar-alpha-slider",
-                      onClick: handleAlphaBarEvent
-                    },
-                    [
-                      (0, import_vue.h)("div", {
-                        class: "vxe-color-picker--bar-alpha-bg",
-                        style: {
-                          background: `linear-gradient(to right, rgba(0, 0, 0, 0), ${panelColor})`
-                        }
-                      }),
-                      (0, import_vue.h)("div", {
-                        ref: refAlphaSliderBtnElem,
-                        class: "vxe-color-picker--bar-alpha-btn",
-                        onMousedown: handleAlphaSliderMousedownEvent
-                      })
-                    ]
-                  ) : renderEmptyElement($xeColorPicker)
-                ]
-              )
-            ]
-          ),
-          (0, import_vue.h)(
+                onClick(evnt) {
+                  handleQuickEvent(evnt, item);
+                }
+              });
+            })
+          );
+        }
+        return renderEmptyElement($xeColorPicker);
+      };
+      const renderVN = () => {
+        const { className, popupClassName, clearable, modelValue } = props;
+        const { initialized, isActivated, isAniVisible, visiblePanel } = reactData;
+        const vSize = computeSize.value;
+        const isDisabled = computeIsDisabled.value;
+        const btnTransfer = computeBtnTransfer.value;
+        const formReadonly = computeFormReadonly.value;
+        if (formReadonly) {
+          return (0, import_vue.h)(
             "div",
             {
-              class: "vxe-color-picker--custom-wrapper"
+              ref: refElem,
+              class: [
+                "vxe-color-picker--readonly",
+                className,
+                {
+                  [`size--${vSize}`]: vSize
+                }
+              ]
             },
             [
-              (0, import_vue.h)(
-                "div",
-                {
-                  class: "vxe-color-picker--type-switch"
-                },
-                [
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-color-picker--type-label",
-                      onClick: toggleTypeVisibleEvent
-                    },
-                    [
-                      (0, import_vue.h)("span", `${selectTypeItem ? selectTypeItem.label : selectTyle}`),
-                      (0, import_vue.h)(
-                        "span",
-                        {
-                          class: "vxe-color-picker--type-icon"
-                        },
-                        [
-                          (0, import_vue.h)("i", {
-                            class: showTypePopup ? getIcon().COLOR_PICKER_TPTY_OPEN : getIcon().COLOR_PICKER_TPTY_CLOSE
-                          })
-                        ]
-                      )
-                    ]
-                  ),
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: [
-                        "vxe-color-picker--type-popup",
-                        {
-                          "is--visible": showTypePopup
-                        }
-                      ]
-                    },
-                    typeList.map((item) => {
-                      return (0, import_vue.h)(
-                        "div",
-                        {
-                          class: "vxe-color-picker--type-item",
-                          onClick(evnt) {
-                            evnt.stopPropagation();
-                            handleChangeType(item.value);
-                          }
-                        },
-                        item.label
-                      );
-                    })
-                  )
-                ]
-              ),
-              (0, import_vue.h)(
-                "div",
-                {
-                  class: `vxe-color-picker--${selectTyle}-wrapper`
-                },
-                isRgb ? [
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-color-picker--input-wrapper"
-                    },
-                    [
-                      (0, import_vue.h)(import_number_input.default, {
-                        type: "integer",
-                        size: "mini",
-                        align: "center",
-                        min: 0,
-                        max: 255,
-                        maxLength: 3,
-                        placeholder: "",
-                        modelValue: rValue,
-                        controlConfig: {
-                          showButton: false
-                        },
-                        "onUpdate:modelValue"(val) {
-                          reactData.rValue = val;
-                        },
-                        onChange: handleInputRgbEvent
-                      }),
-                      (0, import_vue.h)(import_number_input.default, {
-                        type: "integer",
-                        size: "mini",
-                        align: "center",
-                        min: 0,
-                        max: 255,
-                        maxLength: 3,
-                        placeholder: "",
-                        modelValue: gValue,
-                        controlConfig: {
-                          showButton: false
-                        },
-                        "onUpdate:modelValue"(val) {
-                          reactData.gValue = val;
-                        },
-                        onChange: handleInputRgbEvent
-                      }),
-                      (0, import_vue.h)(import_number_input.default, {
-                        type: "integer",
-                        size: "mini",
-                        align: "center",
-                        min: 0,
-                        max: 255,
-                        maxLength: 3,
-                        placeholder: "",
-                        modelValue: bValue,
-                        controlConfig: {
-                          showButton: false
-                        },
-                        "onUpdate:modelValue"(val) {
-                          reactData.bValue = val;
-                        },
-                        onChange: handleInputRgbEvent
-                      }),
-                      (0, import_vue.h)(import_number_input.default, {
-                        type: "number",
-                        size: "mini",
-                        align: "center",
-                        min: 0,
-                        max: 1,
-                        step: 0.01,
-                        maxLength: 4,
-                        placeholder: "",
-                        modelValue: aValue,
-                        controlConfig: {
-                          showButton: false
-                        },
-                        "onUpdate:modelValue"(val) {
-                          reactData.aValue = val;
-                        },
-                        onChange: handleInputAlphaEvent
-                      })
-                    ]
-                  ),
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-color-picker--input-title"
-                    },
-                    [(0, import_vue.h)("span", "R"), (0, import_vue.h)("span", "G"), (0, import_vue.h)("span", "B"), (0, import_vue.h)("span", "A")]
-                  )
-                ] : [
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-color-picker--input-wrapper"
-                    },
-                    [
-                      (0, import_vue.h)(import_input.default, {
-                        type: "text",
-                        size: "mini",
-                        align: "center",
-                        maxLength: 9,
-                        placeholder: "",
-                        modelValue: hexValue,
-                        "onUpdate:modelValue"(val) {
-                          reactData.hexValue = val;
-                        },
-                        onChange() {
-                          const colorRest = (0, import_util.parseValColor)(reactData.hexValue);
-                          if (colorRest) {
-                            if (colorRest.value) {
-                              reactData.selectColor = colorRest.value;
-                              updateModelColor();
-                            }
-                          }
-                        }
-                      })
-                    ]
-                  ),
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-color-picker--input-title"
-                    },
-                    getI18n("vxe.colorPicker.hex")
-                  )
-                ]
-              )
+              (0, import_vue.h)("div", {
+                class: [
+                  "vxe-color-picker--readonly-color",
+                  {
+                    "is--empty": !modelValue
+                  }
+                ],
+                style: modelValue ? {
+                  backgroundColor: modelValue
+                } : void 0
+              })
             ]
-          )
-        ]
-      );
-    };
-    const renderQuickWrapper = () => {
-      const { showQuick } = props;
-      const colorList = computeColorList.value;
-      if (showQuick && colorList.length) {
-        return (0, import_vue.h)(
-          "div",
-          {
-            class: "vxe-color-picker--quick-wrapper"
-          },
-          colorList.map((item, i) => {
-            return (0, import_vue.h)("div", {
-              key: i,
-              class: "vxe-color-picker--quick-item",
-              title: item.label || "",
-              style: {
-                backgroundColor: item.value
-              },
-              onClick(evnt) {
-                handleQuickEvent(evnt, item);
-              }
-            });
-          })
-        );
-      }
-      return renderEmptyElement($xeColorPicker);
-    };
-    const renderVN = () => {
-      const { className, popupClassName, clearable, modelValue } = props;
-      const { initialized, isActivated, isAniVisible, visiblePanel } = reactData;
-      const vSize = computeSize.value;
-      const isDisabled = computeIsDisabled.value;
-      const btnTransfer = computeBtnTransfer.value;
-      const formReadonly = computeFormReadonly.value;
-      if (formReadonly) {
+          );
+        }
+        const currStyle = computeCurrStyle.value;
+        const popupOpts = computePopupOpts.value;
+        const { appendTo } = popupOpts;
         return (0, import_vue.h)(
           "div",
           {
             ref: refElem,
             class: [
-              "vxe-color-picker--readonly",
-              className,
+              "vxe-color-picker",
+              className ? import_xe_utils.default.isFunction(className) ? className({ $colorPicker: $xeColorPicker }) : className : "",
               {
-                [`size--${vSize}`]: vSize
+                [`size--${vSize}`]: vSize,
+                "is--selected": !!modelValue,
+                "is--visible": visiblePanel,
+                "is--disabled": isDisabled,
+                "is--active": isActivated
               }
-            ]
+            ],
+            style: currStyle
           },
           [
-            (0, import_vue.h)("div", {
-              class: [
-                "vxe-color-picker--readonly-color",
-                {
-                  "is--empty": !modelValue
-                }
-              ],
-              style: modelValue ? {
-                backgroundColor: modelValue
-              } : void 0
-            })
+            (0, import_vue.h)("input", {
+              ref: refInputTarget,
+              class: "vxe-color-picker--input",
+              onFocus: focusEvent,
+              onBlur: blurEvent
+            }),
+            (0, import_vue.h)(
+              "div",
+              {
+                class: "vxe-color-picker--inner",
+                onClick: clickEvent
+              },
+              [
+                (0, import_vue.h)("div", {
+                  class: "vxe-color-picker--inner-color",
+                  style: {
+                    backgroundColor: modelValue
+                  }
+                })
+              ]
+            ),
+            (0, import_vue.h)(
+              import_vue.Teleport,
+              {
+                to: (0, import_dom.getPopupContainer)(appendTo),
+                disabled: btnTransfer ? !initialized : true
+              },
+              [
+                (0, import_vue.h)(
+                  "div",
+                  {
+                    ref: refOptionPanel,
+                    class: [
+                      "vxe-table--ignore-clear vxe-color-picker--panel",
+                      popupClassName ? import_xe_utils.default.isFunction(popupClassName) ? popupClassName({ $colorPicker: $xeColorPicker }) : popupClassName : "",
+                      {
+                        [`size--${vSize}`]: vSize,
+                        "is--transfer": btnTransfer,
+                        "ani--leave": isAniVisible,
+                        "ani--enter": visiblePanel
+                      }
+                    ],
+                    placement: reactData.panelPlacement,
+                    style: reactData.panelStyle
+                  },
+                  [
+                    initialized && (visiblePanel || isAniVisible) ? (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-color-picker--panel-wrapper",
+                        onClick: handlePanelClickEvent
+                      },
+                      [
+                        renderColorWrapper(),
+                        renderColorBar(),
+                        renderQuickWrapper(),
+                        (0, import_vue.h)(
+                          "div",
+                          {
+                            class: "vxe-color-picker--footer-wrapper"
+                          },
+                          [
+                            clearable ? (0, import_vue.h)(import_button.default, {
+                              content: getI18n("vxe.colorPicker.clear"),
+                              size: "mini",
+                              onClick: clearEvent
+                            }) : renderEmptyElement($xeColorPicker),
+                            (0, import_vue.h)(import_button.default, {
+                              content: getI18n("vxe.colorPicker.confirm"),
+                              size: "mini",
+                              status: "primary",
+                              onClick: confirmEvent
+                            })
+                          ]
+                        )
+                      ]
+                    ) : renderEmptyElement($xeColorPicker)
+                  ]
+                )
+              ]
+            )
           ]
         );
-      }
-      const currStyle = computeCurrStyle.value;
-      const popupOpts = computePopupOpts.value;
-      const { appendTo } = popupOpts;
-      return (0, import_vue.h)(
-        "div",
-        {
-          ref: refElem,
-          class: [
-            "vxe-color-picker",
-            className ? import_xe_utils.default.isFunction(className) ? className({ $colorPicker: $xeColorPicker }) : className : "",
-            {
-              [`size--${vSize}`]: vSize,
-              "is--selected": !!modelValue,
-              "is--visible": visiblePanel,
-              "is--disabled": isDisabled,
-              "is--active": isActivated
-            }
-          ],
-          style: currStyle
-        },
-        [
-          (0, import_vue.h)("input", {
-            ref: refInputTarget,
-            class: "vxe-color-picker--input",
-            onFocus: focusEvent,
-            onBlur: blurEvent
-          }),
-          (0, import_vue.h)(
-            "div",
-            {
-              class: "vxe-color-picker--inner",
-              onClick: clickEvent
-            },
-            [
-              (0, import_vue.h)("div", {
-                class: "vxe-color-picker--inner-color",
-                style: {
-                  backgroundColor: modelValue
-                }
-              })
-            ]
-          ),
-          (0, import_vue.h)(
-            import_vue.Teleport,
-            {
-              to: (0, import_dom.getPopupContainer)(appendTo),
-              disabled: btnTransfer ? !initialized : true
-            },
-            [
-              (0, import_vue.h)(
-                "div",
-                {
-                  ref: refOptionPanel,
-                  class: [
-                    "vxe-table--ignore-clear vxe-color-picker--panel",
-                    popupClassName ? import_xe_utils.default.isFunction(popupClassName) ? popupClassName({ $colorPicker: $xeColorPicker }) : popupClassName : "",
-                    {
-                      [`size--${vSize}`]: vSize,
-                      "is--transfer": btnTransfer,
-                      "ani--leave": isAniVisible,
-                      "ani--enter": visiblePanel
-                    }
-                  ],
-                  placement: reactData.panelPlacement,
-                  style: reactData.panelStyle
-                },
-                [
-                  initialized && (visiblePanel || isAniVisible) ? (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-color-picker--panel-wrapper",
-                      onClick: handlePanelClickEvent
-                    },
-                    [
-                      renderColorWrapper(),
-                      renderColorBar(),
-                      renderQuickWrapper(),
-                      (0, import_vue.h)(
-                        "div",
-                        {
-                          class: "vxe-color-picker--footer-wrapper"
-                        },
-                        [
-                          clearable ? (0, import_vue.h)(import_button.default, {
-                            content: getI18n("vxe.colorPicker.clear"),
-                            size: "mini",
-                            onClick: clearEvent
-                          }) : renderEmptyElement($xeColorPicker),
-                          (0, import_vue.h)(import_button.default, {
-                            content: getI18n("vxe.colorPicker.confirm"),
-                            size: "mini",
-                            status: "primary",
-                            onClick: confirmEvent
-                          })
-                        ]
-                      )
-                    ]
-                  ) : renderEmptyElement($xeColorPicker)
-                ]
-              )
-            ]
-          )
-        ]
+      };
+      (0, import_vue.watch)(
+        () => props.modelValue,
+        () => {
+          updateMode();
+        }
       );
-    };
-    (0, import_vue.watch)(
-      () => props.modelValue,
-      () => {
-        updateMode();
-      }
-    );
-    (0, import_vue.watch)(
-      () => props.type,
-      () => {
-        updateType();
-      }
-    );
-    (0, import_vue.onMounted)(() => {
-      globalEvents.on($xeColorPicker, "mousedown", handleGlobalMousedownEvent);
-      globalEvents.on($xeColorPicker, "blur", handleGlobalBlurEvent);
-      globalEvents.on($xeColorPicker, "resize", handleGlobalResizeEvent);
-      globalEvents.on($xeColorPicker, "scroll", handleGlobalScrollEvent);
-    });
-    (0, import_vue.onUnmounted)(() => {
-      globalEvents.off($xeColorPicker, "mousedown");
-      globalEvents.off($xeColorPicker, "blur");
-      globalEvents.off($xeColorPicker, "resize");
-      globalEvents.off($xeColorPicker, "scroll");
-    });
-    updateType();
-    (0, import_vue.provide)("$xeColorPicker", $xeColorPicker);
-    $xeColorPicker.renderVN = renderVN;
-    return $xeColorPicker;
-  },
-  render() {
-    return this.renderVN();
-  }
-});
+      (0, import_vue.watch)(
+        () => props.type,
+        () => {
+          updateType();
+        }
+      );
+      (0, import_vue.onMounted)(() => {
+        globalEvents.on($xeColorPicker, "mousedown", handleGlobalMousedownEvent);
+        globalEvents.on($xeColorPicker, "blur", handleGlobalBlurEvent);
+        globalEvents.on($xeColorPicker, "resize", handleGlobalResizeEvent);
+        globalEvents.on($xeColorPicker, "scroll", handleGlobalScrollEvent);
+      });
+      (0, import_vue.onUnmounted)(() => {
+        globalEvents.off($xeColorPicker, "mousedown");
+        globalEvents.off($xeColorPicker, "blur");
+        globalEvents.off($xeColorPicker, "resize");
+        globalEvents.off($xeColorPicker, "scroll");
+      });
+      updateType();
+      (0, import_vue.provide)("$xeColorPicker", $xeColorPicker);
+      $xeColorPicker.renderVN = renderVN;
+      return $xeColorPicker;
+    },
+    render() {
+      return this.renderVN();
+    }
+  })
+);