@unicom-cloud/ui 0.8.90 → 0.8.92

package/dist/react-transition-group/src/ReplaceTransition.js

@@ -0,0 +1,43 @@
+import { jsx as h } from "react/jsx-runtime";
+import { P as a } from "../chunk/F6QOOr2H.js";
+import o from "react";
+import E from "react-dom";
+import c from "./TransitionGroup.js";
+var p = Object.defineProperty, f = (t, e, i) => e in t ? p(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i, r = (t, e, i) => f(t, typeof e != "symbol" ? e + "" : e, i);
+class m extends o.Component {
+  constructor() {
+    super(...arguments), r(this, "handleEnter", (...e) => this.handleLifecycle("onEnter", 0, e)), r(this, "handleEntering", (...e) => this.handleLifecycle("onEntering", 0, e)), r(this, "handleEntered", (...e) => this.handleLifecycle("onEntered", 0, e)), r(this, "handleExit", (...e) => this.handleLifecycle("onExit", 1, e)), r(this, "handleExiting", (...e) => this.handleLifecycle("onExiting", 1, e)), r(this, "handleExited", (...e) => this.handleLifecycle("onExited", 1, e));
+  }
+  handleLifecycle(e, i, n) {
+    const { children: d } = this.props, l = o.Children.toArray(d)[i];
+    if (l.props[e] && l.props[e](...n), this.props[e]) {
+      const s = l.props.nodeRef ? void 0 : E.findDOMNode(this);
+      this.props[e](s);
+    }
+  }
+  render() {
+    const { children: e, in: i, ...n } = this.props, [d, l] = o.Children.toArray(e);
+    return delete n.onEnter, delete n.onEntering, delete n.onEntered, delete n.onExit, delete n.onExiting, delete n.onExited, /* @__PURE__ */ h(c, { ...n, children: i ? o.cloneElement(d, {
+      key: "first",
+      onEnter: this.handleEnter,
+      onEntering: this.handleEntering,
+      onEntered: this.handleEntered
+    }) : o.cloneElement(l, {
+      key: "second",
+      onEnter: this.handleExit,
+      onEntering: this.handleExiting,
+      onEntered: this.handleExited
+    }) });
+  }
+}
+m.propTypes = {
+  in: a.bool.isRequired,
+  children(t, e) {
+    return o.Children.count(t[e]) !== 2 ? new Error(
+      `"${e}" must be exactly two transition components.`
+    ) : null;
+  }
+};
+export {
+  m as default
+};

package/dist/react-transition-group/src/SwitchTransition.js

@@ -0,0 +1,117 @@
+import { jsx as f } from "react/jsx-runtime";
+import { P as c } from "../chunk/F6QOOr2H.js";
+import r from "react";
+import { a as o, b as h, E as u } from "../chunk/CPfP7aNL.js";
+import g from "./TransitionGroupContext.js";
+var S = Object.defineProperty, b = (t, e, n) => e in t ? S(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, d = (t, e, n) => b(t, typeof e != "symbol" ? e + "" : e, n);
+function x(t, e) {
+  return !(t === e || r.isValidElement(t) && r.isValidElement(e) && t.key != null && t.key === e.key);
+}
+const a = {
+  out: "out-in",
+  in: "in-out"
+}, l = (t, e, n) => (...s) => {
+  t.props[e] && t.props[e](...s), n();
+}, y = {
+  [a.out]: ({ current: t, changeState: e }) => r.cloneElement(t, {
+    in: !1,
+    onExited: l(t, "onExited", () => {
+      e(o, null);
+    })
+  }),
+  [a.in]: ({ current: t, changeState: e, children: n }) => [
+    t,
+    r.cloneElement(n, {
+      in: !0,
+      onEntered: l(n, "onEntered", () => {
+        e(o);
+      })
+    })
+  ]
+}, v = {
+  [a.out]: ({ children: t, changeState: e }) => r.cloneElement(t, {
+    in: !0,
+    onEntered: l(t, "onEntered", () => {
+      e(u, r.cloneElement(t, { in: !0 }));
+    })
+  }),
+  [a.in]: ({ current: t, children: e, changeState: n }) => [
+    r.cloneElement(t, {
+      in: !1,
+      onExited: l(t, "onExited", () => {
+        n(u, r.cloneElement(e, { in: !0 }));
+      })
+    }),
+    r.cloneElement(e, {
+      in: !0
+    })
+  ]
+};
+class E extends r.Component {
+  constructor() {
+    super(...arguments), d(this, "state", {
+      status: u,
+      current: null
+    }), d(this, "appeared", !1), d(this, "changeState", (e, n = this.state.current) => {
+      this.setState({
+        status: e,
+        current: n
+      });
+    });
+  }
+  componentDidMount() {
+    this.appeared = !0;
+  }
+  static getDerivedStateFromProps(e, n) {
+    return e.children == null ? {
+      current: null
+    } : n.status === o && e.mode === a.in ? {
+      status: o
+    } : n.current && x(n.current, e.children) ? {
+      status: h
+    } : {
+      current: r.cloneElement(e.children, {
+        in: !0
+      })
+    };
+  }
+  render() {
+    const {
+      props: { children: e, mode: n },
+      state: { status: s, current: m }
+    } = this, p = { children: e, current: m, changeState: this.changeState, status: s };
+    let i;
+    switch (s) {
+      case o:
+        i = v[n](p);
+        break;
+      case h:
+        i = y[n](p);
+        break;
+      case u:
+        i = m;
+    }
+    return /* @__PURE__ */ f(g.Provider, { value: { isMounting: !this.appeared }, children: i });
+  }
+}
+E.propTypes = {
+  /**
+   * Transition modes.
+   * `out-in`: Current element transitions out first, then when complete, the new element transitions in.
+   * `in-out`: New element transitions in first, then when complete, the current element transitions out.
+   *
+   * @type {'out-in'|'in-out'}
+   */
+  mode: c.oneOf([a.in, a.out]),
+  /**
+   * Any `Transition` or `CSSTransition` component.
+   */
+  children: c.oneOfType([c.element.isRequired])
+};
+E.defaultProps = {
+  mode: a.out
+};
+export {
+  E as default,
+  a as modes
+};

package/dist/react-transition-group/src/TransitionGroup.js

@@ -0,0 +1,160 @@
+import { jsx as f } from "react/jsx-runtime";
+import { P as c } from "../chunk/F6QOOr2H.js";
+import y, { isValidElement as p, cloneElement as h, Children as v } from "react";
+import E from "./TransitionGroupContext.js";
+function m(n, e) {
+  let r = (t) => e && p(t) ? e(t) : t, o = /* @__PURE__ */ Object.create(null);
+  return n && v.map(n, (t) => t).forEach((t) => {
+    o[t.key] = r(t);
+  }), o;
+}
+function g(n, e) {
+  n = n || {}, e = e || {};
+  function r(l) {
+    return l in e ? e[l] : n[l];
+  }
+  let o = /* @__PURE__ */ Object.create(null), t = [];
+  for (let l in n)
+    l in e ? t.length && (o[l] = t, t = []) : t.push(l);
+  let i, s = {};
+  for (let l in e) {
+    if (o[l])
+      for (i = 0; i < o[l].length; i++) {
+        let a = o[l][i];
+        s[o[l][i]] = r(a);
+      }
+    s[l] = r(l);
+  }
+  for (i = 0; i < t.length; i++)
+    s[t[i]] = r(t[i]);
+  return s;
+}
+function d(n, e, r) {
+  return r[e] != null ? r[e] : n.props[e];
+}
+function j(n, e) {
+  return m(n.children, (r) => h(r, {
+    onExited: e.bind(null, r),
+    in: !0,
+    appear: d(r, "appear", n),
+    enter: d(r, "enter", n),
+    exit: d(r, "exit", n)
+  }));
+}
+function k(n, e, r) {
+  let o = m(n.children), t = g(e, o);
+  return Object.keys(t).forEach((i) => {
+    let s = t[i];
+    if (!p(s)) return;
+    const l = i in e, a = i in o, u = e[i], x = p(u) && !u.props.in;
+    a && (!l || x) ? t[i] = h(s, {
+      onExited: r.bind(null, s),
+      in: !0,
+      exit: d(s, "exit", n),
+      enter: d(s, "enter", n)
+    }) : !a && l && !x ? t[i] = h(s, { in: !1 }) : a && l && p(u) && (t[i] = h(s, {
+      onExited: r.bind(null, s),
+      in: u.props.in,
+      exit: d(s, "exit", n),
+      enter: d(s, "enter", n)
+    }));
+  }), t;
+}
+const O = Object.values || ((n) => Object.keys(n).map((e) => n[e])), P = {
+  component: "div",
+  childFactory: (n) => n
+};
+class b extends y.Component {
+  constructor(e, r) {
+    super(e, r);
+    const o = this.handleExited.bind(this);
+    this.state = {
+      contextValue: { isMounting: !0 },
+      handleExited: o,
+      firstRender: !0
+    };
+  }
+  componentDidMount() {
+    this.mounted = !0, this.setState({
+      contextValue: { isMounting: !1 }
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+  }
+  static getDerivedStateFromProps(e, { children: r, handleExited: o, firstRender: t }) {
+    return {
+      children: t ? j(e, o) : k(e, r, o),
+      firstRender: !1
+    };
+  }
+  // node is `undefined` when user provided `nodeRef` prop
+  handleExited(e, r) {
+    let o = m(this.props.children);
+    e.key in o || (e.props.onExited && e.props.onExited(r), this.mounted && this.setState((t) => {
+      let i = { ...t.children };
+      return delete i[e.key], { children: i };
+    }));
+  }
+  render() {
+    const { component: e, childFactory: r, ...o } = this.props, { contextValue: t } = this.state, i = O(this.state.children).map(r);
+    return delete o.appear, delete o.enter, delete o.exit, e === null ? /* @__PURE__ */ f(E.Provider, { value: t, children: i }) : /* @__PURE__ */ f(E.Provider, { value: t, children: /* @__PURE__ */ f(e, { ...o, children: i }) });
+  }
+}
+b.propTypes = {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: c.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: c.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: c.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: c.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: c.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: c.func
+};
+b.defaultProps = P;
+export {
+  b as default
+};

package/dist/react-transition-group/src/TransitionGroupContext.js

@@ -0,0 +1,5 @@
+import t from "react";
+const o = t.createContext(null);
+export {
+  o as default
+};

package/dist/react-transition-group/src/config.js

@@ -0,0 +1,6 @@
+const a = {
+  disabled: !1
+};
+export {
+  a as default
+};

package/{chunk/Coz3rCng.js → dist/scroll-into-view-if-needed/src/index.js}

@@ -1,4 +1,4 @@
-import { compute as r } from "../utils/computeScrollIntoView.js";
+import { compute as r } from "../../compute-scroll-into-view/src/index.js";
 const f = (t) => t === Object(t) && Object.keys(t).length !== 0, p = (t) => typeof t == "object" ? typeof t.behavior == "function" : !1, d = (t) => t === !1 ? { block: "end", inline: "nearest" } : f(t) ? t : { block: "start", inline: "nearest" }, u = (t) => {
   const o = window.getComputedStyle(t);
   return {
@@ -23,11 +23,11 @@ function g(t, o) {
   if (p(o))
     return o.behavior(r(t, o));
   const n = typeof o == "boolean" || o == null ? void 0 : o.behavior;
-  for (const { el: l, top: a, left: i } of r(t, d(o))) {
-    const s = a - e.top + e.bottom, c = i - e.left + e.right;
-    l.scroll({ top: s, left: c, behavior: n });
+  for (const { el: a, top: l, left: s } of r(t, d(o))) {
+    const i = l - e.top + e.bottom, c = s - e.left + e.right;
+    a.scroll({ top: i, left: c, behavior: n });
   }
 }
 export {
-  g as p
+  g as default
 };

package/dist/tinycolor/chunk/DGZSWe7E.js

@@ -0,0 +1,182 @@
+import { TinyColor as e } from "../src/index.js";
+const o = 10, k = {
+  name: { zh: "浪漫红", en: "red" },
+  value: "#F53F3F"
+}, b = {
+  name: { zh: "晚秋红", en: "orangered" },
+  value: "#FF702E"
+}, f = {
+  name: { zh: "活力橙", en: "orange" },
+  value: "#FFA500"
+}, C = {
+  name: { zh: "黄昏", en: "gold" },
+  value: "#FFBD14"
+}, _ = {
+  name: { zh: "柠檬黄", en: "yellow" },
+  value: "#FFE014"
+}, j = {
+  name: { zh: "新生绿", en: "lime" },
+  value: "#A1E619"
+}, q = {
+  name: { zh: "仙野绿", en: "green" },
+  value: "#00B82B"
+}, P = {
+  name: { zh: "碧涛青", en: "cyan" },
+  value: "#0BD0D0"
+}, T = {
+  name: { zh: "海蔚蓝", en: "blue" },
+  value: "#2E8FFF"
+}, H = {
+  name: { zh: "极致蓝", en: "pqbblue" },
+  value: "#1A5EFF"
+}, L = {
+  name: { zh: "暗夜紫", en: "purple" },
+  value: "#7126D9"
+}, M = {
+  name: { zh: "青春紫", en: "pinkpurple" },
+  value: "#D91AD9"
+}, O = {
+  name: { zh: "品红", en: "magenta" },
+  value: "#FF299F"
+}, t = {
+  name: { zh: "中性灰", en: "gray" },
+  value: "#6B6C6D"
+}, i = [
+  k,
+  b,
+  f,
+  C,
+  _,
+  j,
+  q,
+  P,
+  T,
+  H,
+  L,
+  M,
+  O
+];
+var A, B;
+const S = {
+  key: ((A = t.name) == null ? void 0 : A.en) ?? ((B = t.name) == null ? void 0 : B.zh) ?? t.name,
+  name: t.name,
+  primary: t.value,
+  light: [
+    new e("#F7F8F9"),
+    new e("#F2F3F4"),
+    new e("#E5E6E7"),
+    new e("#C9CACB"),
+    new e("#A9ABAC"),
+    new e("#868788"),
+    new e(t.value),
+    new e("#4D4E4F"),
+    new e("#28292A"),
+    new e("#1E1F20")
+  ],
+  dark: [
+    new e("#121213"),
+    new e("#1C1C1D"),
+    new e("#404142"),
+    new e("#5E5F60"),
+    new e("#797A7B"),
+    new e("#9C9E9F"),
+    new e("#BCBDBE"),
+    new e("#D8D9DB"),
+    new e("#E4E6E8"),
+    new e("#E8EBEE")
+  ]
+}, K = i.map((n, s, F) => {
+  const r = n.name, a = (r == null ? void 0 : r.en) ?? (r == null ? void 0 : r.zh) ?? r, u = n.value;
+  return {
+    key: a,
+    name: r,
+    primary: u,
+    light: G({ color: u, length: o }),
+    dark: N({ color: u, length: o })
+  };
+}).concat([S]);
+function p(n = {}) {
+  const { length: s, color: F, level: r } = n, a = (s ?? o) / 2 + 1, u = r ?? a;
+  let m = new e(F);
+  const g = m.toHsv(), E = g.h, l = g.s, c = g.v, d = E === 0 && l === 0, y = u < a, h = Math.abs(a - u), I = 1, z = 0.1;
+  let v = l;
+  v > z && (y ? v = l - (l - z) / (a - 1) * h : v = l + (I - l) / (a - 1) * h), d && (v = l);
+  const J = d ? 0.97 : 1, D = 0.1;
+  let w = c;
+  return w > D && (y ? w = c + (J - c) / (a - 1) * h : w = c - (c - D) / (a - 1) * h), m = new e({
+    h: E,
+    s: v,
+    v: w
+  }), n.dark && (m = m.darken(n.amount ?? 10)), m;
+}
+function x(n = {}) {
+  return p({ ...n, dark: !0 });
+}
+function G(n = {}) {
+  const { length: s } = n;
+  return Array.from(new Array(s ?? o), (F, r) => {
+    const a = r + 1;
+    return p({ ...n, level: a });
+  });
+}
+function N(n = {}) {
+  const { length: s } = n;
+  return Array.from(new Array(s ?? o), (F, r) => {
+    const a = r + 1;
+    return x({
+      ...n,
+      level: o - a + 1
+    });
+  });
+}
+const Q = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  LENGTH: o,
+  blue: T,
+  colorPresets: K,
+  colors: i,
+  cyan: P,
+  default: i,
+  generate: G,
+  generateDark: N,
+  gold: C,
+  gray: t,
+  grayPresets: S,
+  green: q,
+  lime: j,
+  magenta: O,
+  orange: f,
+  orangered: b,
+  palette: p,
+  paletteDark: x,
+  pinkpurple: M,
+  pqbblue: H,
+  purple: L,
+  red: k,
+  yellow: _
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  o as L,
+  Q as a,
+  T as b,
+  i as c,
+  K as d,
+  P as e,
+  N as f,
+  G as g,
+  C as h,
+  t as i,
+  S as j,
+  q as k,
+  j as l,
+  O as m,
+  b as n,
+  f as o,
+  p,
+  x as q,
+  M as r,
+  H as s,
+  L as t,
+  k as u,
+  _ as y
+};

package/dist/tinycolor/customize/index.js

@@ -0,0 +1,12 @@
+import { c as f, a as h } from "../chunk/DGZSWe7E.js";
+function p(c = [34797, 15747172]) {
+  return (a = 1) => {
+    const o = c, r = Math.log(256) / Math.log(2), l = o[0] >>> r * 2 & 255, s = o[0] >>> r * 1 & 255, g = o[0] >>> r * 0 & 255, t = o[1] >>> r * 2 & 255, e = o[1] >>> r * 1 & 255, n = o[1] >>> r * 0 & 255, u = t - (t - l) * a, i = e - (e - s) * a, m = n - (n - g) * a;
+    return `rgb(${u},${i},${m})`;
+  };
+}
+export {
+  f as colors,
+  p as compareColorByRange,
+  h as uiColor
+};

package/dist/tinycolor/src/conversion.js

@@ -0,0 +1,143 @@
+import { bound01 as i, pad2 as h } from "./util.js";
+function l(a, o, t) {
+  return {
+    r: i(a, 255) * 255,
+    g: i(o, 255) * 255,
+    b: i(t, 255) * 255
+  };
+}
+function T(a, o, t) {
+  a = i(a, 255), o = i(o, 255), t = i(t, 255);
+  const c = Math.max(a, o, t), n = Math.min(a, o, t);
+  let r = 0, s = 0;
+  const e = (c + n) / 2;
+  if (c === n)
+    s = 0, r = 0;
+  else {
+    const u = c - n;
+    switch (s = e > 0.5 ? u / (2 - c - n) : u / (c + n), c) {
+      case a:
+        r = (o - t) / u + (o < t ? 6 : 0);
+        break;
+      case o:
+        r = (t - a) / u + 2;
+        break;
+      case t:
+        r = (a - o) / u + 4;
+        break;
+    }
+    r /= 6;
+  }
+  return { h: r, s, l: e };
+}
+function f(a, o, t) {
+  return t < 0 && (t += 1), t > 1 && (t -= 1), t < 1 / 6 ? a + (o - a) * (6 * t) : t < 1 / 2 ? o : t < 2 / 3 ? a + (o - a) * (2 / 3 - t) * 6 : a;
+}
+function S(a, o, t) {
+  let c, n, r;
+  if (a = i(a, 360), o = i(o, 100), t = i(t, 100), o === 0)
+    n = t, r = t, c = t;
+  else {
+    const s = t < 0.5 ? t * (1 + o) : t + o - t * o, e = 2 * t - s;
+    c = f(e, s, a + 1 / 3), n = f(e, s, a), r = f(e, s, a - 1 / 3);
+  }
+  return { r: c * 255, g: n * 255, b: r * 255 };
+}
+function k(a, o, t) {
+  a = i(a, 255), o = i(o, 255), t = i(t, 255);
+  const c = Math.max(a, o, t), n = Math.min(a, o, t);
+  let r = 0;
+  const s = c, e = c - n, u = c === 0 ? 0 : e / c;
+  if (c === n)
+    r = 0;
+  else {
+    switch (c) {
+      case a:
+        r = (o - t) / e + (o < t ? 6 : 0);
+        break;
+      case o:
+        r = (t - a) / e + 2;
+        break;
+      case t:
+        r = (a - o) / e + 4;
+        break;
+    }
+    r /= 6;
+  }
+  return { h: r, s: u, v: s };
+}
+function p(a, o, t) {
+  a = i(a, 360) * 6, o = i(o, 100), t = i(t, 100);
+  const c = Math.floor(a), n = a - c, r = t * (1 - o), s = t * (1 - n * o), e = t * (1 - (1 - n) * o), u = c % 6, g = [t, s, r, r, e, t][u], b = [e, t, t, s, r, r][u], d = [r, r, e, t, t, s][u];
+  return { r: g * 255, g: b * 255, b: d * 255 };
+}
+function x(a, o, t, c) {
+  const n = [
+    h(Math.round(a).toString(16)),
+    h(Math.round(o).toString(16)),
+    h(Math.round(t).toString(16))
+  ];
+  return c && n[0].startsWith(n[0].charAt(1)) && n[1].startsWith(n[1].charAt(1)) && n[2].startsWith(n[2].charAt(1)) ? n[0].charAt(0) + n[1].charAt(0) + n[2].charAt(0) : n.join("");
+}
+function H(a, o, t, c, n) {
+  const r = [
+    h(Math.round(a).toString(16)),
+    h(Math.round(o).toString(16)),
+    h(Math.round(t).toString(16)),
+    h(M(c))
+  ];
+  return n && r[0].startsWith(r[0].charAt(1)) && r[1].startsWith(r[1].charAt(1)) && r[2].startsWith(r[2].charAt(1)) && r[3].startsWith(r[3].charAt(1)) ? r[0].charAt(0) + r[1].charAt(0) + r[2].charAt(0) + r[3].charAt(0) : r.join("");
+}
+function W(a, o, t, c) {
+  return [
+    h(M(c)),
+    h(Math.round(a).toString(16)),
+    h(Math.round(o).toString(16)),
+    h(Math.round(t).toString(16))
+  ].join("");
+}
+function j(a, o, t, c) {
+  const n = a / 100, r = o / 100, s = t / 100, e = c / 100, u = 255 * (1 - n) * (1 - e), g = 255 * (1 - r) * (1 - e), b = 255 * (1 - s) * (1 - e);
+  return { r: u, g, b };
+}
+function v(a, o, t) {
+  let c = 1 - a / 255, n = 1 - o / 255, r = 1 - t / 255, s = Math.min(c, n, r);
+  return s === 1 ? (c = 0, n = 0, r = 0) : (c = (c - s) / (1 - s) * 100, n = (n - s) / (1 - s) * 100, r = (r - s) / (1 - s) * 100), s *= 100, {
+    c: Math.round(c),
+    m: Math.round(n),
+    y: Math.round(r),
+    k: Math.round(s)
+  };
+}
+function M(a) {
+  return Math.round(parseFloat(a) * 255).toString(16);
+}
+function R(a) {
+  return m(a) / 255;
+}
+function m(a) {
+  return parseInt(a, 16);
+}
+function $(a) {
+  return {
+    r: a >> 16,
+    g: (a & 65280) >> 8,
+    b: a & 255
+  };
+}
+export {
+  j as cmykToRgb,
+  M as convertDecimalToHex,
+  R as convertHexToDecimal,
+  S as hslToRgb,
+  p as hsvToRgb,
+  $ as numberInputToObject,
+  m as parseIntFromHex,
+  v as rgbToCmyk,
+  x as rgbToHex,
+  T as rgbToHsl,
+  k as rgbToHsv,
+  l as rgbToRgb,
+  W as rgbaToArgbHex,
+  H as rgbaToHex
+};