react-headless-color-picker 1.0.0

package/dist/index.js

@@ -0,0 +1,671 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Alpha: () => Alpha,
+  ColorPicker: () => ColorPicker,
+  HexColorPicker: () => HexColorPicker,
+  Hue: () => Hue,
+  Interactive: () => Interactive,
+  Pointer: () => Pointer,
+  Saturation: () => Saturation,
+  clamp: () => clamp,
+  equalColorObjects: () => equalColorObjects,
+  equalColorString: () => equalColorString,
+  equalHex: () => equalHex,
+  formatClassName: () => formatClassName,
+  getNonce: () => getNonce,
+  hexColorModel: () => hexColorModel,
+  hexToHsva: () => hexToHsva,
+  hexToRgba: () => hexToRgba,
+  hslStringToHsva: () => hslStringToHsva,
+  hslaStringToHsva: () => hslaStringToHsva,
+  hslaToHsl: () => hslaToHsl,
+  hslaToHsva: () => hslaToHsva,
+  hsvStringToHsva: () => hsvStringToHsva,
+  hsvaStringToHsva: () => hsvaStringToHsva,
+  hsvaToHex: () => hsvaToHex,
+  hsvaToHslString: () => hsvaToHslString,
+  hsvaToHsla: () => hsvaToHsla,
+  hsvaToHslaString: () => hsvaToHslaString,
+  hsvaToHsv: () => hsvaToHsv,
+  hsvaToHsvString: () => hsvaToHsvString,
+  hsvaToHsvaString: () => hsvaToHsvaString,
+  hsvaToHueHsl: () => hsvaToHueHsl,
+  hsvaToRgbString: () => hsvaToRgbString,
+  hsvaToRgba: () => hsvaToRgba,
+  hsvaToRgbaString: () => hsvaToRgbaString,
+  parseHue: () => parseHue,
+  rgbStringToHsva: () => rgbStringToHsva,
+  rgbaStringToHsva: () => rgbaStringToHsva,
+  rgbaToHex: () => rgbaToHex,
+  rgbaToHsva: () => rgbaToHsva,
+  rgbaToRgb: () => rgbaToRgb,
+  round: () => round,
+  roundHsva: () => roundHsva,
+  setNonce: () => setNonce,
+  useColorManipulation: () => useColorManipulation,
+  useEventCallback: () => useEventCallback,
+  validHex: () => validHex
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks/useColorManipulation.ts
+var import_react2 = require("react");
+
+// src/utils/round.ts
+var round = (number, digits = 0, base = Math.pow(10, digits)) => {
+  return Math.round(base * number) / base;
+};
+
+// src/utils/convert.ts
+var angleUnits = {
+  grad: 360 / 400,
+  turn: 360,
+  rad: 360 / (Math.PI * 2)
+};
+var hexToHsva = (hex) => rgbaToHsva(hexToRgba(hex));
+var hexToRgba = (hex) => {
+  if (hex[0] === "#") hex = hex.substring(1);
+  if (hex.length < 6) {
+    return {
+      r: parseInt(hex[0] + hex[0], 16),
+      g: parseInt(hex[1] + hex[1], 16),
+      b: parseInt(hex[2] + hex[2], 16),
+      a: hex.length === 4 ? round(parseInt(hex[3] + hex[3], 16) / 255, 2) : 1
+    };
+  }
+  return {
+    r: parseInt(hex.substring(0, 2), 16),
+    g: parseInt(hex.substring(2, 4), 16),
+    b: parseInt(hex.substring(4, 6), 16),
+    a: hex.length === 8 ? round(parseInt(hex.substring(6, 8), 16) / 255, 2) : 1
+  };
+};
+var parseHue = (value, unit = "deg") => {
+  return Number(value) * (angleUnits[unit] || 1);
+};
+var hslaStringToHsva = (hslString) => {
+  const matcher2 = /hsla?\(?\s*(-?\d*\.?\d+)(deg|rad|grad|turn)?[,\s]+(-?\d*\.?\d+)%?[,\s]+(-?\d*\.?\d+)%?,?\s*[/\s]*(-?\d*\.?\d+)?(%)?\s*\)?/i;
+  const match = matcher2.exec(hslString);
+  if (!match) return { h: 0, s: 0, v: 0, a: 1 };
+  return hslaToHsva({
+    h: parseHue(match[1], match[2]),
+    s: Number(match[3]),
+    l: Number(match[4]),
+    a: match[5] === void 0 ? 1 : Number(match[5]) / (match[6] ? 100 : 1)
+  });
+};
+var hslStringToHsva = hslaStringToHsva;
+var hslaToHsva = ({ h, s, l, a }) => {
+  s *= (l < 50 ? l : 100 - l) / 100;
+  return {
+    h,
+    s: s > 0 ? 2 * s / (l + s) * 100 : 0,
+    v: l + s,
+    a
+  };
+};
+var hsvaToHex = (hsva) => rgbaToHex(hsvaToRgba(hsva));
+var hsvaToHsla = ({ h, s, v, a }) => {
+  const hh = (200 - s) * v / 100;
+  return {
+    h: round(h),
+    s: round(hh > 0 && hh < 200 ? s * v / 100 / (hh <= 100 ? hh : 200 - hh) * 100 : 0),
+    l: round(hh / 2),
+    a: round(a, 2)
+  };
+};
+var hsvaToHslString = (hsva) => {
+  const { h, s, l } = hsvaToHsla(hsva);
+  return `hsl(${h}, ${s}%, ${l}%)`;
+};
+var hsvaToHsvString = (hsva) => {
+  const { h, s, v } = roundHsva(hsva);
+  return `hsv(${h}, ${s}%, ${v}%)`;
+};
+var hsvaToHsvaString = (hsva) => {
+  const { h, s, v, a } = roundHsva(hsva);
+  return `hsva(${h}, ${s}%, ${v}%, ${a})`;
+};
+var hsvaToHslaString = (hsva) => {
+  const { h, s, l, a } = hsvaToHsla(hsva);
+  return `hsla(${h}, ${s}%, ${l}%, ${a})`;
+};
+var hsvaToRgba = ({ h, s, v, a }) => {
+  h = h / 360 * 6;
+  s = s / 100;
+  v = v / 100;
+  const hh = Math.floor(h), b = v * (1 - s), c = v * (1 - (h - hh) * s), d = v * (1 - (1 - h + hh) * s), module2 = hh % 6;
+  return {
+    r: round([v, c, b, b, d, v][module2] * 255),
+    g: round([d, v, v, c, b, b][module2] * 255),
+    b: round([b, b, d, v, v, c][module2] * 255),
+    a: round(a, 2)
+  };
+};
+var hsvaToRgbString = (hsva) => {
+  const { r, g, b } = hsvaToRgba(hsva);
+  return `rgb(${r}, ${g}, ${b})`;
+};
+var hsvaToRgbaString = (hsva) => {
+  const { r, g, b, a } = hsvaToRgba(hsva);
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+};
+var hsvaStringToHsva = (hsvString) => {
+  const matcher2 = /hsva?\(?\s*(-?\d*\.?\d+)(deg|rad|grad|turn)?[,\s]+(-?\d*\.?\d+)%?[,\s]+(-?\d*\.?\d+)%?,?\s*[/\s]*(-?\d*\.?\d+)?(%)?\s*\)?/i;
+  const match = matcher2.exec(hsvString);
+  if (!match) return { h: 0, s: 0, v: 0, a: 1 };
+  return roundHsva({
+    h: parseHue(match[1], match[2]),
+    s: Number(match[3]),
+    v: Number(match[4]),
+    a: match[5] === void 0 ? 1 : Number(match[5]) / (match[6] ? 100 : 1)
+  });
+};
+var hsvStringToHsva = hsvaStringToHsva;
+var rgbaStringToHsva = (rgbaString) => {
+  const matcher2 = /rgba?\(?\s*(-?\d*\.?\d+)(%)?[,\s]+(-?\d*\.?\d+)(%)?[,\s]+(-?\d*\.?\d+)(%)?,?\s*[/\s]*(-?\d*\.?\d+)?(%)?\s*\)?/i;
+  const match = matcher2.exec(rgbaString);
+  if (!match) return { h: 0, s: 0, v: 0, a: 1 };
+  return rgbaToHsva({
+    r: Number(match[1]) / (match[2] ? 100 / 255 : 1),
+    g: Number(match[3]) / (match[4] ? 100 / 255 : 1),
+    b: Number(match[5]) / (match[6] ? 100 / 255 : 1),
+    a: match[7] === void 0 ? 1 : Number(match[7]) / (match[8] ? 100 : 1)
+  });
+};
+var rgbStringToHsva = rgbaStringToHsva;
+var format = (number) => {
+  const hex = number.toString(16);
+  return hex.length < 2 ? "0" + hex : hex;
+};
+var rgbaToHex = ({ r, g, b, a }) => {
+  const alphaHex = a < 1 ? format(round(a * 255)) : "";
+  return "#" + format(r) + format(g) + format(b) + alphaHex;
+};
+var rgbaToHsva = ({ r, g, b, a }) => {
+  const max = Math.max(r, g, b);
+  const delta = max - Math.min(r, g, b);
+  const hh = delta ? max === r ? (g - b) / delta : max === g ? 2 + (b - r) / delta : 4 + (r - g) / delta : 0;
+  return {
+    h: round(60 * (hh < 0 ? hh + 6 : hh)),
+    s: round(max ? delta / max * 100 : 0),
+    v: round(max / 255 * 100),
+    a
+  };
+};
+var roundHsva = (hsva) => ({
+  h: round(hsva.h),
+  s: round(hsva.s),
+  v: round(hsva.v),
+  a: round(hsva.a, 2)
+});
+var rgbaToRgb = ({ r, g, b }) => ({ r, g, b });
+var hslaToHsl = ({ h, s, l }) => ({ h, s, l });
+var hsvaToHsv = (hsva) => {
+  const { h, s, v } = roundHsva(hsva);
+  return { h, s, v };
+};
+var hsvaToHueHsl = (h) => {
+  return `hsl(${Math.round(h)}, 100%, 50%)`;
+};
+
+// src/utils/compare.ts
+var equalColorObjects = (first, second) => {
+  if (first === second) return true;
+  for (const prop in first) {
+    if (first[prop] !== second[prop])
+      return false;
+  }
+  return true;
+};
+var equalColorString = (first, second) => {
+  return first.replace(/\s/g, "") === second.replace(/\s/g, "");
+};
+var equalHex = (first, second) => {
+  if (first.toLowerCase() === second.toLowerCase()) return true;
+  return equalColorObjects(hexToRgba(first), hexToRgba(second));
+};
+
+// src/hooks/useEventCallback.ts
+var import_react = require("react");
+function useEventCallback(handler) {
+  const callbackRef = (0, import_react.useRef)(handler);
+  const fn = (0, import_react.useRef)((value) => {
+    callbackRef.current && callbackRef.current(value);
+  });
+  callbackRef.current = handler;
+  return fn.current;
+}
+
+// src/hooks/useColorManipulation.ts
+function useColorManipulation(colorModel, color, onChange) {
+  const onChangeCallback = useEventCallback(onChange);
+  const [hsva, updateHsva] = (0, import_react2.useState)(() => colorModel.toHsva(color));
+  const cache = (0, import_react2.useRef)({ color, hsva });
+  (0, import_react2.useEffect)(() => {
+    if (!colorModel.equal(color, cache.current.color)) {
+      const newHsva = colorModel.toHsva(color);
+      cache.current = { hsva: newHsva, color };
+      updateHsva(newHsva);
+    }
+  }, [color, colorModel]);
+  (0, import_react2.useEffect)(() => {
+    let newColor;
+    if (!equalColorObjects(hsva, cache.current.hsva) && !colorModel.equal(newColor = colorModel.fromHsva(hsva), cache.current.color)) {
+      cache.current = { hsva, color: newColor };
+      onChangeCallback(newColor);
+    }
+  }, [hsva, colorModel, onChangeCallback]);
+  const handleChange = (0, import_react2.useCallback)((params) => {
+    updateHsva((current) => Object.assign({}, current, params));
+  }, []);
+  return [hsva, handleChange];
+}
+
+// src/components/Hue.tsx
+var import_react4 = require("react");
+
+// src/utils/clamp.ts
+var clamp = (number, min = 0, max = 1) => {
+  return number > max ? max : number < min ? min : number;
+};
+
+// src/components/Interactive.tsx
+var import_react3 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var isTouch = (e) => "touches" in e;
+var getParentWindow = (node) => node?.ownerDocument?.defaultView ?? window;
+var getRelativePosition = (node, event, touchId) => {
+  const rect = node.getBoundingClientRect();
+  const pointer = isTouch(event) ? Array.from(event.touches).find((t) => t.identifier === touchId) ?? event.touches[0] : event;
+  return {
+    left: clamp(
+      (pointer.pageX - (rect.left + getParentWindow(node).pageXOffset)) / rect.width
+    ),
+    top: clamp(
+      (pointer.pageY - (rect.top + getParentWindow(node).pageYOffset)) / rect.height
+    )
+  };
+};
+var Interactive = (0, import_react3.memo)(function Interactive2({
+  onMove,
+  onKey,
+  children,
+  style,
+  ...rest
+}) {
+  const container = (0, import_react3.useRef)(null);
+  const onMoveCallback = useEventCallback(onMove);
+  const onKeyCallback = useEventCallback(onKey);
+  const touchId = (0, import_react3.useRef)(null);
+  const hasTouch = (0, import_react3.useRef)(false);
+  const [handleMoveStart, handleKeyDown, toggleDocumentEvents] = (0, import_react3.useMemo)(() => {
+    const handleMoveStart2 = ({
+      nativeEvent
+    }) => {
+      const el = container.current;
+      if (!el) return;
+      if (!isTouch(nativeEvent)) nativeEvent.preventDefault();
+      if (hasTouch.current && !isTouch(nativeEvent)) return;
+      if (isTouch(nativeEvent)) {
+        hasTouch.current = true;
+        touchId.current = nativeEvent.changedTouches?.[0]?.identifier ?? null;
+      }
+      el.focus();
+      onMoveCallback(
+        getRelativePosition(el, nativeEvent, touchId.current)
+      );
+      toggleDocumentEvents2(true);
+    };
+    const handleMove = (event) => {
+      if (!isTouch(event)) event.preventDefault();
+      const isDown = isTouch(event) ? event.touches.length > 0 : event.buttons > 0;
+      if (isDown && container.current) {
+        onMoveCallback(
+          getRelativePosition(
+            container.current,
+            event,
+            touchId.current
+          )
+        );
+      } else {
+        toggleDocumentEvents2(false);
+      }
+    };
+    const handleMoveEnd = () => {
+      hasTouch.current = false;
+      touchId.current = null;
+      toggleDocumentEvents2(false);
+    };
+    const handleKeyDown2 = (event) => {
+      const k = event.key;
+      if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(k)) {
+        return;
+      }
+      event.preventDefault();
+      onKeyCallback({
+        left: k === "ArrowRight" ? 0.05 : k === "ArrowLeft" ? -0.05 : 0,
+        top: k === "ArrowDown" ? 0.05 : k === "ArrowUp" ? -0.05 : 0
+      });
+    };
+    function toggleDocumentEvents2(state) {
+      const el = container.current;
+      const win = getParentWindow(el);
+      const method = state ? win.addEventListener.bind(win) : win.removeEventListener.bind(win);
+      if (hasTouch.current) {
+        method("touchmove", handleMove);
+        method("touchend", handleMoveEnd);
+      } else {
+        method("mousemove", handleMove);
+        method("mouseup", handleMoveEnd);
+      }
+    }
+    return [handleMoveStart2, handleKeyDown2, toggleDocumentEvents2];
+  }, [onKeyCallback, onMoveCallback]);
+  (0, import_react3.useEffect)(() => {
+    return () => toggleDocumentEvents(false);
+  }, [toggleDocumentEvents]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      ...rest,
+      ref: container,
+      onMouseDown: handleMoveStart,
+      onTouchStart: handleMoveStart,
+      onKeyDown: handleKeyDown,
+      tabIndex: 0,
+      role: "slider",
+      style: {
+        position: "relative",
+        cursor: "crosshair",
+        outline: "none",
+        ...style
+      },
+      children
+    }
+  );
+});
+
+// src/components/Pointer.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var Pointer = function Pointer2({
+  left,
+  top = 0.5,
+  children,
+  style,
+  ...rest
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "div",
+    {
+      ...rest,
+      style: {
+        position: "absolute",
+        left: `${left * 100}%`,
+        top: `${top * 100}%`,
+        transform: "translate(-50%, -50%)",
+        ...style
+      },
+      children
+    }
+  );
+};
+
+// src/components/Hue.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var Hue = (0, import_react4.memo)(function Hue2({
+  hue,
+  onChange,
+  renderPointer,
+  style,
+  ...rest
+}) {
+  const handleMove = ({ left }) => onChange({ h: 360 * left });
+  const handleKey = ({ left }) => onChange({ h: clamp(hue + left * 360, 0, 360) });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    Interactive,
+    {
+      onMove: handleMove,
+      onKey: handleKey,
+      "aria-label": "Hue",
+      "aria-valuenow": round(hue),
+      "aria-valuemax": 360,
+      "aria-valuemin": 0,
+      style: {
+        background: "linear-gradient(to right, #f00 0%, #ff0 17%, #0f0 33%, #0ff 50%, #00f 67%, #f0f 83%, #f00 100%)",
+        ...style
+      },
+      ...rest,
+      children: renderPointer ? renderPointer({ left: hue / 360, top: 0.5, hue }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Pointer, { left: hue / 360 })
+    }
+  );
+});
+
+// src/components/Saturation.tsx
+var import_react5 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var Saturation = (0, import_react5.memo)(function Saturation2({
+  hsva,
+  onChange,
+  style,
+  renderPointer,
+  ...rest
+}) {
+  const handleMove = ({ left, top }) => onChange({ s: left * 100, v: 100 - top * 100 });
+  const handleKey = ({ left, top }) => onChange({
+    s: clamp(hsva.s + left * 100, 0, 100),
+    v: clamp(hsva.v - top * 100, 0, 100)
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    Interactive,
+    {
+      onMove: handleMove,
+      onKey: handleKey,
+      "aria-label": "Color",
+      "aria-valuetext": `Saturation ${round(hsva.s)}%, Brightness ${round(hsva.v)}%`,
+      style: {
+        width: "100%",
+        height: "100%",
+        background: `
+          linear-gradient(to top, #000, transparent),
+          linear-gradient(to right, #fff, transparent),
+          ${hsvaToHueHsl(hsva.h)}
+        `,
+        ...style
+      },
+      ...rest,
+      children: renderPointer ? renderPointer({ left: hsva.s / 100, top: 1 - hsva.v / 100, hsva }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Pointer, { left: hsva.s / 100, top: 1 - hsva.v / 100 })
+    }
+  );
+});
+
+// src/components/Alpha.tsx
+var import_react6 = require("react");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var Alpha = (0, import_react6.memo)(function Alpha2({
+  hsva,
+  onChange,
+  renderPointer,
+  style,
+  ...rest
+}) {
+  const handleMove = ({ left }) => onChange({ a: left });
+  const handleKey = ({ left }) => onChange({ a: clamp(hsva.a + left) });
+  const colorFrom = `hsla(${Math.round(hsva.h)}, 100%, 50%, 0)`;
+  const colorTo = `hsla(${Math.round(hsva.h)}, 100%, 50%, 1)`;
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    "div",
+    {
+      style: {
+        position: "relative",
+        backgroundImage: `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8'%3E%3Crect width='4' height='4' fill='%23ccc'/%3E%3Crect x='4' y='4' width='4' height='4' fill='%23ccc'/%3E%3C/svg%3E")`,
+        ...style
+      },
+      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        Interactive,
+        {
+          onMove: handleMove,
+          onKey: handleKey,
+          "aria-label": "Alpha",
+          "aria-valuenow": round(hsva.a * 100),
+          "aria-valuemin": 0,
+          "aria-valuemax": 100,
+          "aria-valuetext": `${round(hsva.a * 100)}%`,
+          style: {
+            width: "100%",
+            height: "100%",
+            background: `linear-gradient(90deg, ${colorFrom}, ${colorTo})`
+          },
+          ...rest,
+          children: renderPointer ? renderPointer({ left: hsva.a, top: 0.5, hsva }) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Pointer, { left: hsva.a })
+        }
+      )
+    }
+  );
+});
+
+// src/components/ColorPicker.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function ColorPicker({
+  colorModel,
+  color,
+  onChange,
+  children,
+  renderSaturationPointer,
+  renderHuePointer,
+  ...rest
+}) {
+  const [hsva, updateHsva] = useColorManipulation(colorModel, color, onChange);
+  if (children) {
+    return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children: children({ hsva, updateHsva, Saturation, Hue, Alpha, Pointer }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { ...rest, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      Saturation,
+      {
+        hsva,
+        onChange: updateHsva,
+        renderPointer: renderSaturationPointer,
+        style: { width: "100%", aspectRatio: "1", borderRadius: "4px 4px 0 0" }
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      Hue,
+      {
+        hue: hsva.h,
+        onChange: updateHsva,
+        renderPointer: renderHuePointer,
+        style: { width: "100%", height: 24, borderRadius: "0 0 4px 4px", marginTop: 4 }
+      }
+    )
+  ] });
+}
+
+// src/components/HexColorPicker.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var hexColorModel = {
+  defaultColor: "#ff0000",
+  toHsva: hexToHsva,
+  fromHsva: (hsva) => hsvaToHex(hsva),
+  equal: equalHex
+};
+function HexColorPicker({
+  color = "#ff0000",
+  ...rest
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(ColorPicker, { colorModel: hexColorModel, color, ...rest });
+}
+
+// src/utils/validate.ts
+var matcher = /^#?([0-9A-F]{3,8})$/i;
+var validHex = (value, alpha) => {
+  const match = matcher.exec(value);
+  const length = match ? match[1].length : 0;
+  return length === 3 || // '#rgb' format
+  length === 6 || // '#rrggbb' format
+  !!alpha && length === 4 || // '#rgba' format
+  !!alpha && length === 8;
+};
+
+// src/utils/nonce.ts
+var nonce;
+var getNonce = () => {
+  if (nonce) return nonce;
+  if (typeof __webpack_nonce__ !== "undefined") return __webpack_nonce__;
+  return void 0;
+};
+var setNonce = (hash) => {
+  nonce = hash;
+};
+
+// src/utils/format.ts
+var formatClassName = (names) => names.filter(Boolean).join(" ");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Alpha,
+  ColorPicker,
+  HexColorPicker,
+  Hue,
+  Interactive,
+  Pointer,
+  Saturation,
+  clamp,
+  equalColorObjects,
+  equalColorString,
+  equalHex,
+  formatClassName,
+  getNonce,
+  hexColorModel,
+  hexToHsva,
+  hexToRgba,
+  hslStringToHsva,
+  hslaStringToHsva,
+  hslaToHsl,
+  hslaToHsva,
+  hsvStringToHsva,
+  hsvaStringToHsva,
+  hsvaToHex,
+  hsvaToHslString,
+  hsvaToHsla,
+  hsvaToHslaString,
+  hsvaToHsv,
+  hsvaToHsvString,
+  hsvaToHsvaString,
+  hsvaToHueHsl,
+  hsvaToRgbString,
+  hsvaToRgba,
+  hsvaToRgbaString,
+  parseHue,
+  rgbStringToHsva,
+  rgbaStringToHsva,
+  rgbaToHex,
+  rgbaToHsva,
+  rgbaToRgb,
+  round,
+  roundHsva,
+  setNonce,
+  useColorManipulation,
+  useEventCallback,
+  validHex
+});
+//# sourceMappingURL=index.js.map