@zcrkey/js-utils 0.0.11 → 0.0.15

package/dist/esm/color.d.ts

@@ -1,195 +0,0 @@
-export default class CrColorUtil {
-    /**
-     * hex 转 rgb 数组 [r,g,b]  r/g/b范围 0-255
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     */
-    static hexToRgb(hex: string): number[];
-    /**
-     * rgb 转 hex 标准格式
-     * @param r 0-255
-     * @param g 0-255
-     * @param b 0-255
-     */
-    static rgbToHex(r: number, g: number, b: number): string;
-    /**
-     * 将 rgb 格式转为 hsv 格式
-     * input: r,g,b in [0,1], out: h in [0,360) and s,v in [0,1]
-     * @param r 0-1
-     * @param g 0-1
-     * @param b 0-1
-     */
-    static rgb2hsv(r: number, g: number, b: number): number[];
-    /**
-     * 将 hsv 格式转为 rgb 格式
-     * input: h in [0,360] and s,v in [0,1] - output: r,g,b in [0,1]
-     * @param h 0-360
-     * @param s 0-1
-     * @param v 0-1
-     */
-    static hsv2rgb(h: number, s: number, v: number): number[];
-    /**
-     * hex 转 rgba 格式字符串 可直接用于css
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param alpha 透明度 0-1  默认1(完全不透明)
-     * @returns 例: rgba(255,255,255,0.5)
-     */
-    static hexToRgba(hex: string, alpha?: number): string;
-    /**
-     * 给hex颜色添加透明度，返回 8位带透明通道的hex格式 #RRGGBBAA (CSS常用)
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param alpha 透明度 0-1  默认1(完全不透明)
-     * @returns 例: #ffffff80  #ff000033
-     */
-    static hexAddAlpha(hex: string, alpha?: number): string;
-    /**
-     * rgba 转 hex 格式
-     * @param r 0-255
-     * @param g 0-255
-     * @param b 0-255
-     */
-    static rgbaToHex(r: number, g: number, b: number): string;
-    /**
-     * hsv 转 hex 十六进制颜色
-     * @param h 色相 0-360
-     * @param s 饱和度 0-1
-     * @param v 明度 0-1
-     */
-    static hsvToHex(h: number, s: number, v: number): string;
-    /**
-     * hex 转 hsv 格式
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @returns [h:0-360, s:0-1, v:0-1]
-     */
-    static hexToHsv(hex: string): number[];
-    /**
-     * 颜色加深处理 - 基于hex颜色
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param level 加深程度 0-1  0不变 1最深(接近黑色)
-     */
-    static darkenColor(hex: string, level: number): string;
-    /**
-     * 颜色减淡/提亮处理 - 基于hex颜色
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param level 减淡程度 0-1  0不变 1最亮(接近白色)
-     */
-    static lightenColor(hex: string, level: number): string;
-    /**
-     * 解析8位带透明的hex #RRGGBBAA 为 普通hex + 透明度
-     * @param hex8 8位带透明的十六进制颜色 例：#ffffff80
-     * @returns { hex: '#ffffff', alpha: 0.5 }
-     */
-    static parseHex8(hex8: string): {
-        hex: string;
-        alpha: number;
-    };
-    /**
-     * rgb 数组 转 rgb/rgba 字符串
-     * @param rgb [r,g,b] 0-255
-     * @param alpha 透明度0-1 传则返回rgba，不传返回rgb
-     */
-    static rgbToStr(rgb: number[], alpha?: number): string;
-    /**
-     * Hex颜色字符串 转 十进制数值（6位纯颜色值，无透明通道，专用于颜色运算）
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @returns 十进制数值 例：#ff0000 → 16711680，非法入参返回 0
-     */
-    static hexToNumber(hex: string): number;
-    /**
-     * 十进制数值 转回 Hex颜色字符串（无透明通道 标准6位）
-     * @param num 十进制数值 例：16711680 → #ff0000
-     * @returns 标准6位十六进制颜色 #RRGGBB 格式
-     */
-    static numberToHex(num: number): string;
-    /**
-     * ARGB颜色字符串 转 十进制数值（8位带透明通道，专用于带透明的颜色运算）
-     * @param argb 支持 #AARRGGBB / AARRGGBB 格式 例：#80FFFFFF、80FFFFFF
-     * @returns 十进制数值 例：#80FFFFFF → 2147483647，非法入参/格式错误返回 0
-     */
-    static argbToNumber(argb: string): number;
-    /**
-     * 十进制数值 转回 ARGB颜色字符串（8位带透明通道，标准#AARRGGBB格式）
-     * @param num 十进制数值 例：2147483647 → #80ffffff
-     * @returns 标准ARGB颜色字符串 #AARRGGBB 小写格式
-     */
-    static numberToArgb(num: number): string;
-    /**
-     * 生成随机Hex颜色
-     * @param withSharp 是否带#号 默认为true
-     * @returns 随机hex颜色
-     */
-    static randomHexColor(withSharp?: boolean): string;
-    /**
-     * 反色处理 - 取颜色的补色（比如黑色→白色，白色→黑色）
-     * @param hex 目标颜色
-     * @returns 反色hex
-     */
-    static reverseColor(hex: string): string;
-    /**
-     * 校验是否为合法的hex颜色
-     * @param hex 待校验的颜色字符串
-     * @returns true=合法 false=不合法
-     */
-    static isHexColor(hex: string): boolean;
-    /**
-     * 标准6位Hex颜色 转 ARGB 8位颜色格式 ( 核心：ARGB格式是 #AARRGGBB )
-     * @param hex 6位标准hex 支持 #ffffff / ffffff / #fff / fff
-     * @param alpha 透明度 0~1  默认 1 (完全不透明)
-     * @returns 8位ARGB格式颜色 例：#80FFFFFF  半透明白色
-     */
-    static hexToArgb(hex: string, alpha?: number): string;
-    /**
-     * ARGB 8位颜色格式 转回 标准6位Hex颜色 + 独立的透明度值 ( 反向解析 )
-     * @param argb 8位ARGB格式颜色 必须是 #AARRGGBB 格式 例：#80FFFFFF
-     * @returns { hex: '#ffffff', alpha: 0.5 } 标准hex + 0~1的透明度
-     */
-    static argbToHex(argb: string): {
-        hex: string;
-        alpha: number;
-    };
-    /**
-     * ARGB格式(#AARRGGBB) 转 RRGGBBAA格式(#RRGGBBAA)
-     * @param argb #AARRGGBB
-     * @returns #RRGGBBAA
-     */
-    static argbToRgbaHex(argb: string): string;
-    /**
-     * RRGGBBAA格式(#RRGGBBAA) 转 ARGB格式(#AARRGGBB)
-     * @param rgbaHex #RRGGBBAA
-     * @returns #AARRGGBB
-     */
-    static rgbaHexToArgb(rgbaHex: string): string;
-    /**
-     * 调整颜色饱和度
-     * @param hex 目标颜色
-     * @param level 调整程度 0-2  1=不变  <1=降低饱和度  >1=提高饱和度
-     * @returns 调整后的hex颜色
-     */
-    static adjustSaturation(hex: string, level: number): string;
-    /**
-     * 调整颜色明度
-     * @param hex 目标颜色
-     * @param level 调整程度 0-2  1=不变  <1=降低明度  >1=提高明度
-     * @returns 调整后的hex颜色
-     */
-    static adjustBrightness(hex: string, level: number): string;
-    /**
-     * 普通6位Hex+透明度 → 直接返回ARGB对应的十进制数值
-     * @param hex 支持 #fff / #ffffff 格式
-     * @param alpha 透明度 0-1
-     * @returns ARGB十进制数值
-     */
-    static hexAlphaToArgbNumber(hex: string, alpha?: number): number;
-    /**
-     * ARGB十进制数值 → 解析出 普通Hex + 0-1透明度
-     * @param num ARGB十进制数值
-     * @returns { hex: '#ffffff', alpha: 0.5 }
-     */
-    static argbNumberToHexAlpha(num: number): {
-        hex: string;
-        alpha: number;
-    };
-    /**
-     * 补零成两位字符
-     */
-    private static twoDigits;
-}

package/dist/esm/color.js

@@ -1,500 +0,0 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var CrColorUtil = /*#__PURE__*/function () {
-  function CrColorUtil() {
-    _classCallCheck(this, CrColorUtil);
-  }
-  _createClass(CrColorUtil, null, [{
-    key: "hexToRgb",
-    value:
-    /**
-     * hex 转 rgb 数组 [r,g,b]  r/g/b范围 0-255
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     */
-    function hexToRgb(hex) {
-      var hexVal = hex.replace('#', '');
-      if (hexVal.length === 3) {
-        hexVal = hexVal.split('').map(function (c) {
-          return c + c;
-        }).join('');
-      }
-      var hexInt = parseInt(hexVal, 16);
-      var r = hexInt >> 16 & 255;
-      var g = hexInt >> 8 & 255;
-      var b = hexInt & 255;
-      return [r, g, b];
-    }
-
-    /**
-     * rgb 转 hex 标准格式
-     * @param r 0-255
-     * @param g 0-255
-     * @param b 0-255
-     */
-  }, {
-    key: "rgbToHex",
-    value: function rgbToHex(r, g, b) {
-      var clamp = function clamp(val) {
-        return Math.max(0, Math.min(255, Math.round(val)));
-      };
-      var red = clamp(r);
-      var green = clamp(g);
-      var blue = clamp(b);
-      return '#' + this.twoDigits(red.toString(16)) + this.twoDigits(green.toString(16)) + this.twoDigits(blue.toString(16));
-    }
-
-    /**
-     * 将 rgb 格式转为 hsv 格式
-     * input: r,g,b in [0,1], out: h in [0,360) and s,v in [0,1]
-     * @param r 0-1
-     * @param g 0-1
-     * @param b 0-1
-     */
-  }, {
-    key: "rgb2hsv",
-    value: function rgb2hsv(r, g, b) {
-      var v = Math.max(r, g, b);
-      var n = v - Math.min(r, g, b);
-      var h = n && (v == r ? (g - b) / n : v == g ? 2 + (b - r) / n : 4 + (r - g) / n);
-      return [60 * (h < 0 ? h + 6 : h), v && n / v, v];
-    }
-
-    /**
-     * 将 hsv 格式转为 rgb 格式
-     * input: h in [0,360] and s,v in [0,1] - output: r,g,b in [0,1]
-     * @param h 0-360
-     * @param s 0-1
-     * @param v 0-1
-     */
-  }, {
-    key: "hsv2rgb",
-    value: function hsv2rgb(h, s, v) {
-      var f = function f(n) {
-        var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 60) % 6;
-        return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
-      };
-      return [f(5), f(3), f(1)];
-    }
-
-    /**
-     * hex 转 rgba 格式字符串 可直接用于css
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param alpha 透明度 0-1  默认1(完全不透明)
-     * @returns 例: rgba(255,255,255,0.5)
-     */
-  }, {
-    key: "hexToRgba",
-    value: function hexToRgba(hex) {
-      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      var _this$hexToRgb = this.hexToRgb(hex),
-        _this$hexToRgb2 = _slicedToArray(_this$hexToRgb, 3),
-        r = _this$hexToRgb2[0],
-        g = _this$hexToRgb2[1],
-        b = _this$hexToRgb2[2];
-      var validAlpha = Math.max(0, Math.min(1, alpha));
-      return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(validAlpha, ")");
-    }
-
-    /**
-     * 给hex颜色添加透明度，返回 8位带透明通道的hex格式 #RRGGBBAA (CSS常用)
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param alpha 透明度 0-1  默认1(完全不透明)
-     * @returns 例: #ffffff80  #ff000033
-     */
-  }, {
-    key: "hexAddAlpha",
-    value: function hexAddAlpha(hex) {
-      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      var pureHex = hex.replace('#', '');
-      pureHex = pureHex.length === 3 ? pureHex.split('').map(function (char) {
-        return char + char;
-      }).join('') : pureHex;
-      var validAlpha = Math.max(0, Math.min(1, alpha));
-      var alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
-      return "#".concat(pureHex).concat(alphaHex);
-    }
-
-    /**
-     * rgba 转 hex 格式
-     * @param r 0-255
-     * @param g 0-255
-     * @param b 0-255
-     */
-  }, {
-    key: "rgbaToHex",
-    value: function rgbaToHex(r, g, b) {
-      return this.rgbToHex(r, g, b);
-    }
-
-    /**
-     * hsv 转 hex 十六进制颜色
-     * @param h 色相 0-360
-     * @param s 饱和度 0-1
-     * @param v 明度 0-1
-     */
-  }, {
-    key: "hsvToHex",
-    value: function hsvToHex(h, s, v) {
-      var _this$hsv2rgb = this.hsv2rgb(h, s, v),
-        _this$hsv2rgb2 = _slicedToArray(_this$hsv2rgb, 3),
-        r = _this$hsv2rgb2[0],
-        g = _this$hsv2rgb2[1],
-        b = _this$hsv2rgb2[2];
-      return this.rgbToHex(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255));
-    }
-
-    /**
-     * hex 转 hsv 格式
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @returns [h:0-360, s:0-1, v:0-1]
-     */
-  }, {
-    key: "hexToHsv",
-    value: function hexToHsv(hex) {
-      var _this$hexToRgb3 = this.hexToRgb(hex),
-        _this$hexToRgb4 = _slicedToArray(_this$hexToRgb3, 3),
-        r = _this$hexToRgb4[0],
-        g = _this$hexToRgb4[1],
-        b = _this$hexToRgb4[2];
-      return this.rgb2hsv(r / 255, g / 255, b / 255);
-    }
-
-    /**
-     * 颜色加深处理 - 基于hex颜色
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param level 加深程度 0-1  0不变 1最深(接近黑色)
-     */
-  }, {
-    key: "darkenColor",
-    value: function darkenColor(hex, level) {
-      var _this$hexToRgb5 = this.hexToRgb(hex),
-        _this$hexToRgb6 = _slicedToArray(_this$hexToRgb5, 3),
-        r = _this$hexToRgb6[0],
-        g = _this$hexToRgb6[1],
-        b = _this$hexToRgb6[2];
-      var clamp = function clamp(val) {
-        return Math.max(0, Math.min(255, val));
-      };
-      var darkR = clamp(r - r * level);
-      var darkG = clamp(g - g * level);
-      var darkB = clamp(b - b * level);
-      return this.rgbToHex(darkR, darkG, darkB);
-    }
-
-    /**
-     * 颜色减淡/提亮处理 - 基于hex颜色
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @param level 减淡程度 0-1  0不变 1最亮(接近白色)
-     */
-  }, {
-    key: "lightenColor",
-    value: function lightenColor(hex, level) {
-      var _this$hexToRgb7 = this.hexToRgb(hex),
-        _this$hexToRgb8 = _slicedToArray(_this$hexToRgb7, 3),
-        r = _this$hexToRgb8[0],
-        g = _this$hexToRgb8[1],
-        b = _this$hexToRgb8[2];
-      var clamp = function clamp(val) {
-        return Math.max(0, Math.min(255, val));
-      };
-      var lightR = clamp(r + (255 - r) * level);
-      var lightG = clamp(g + (255 - g) * level);
-      var lightB = clamp(b + (255 - b) * level);
-      return this.rgbToHex(lightR, lightG, lightB);
-    }
-
-    /**
-     * 解析8位带透明的hex #RRGGBBAA 为 普通hex + 透明度
-     * @param hex8 8位带透明的十六进制颜色 例：#ffffff80
-     * @returns { hex: '#ffffff', alpha: 0.5 }
-     */
-  }, {
-    key: "parseHex8",
-    value: function parseHex8(hex8) {
-      var pureHex = hex8.replace('#', '');
-      if (pureHex.length !== 8) return {
-        hex: hex8,
-        alpha: 1
-      };
-      var hex = "#".concat(pureHex.slice(0, 6));
-      var alphaHex = pureHex.slice(6);
-      var alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
-      return {
-        hex: hex,
-        alpha: alpha
-      };
-    }
-
-    /**
-     * rgb 数组 转 rgb/rgba 字符串
-     * @param rgb [r,g,b] 0-255
-     * @param alpha 透明度0-1 传则返回rgba，不传返回rgb
-     */
-  }, {
-    key: "rgbToStr",
-    value: function rgbToStr(rgb, alpha) {
-      var _rgb = _slicedToArray(rgb, 3),
-        r = _rgb[0],
-        g = _rgb[1],
-        b = _rgb[2];
-      return alpha !== undefined ? "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(Math.max(0, Math.min(1, alpha)), ")") : "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")");
-    }
-
-    /**
-     * Hex颜色字符串 转 十进制数值（6位纯颜色值，无透明通道，专用于颜色运算）
-     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
-     * @returns 十进制数值 例：#ff0000 → 16711680，非法入参返回 0
-     */
-  }, {
-    key: "hexToNumber",
-    value: function hexToNumber(hex) {
-      var pureHex = hex.replace('#', '');
-      // 严谨校验：只允许3位/6位纯十六进制颜色，非法值返回0，避免NaN
-      if (!/^[0-9a-fA-F]{3}|[0-9a-fA-F]{6}$/.test(pureHex)) {
-        return 0;
-      }
-      return parseInt(pureHex, 16);
-    }
-
-    /**
-     * 十进制数值 转回 Hex颜色字符串（无透明通道 标准6位）
-     * @param num 十进制数值 例：16711680 → #ff0000
-     * @returns 标准6位十六进制颜色 #RRGGBB 格式
-     */
-  }, {
-    key: "numberToHex",
-    value: function numberToHex(num) {
-      // 位运算拆解R/G/B通道，值范围永远0-255，再转16进制字符串+补零
-      var r = this.twoDigits((num >> 16 & 255).toString(16));
-      var g = this.twoDigits((num >> 8 & 255).toString(16));
-      var b = this.twoDigits((num & 255).toString(16));
-      return "#".concat(r).concat(g).concat(b);
-    }
-
-    /**
-     * ARGB颜色字符串 转 十进制数值（8位带透明通道，专用于带透明的颜色运算）
-     * @param argb 支持 #AARRGGBB / AARRGGBB 格式 例：#80FFFFFF、80FFFFFF
-     * @returns 十进制数值 例：#80FFFFFF → 2147483647，非法入参/格式错误返回 0
-     */
-  }, {
-    key: "argbToNumber",
-    value: function argbToNumber(argb) {
-      var pureArgb = argb.replace('#', '');
-      if (!/^[0-9a-fA-F]{8}$/.test(pureArgb)) {
-        return 0;
-      }
-      return parseInt(pureArgb, 16);
-    }
-
-    /**
-     * 十进制数值 转回 ARGB颜色字符串（8位带透明通道，标准#AARRGGBB格式）
-     * @param num 十进制数值 例：2147483647 → #80ffffff
-     * @returns 标准ARGB颜色字符串 #AARRGGBB 小写格式
-     */
-  }, {
-    key: "numberToArgb",
-    value: function numberToArgb(num) {
-      var a = this.twoDigits((num >> 24 & 255).toString(16));
-      var r = this.twoDigits((num >> 16 & 255).toString(16));
-      var g = this.twoDigits((num >> 8 & 255).toString(16));
-      var b = this.twoDigits((num & 255).toString(16));
-      return "#".concat(a).concat(r).concat(g).concat(b);
-    }
-
-    /**
-     * 生成随机Hex颜色
-     * @param withSharp 是否带#号 默认为true
-     * @returns 随机hex颜色
-     */
-  }, {
-    key: "randomHexColor",
-    value: function randomHexColor() {
-      var withSharp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      var hex = this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16));
-      return withSharp ? "#".concat(hex) : hex;
-    }
-
-    /**
-     * 反色处理 - 取颜色的补色（比如黑色→白色，白色→黑色）
-     * @param hex 目标颜色
-     * @returns 反色hex
-     */
-  }, {
-    key: "reverseColor",
-    value: function reverseColor(hex) {
-      var _this$hexToRgb9 = this.hexToRgb(hex),
-        _this$hexToRgb10 = _slicedToArray(_this$hexToRgb9, 3),
-        r = _this$hexToRgb10[0],
-        g = _this$hexToRgb10[1],
-        b = _this$hexToRgb10[2];
-      return this.rgbToHex(255 - r, 255 - g, 255 - b);
-    }
-
-    /**
-     * 校验是否为合法的hex颜色
-     * @param hex 待校验的颜色字符串
-     * @returns true=合法 false=不合法
-     */
-  }, {
-    key: "isHexColor",
-    value: function isHexColor(hex) {
-      return /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(hex);
-    }
-
-    /**
-     * 标准6位Hex颜色 转 ARGB 8位颜色格式 ( 核心：ARGB格式是 #AARRGGBB )
-     * @param hex 6位标准hex 支持 #ffffff / ffffff / #fff / fff
-     * @param alpha 透明度 0~1  默认 1 (完全不透明)
-     * @returns 8位ARGB格式颜色 例：#80FFFFFF  半透明白色
-     */
-  }, {
-    key: "hexToArgb",
-    value: function hexToArgb(hex) {
-      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      var pureHex = hex.replace('#', '');
-      if (pureHex.length === 3) {
-        pureHex = pureHex.split('').map(function (char) {
-          return char + char;
-        }).join('');
-      }
-      var validAlpha = Math.max(0, Math.min(1, alpha));
-      var alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
-      return "#".concat(alphaHex).concat(pureHex);
-    }
-
-    /**
-     * ARGB 8位颜色格式 转回 标准6位Hex颜色 + 独立的透明度值 ( 反向解析 )
-     * @param argb 8位ARGB格式颜色 必须是 #AARRGGBB 格式 例：#80FFFFFF
-     * @returns { hex: '#ffffff', alpha: 0.5 } 标准hex + 0~1的透明度
-     */
-  }, {
-    key: "argbToHex",
-    value: function argbToHex(argb) {
-      var pureArgb = argb.replace('#', '');
-      if (pureArgb.length !== 8) {
-        console.warn('传入的不是合法的ARGB格式，格式必须是 #AARRGGBB');
-        return {
-          hex: argb,
-          alpha: 1
-        };
-      }
-      var alphaHex = pureArgb.slice(0, 2);
-      var hexVal = pureArgb.slice(2);
-      var alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
-      return {
-        hex: "#".concat(hexVal),
-        alpha: alpha
-      };
-    }
-
-    /**
-     * ARGB格式(#AARRGGBB) 转 RRGGBBAA格式(#RRGGBBAA)
-     * @param argb #AARRGGBB
-     * @returns #RRGGBBAA
-     */
-  }, {
-    key: "argbToRgbaHex",
-    value: function argbToRgbaHex(argb) {
-      var pureArgb = argb.replace('#', '');
-      if (pureArgb.length !== 8) return argb;
-      return "#".concat(pureArgb.slice(2)).concat(pureArgb.slice(0, 2));
-    }
-
-    /**
-     * RRGGBBAA格式(#RRGGBBAA) 转 ARGB格式(#AARRGGBB)
-     * @param rgbaHex #RRGGBBAA
-     * @returns #AARRGGBB
-     */
-  }, {
-    key: "rgbaHexToArgb",
-    value: function rgbaHexToArgb(rgbaHex) {
-      var pureRgba = rgbaHex.replace('#', '');
-      if (pureRgba.length !== 8) return rgbaHex;
-      return "#".concat(pureRgba.slice(6)).concat(pureRgba.slice(0, 6));
-    }
-
-    /**
-     * 调整颜色饱和度
-     * @param hex 目标颜色
-     * @param level 调整程度 0-2  1=不变  <1=降低饱和度  >1=提高饱和度
-     * @returns 调整后的hex颜色
-     */
-  }, {
-    key: "adjustSaturation",
-    value: function adjustSaturation(hex, level) {
-      var _this$hexToHsv = this.hexToHsv(hex),
-        _this$hexToHsv2 = _slicedToArray(_this$hexToHsv, 3),
-        h = _this$hexToHsv2[0],
-        s = _this$hexToHsv2[1],
-        v = _this$hexToHsv2[2];
-      var newS = Math.max(0, Math.min(1, s * level));
-      return this.hsvToHex(h, newS, v);
-    }
-
-    /**
-     * 调整颜色明度
-     * @param hex 目标颜色
-     * @param level 调整程度 0-2  1=不变  <1=降低明度  >1=提高明度
-     * @returns 调整后的hex颜色
-     */
-  }, {
-    key: "adjustBrightness",
-    value: function adjustBrightness(hex, level) {
-      var _this$hexToHsv3 = this.hexToHsv(hex),
-        _this$hexToHsv4 = _slicedToArray(_this$hexToHsv3, 3),
-        h = _this$hexToHsv4[0],
-        s = _this$hexToHsv4[1],
-        v = _this$hexToHsv4[2];
-      var newV = Math.max(0, Math.min(1, v * level));
-      return this.hsvToHex(h, s, newV);
-    }
-
-    /**
-     * 普通6位Hex+透明度 → 直接返回ARGB对应的十进制数值
-     * @param hex 支持 #fff / #ffffff 格式
-     * @param alpha 透明度 0-1
-     * @returns ARGB十进制数值
-     */
-  }, {
-    key: "hexAlphaToArgbNumber",
-    value: function hexAlphaToArgbNumber(hex) {
-      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      var argbStr = this.hexToArgb(hex, alpha);
-      return this.argbToNumber(argbStr);
-    }
-
-    /**
-     * ARGB十进制数值 → 解析出 普通Hex + 0-1透明度
-     * @param num ARGB十进制数值
-     * @returns { hex: '#ffffff', alpha: 0.5 }
-     */
-  }, {
-    key: "argbNumberToHexAlpha",
-    value: function argbNumberToHexAlpha(num) {
-      var argbStr = this.numberToArgb(num);
-      return this.argbToHex(argbStr);
-    }
-
-    /**
-     * 补零成两位字符
-     */
-  }, {
-    key: "twoDigits",
-    value: function twoDigits(num) {
-      var s = num.toString();
-      return s.length === 1 ? '0' + s : s;
-    }
-  }]);
-  return CrColorUtil;
-}();
-export { CrColorUtil as default };