impact-ui 4.0.17-alpha.2 → 5.0.0

package/dist/node_modules/@mui/system/createStyled.js

@@ -0,0 +1,265 @@
+import { __exports as createStyled$1 } from "../../../_virtual/createStyled.js";
+import require$$0 from "@babel/runtime/helpers/interopRequireDefault";
+import require$$1 from "@babel/runtime/helpers/extends";
+import require$$2 from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import require$$1$1 from "../../../_virtual/index7.js";
+import require$$4 from "../../../_virtual/index8.js";
+import require$$5 from "../../../_virtual/index9.js";
+import require$$6 from "../../../_virtual/index10.js";
+import require$$7 from "../../../_virtual/index11.js";
+import require$$8 from "../../../_virtual/index12.js";
+var _interopRequireDefault = require$$0;
+Object.defineProperty(createStyled$1, "__esModule", {
+  value: true
+});
+var _default = createStyled$1.default = createStyled;
+createStyled$1.shouldForwardProp = shouldForwardProp;
+createStyled$1.systemDefaultTheme = void 0;
+var _extends2 = _interopRequireDefault(require$$1);
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require$$2);
+var _styledEngine = _interopRequireWildcard(require$$1$1);
+var _deepmerge = require$$4;
+var _capitalize = _interopRequireDefault(require$$5);
+var _getDisplayName = _interopRequireDefault(require$$6);
+var _createTheme = _interopRequireDefault(require$$7);
+var _styleFunctionSx = _interopRequireDefault(require$$8);
+const _excluded = ["ownerState"], _excluded2 = ["variants"], _excluded3 = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"];
+function _getRequireWildcardCache(e) {
+  if ("function" != typeof WeakMap) return null;
+  var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(e2) {
+    return e2 ? t : r;
+  })(e);
+}
+function _interopRequireWildcard(e, r) {
+  if (e && e.__esModule) return e;
+  if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };
+  var t = _getRequireWildcardCache(r);
+  if (t && t.has(e)) return t.get(e);
+  var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
+    var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+    i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+  }
+  return n.default = e, t && t.set(e, n), n;
+}
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+function isStringTag(tag) {
+  return typeof tag === "string" && // 96 is one less than the char code
+  // for "a" so this is checking that
+  // it's a lowercase character
+  tag.charCodeAt(0) > 96;
+}
+function shouldForwardProp(prop) {
+  return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as";
+}
+function shallowLayer(serialized, layerName) {
+  if (layerName && serialized && typeof serialized === "object" && serialized.styles && !serialized.styles.startsWith("@layer")) {
+    serialized.styles = `@layer ${layerName}{${String(serialized.styles)}}`;
+  }
+  return serialized;
+}
+const systemDefaultTheme = createStyled$1.systemDefaultTheme = (0, _createTheme.default)();
+const lowercaseFirstLetter = (string) => {
+  if (!string) {
+    return string;
+  }
+  return string.charAt(0).toLowerCase() + string.slice(1);
+};
+function resolveTheme({
+  defaultTheme,
+  theme,
+  themeId
+}) {
+  return isEmpty(theme) ? defaultTheme : theme[themeId] || theme;
+}
+function defaultOverridesResolver(slot) {
+  if (!slot) {
+    return null;
+  }
+  return (props, styles) => styles[slot];
+}
+function processStyleArg(callableStyle, _ref, layerName) {
+  let {
+    ownerState
+  } = _ref, props = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+  const resolvedStylesArg = typeof callableStyle === "function" ? callableStyle((0, _extends2.default)({
+    ownerState
+  }, props)) : callableStyle;
+  if (Array.isArray(resolvedStylesArg)) {
+    return resolvedStylesArg.flatMap((resolvedStyle) => processStyleArg(resolvedStyle, (0, _extends2.default)({
+      ownerState
+    }, props), layerName));
+  }
+  if (!!resolvedStylesArg && typeof resolvedStylesArg === "object" && Array.isArray(resolvedStylesArg.variants)) {
+    const {
+      variants = []
+    } = resolvedStylesArg, otherStyles = (0, _objectWithoutPropertiesLoose2.default)(resolvedStylesArg, _excluded2);
+    let result = otherStyles;
+    variants.forEach((variant) => {
+      let isMatch = true;
+      if (typeof variant.props === "function") {
+        isMatch = variant.props((0, _extends2.default)({
+          ownerState
+        }, props, ownerState));
+      } else {
+        Object.keys(variant.props).forEach((key) => {
+          if ((ownerState == null ? void 0 : ownerState[key]) !== variant.props[key] && props[key] !== variant.props[key]) {
+            isMatch = false;
+          }
+        });
+      }
+      if (isMatch) {
+        if (!Array.isArray(result)) {
+          result = [result];
+        }
+        const variantStyle = typeof variant.style === "function" ? variant.style((0, _extends2.default)({
+          ownerState
+        }, props, ownerState)) : variant.style;
+        result.push(layerName ? shallowLayer((0, _styledEngine.internal_serializeStyles)(variantStyle), layerName) : variantStyle);
+      }
+    });
+    return result;
+  }
+  return layerName ? shallowLayer((0, _styledEngine.internal_serializeStyles)(resolvedStylesArg), layerName) : resolvedStylesArg;
+}
+function createStyled(input = {}) {
+  const {
+    themeId,
+    defaultTheme = systemDefaultTheme,
+    rootShouldForwardProp = shouldForwardProp,
+    slotShouldForwardProp = shouldForwardProp
+  } = input;
+  const systemSx = (props) => {
+    return (0, _styleFunctionSx.default)((0, _extends2.default)({}, props, {
+      theme: resolveTheme((0, _extends2.default)({}, props, {
+        defaultTheme,
+        themeId
+      }))
+    }));
+  };
+  systemSx.__mui_systemSx = true;
+  return (tag, inputOptions = {}) => {
+    (0, _styledEngine.internal_processStyles)(tag, (styles) => styles.filter((style) => !(style != null && style.__mui_systemSx)));
+    const {
+      name: componentName,
+      slot: componentSlot,
+      skipVariantsResolver: inputSkipVariantsResolver,
+      skipSx: inputSkipSx,
+      // TODO v6: remove `lowercaseFirstLetter()` in the next major release
+      // For more details: https://github.com/mui/material-ui/pull/37908
+      overridesResolver = defaultOverridesResolver(lowercaseFirstLetter(componentSlot))
+    } = inputOptions, options = (0, _objectWithoutPropertiesLoose2.default)(inputOptions, _excluded3);
+    const layerName = componentName && componentName.startsWith("Mui") || !!componentSlot ? "components" : "custom";
+    const skipVariantsResolver = inputSkipVariantsResolver !== void 0 ? inputSkipVariantsResolver : (
+      // TODO v6: remove `Root` in the next major release
+      // For more details: https://github.com/mui/material-ui/pull/37908
+      componentSlot && componentSlot !== "Root" && componentSlot !== "root" || false
+    );
+    const skipSx = inputSkipSx || false;
+    let label;
+    if (process.env.NODE_ENV !== "production") {
+      if (componentName) {
+        label = `${componentName}-${lowercaseFirstLetter(componentSlot || "Root")}`;
+      }
+    }
+    let shouldForwardPropOption = shouldForwardProp;
+    if (componentSlot === "Root" || componentSlot === "root") {
+      shouldForwardPropOption = rootShouldForwardProp;
+    } else if (componentSlot) {
+      shouldForwardPropOption = slotShouldForwardProp;
+    } else if (isStringTag(tag)) {
+      shouldForwardPropOption = void 0;
+    }
+    const defaultStyledResolver = (0, _styledEngine.default)(tag, (0, _extends2.default)({
+      shouldForwardProp: shouldForwardPropOption,
+      label
+    }, options));
+    const transformStyleArg = (stylesArg) => {
+      if (typeof stylesArg === "function" && stylesArg.__emotion_real !== stylesArg || (0, _deepmerge.isPlainObject)(stylesArg)) {
+        return (props) => {
+          const theme = resolveTheme({
+            theme: props.theme,
+            defaultTheme,
+            themeId
+          });
+          return processStyleArg(stylesArg, (0, _extends2.default)({}, props, {
+            theme
+          }), theme.modularCssLayers ? layerName : void 0);
+        };
+      }
+      return stylesArg;
+    };
+    const muiStyledResolver = (styleArg, ...expressions) => {
+      let transformedStyleArg = transformStyleArg(styleArg);
+      const expressionsWithDefaultTheme = expressions ? expressions.map(transformStyleArg) : [];
+      if (componentName && overridesResolver) {
+        expressionsWithDefaultTheme.push((props) => {
+          const theme = resolveTheme((0, _extends2.default)({}, props, {
+            defaultTheme,
+            themeId
+          }));
+          if (!theme.components || !theme.components[componentName] || !theme.components[componentName].styleOverrides) {
+            return null;
+          }
+          const styleOverrides = theme.components[componentName].styleOverrides;
+          const resolvedStyleOverrides = {};
+          Object.entries(styleOverrides).forEach(([slotKey, slotStyle]) => {
+            resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, (0, _extends2.default)({}, props, {
+              theme
+            }), theme.modularCssLayers ? "theme" : void 0);
+          });
+          return overridesResolver(props, resolvedStyleOverrides);
+        });
+      }
+      if (componentName && !skipVariantsResolver) {
+        expressionsWithDefaultTheme.push((props) => {
+          var _theme$components;
+          const theme = resolveTheme((0, _extends2.default)({}, props, {
+            defaultTheme,
+            themeId
+          }));
+          const themeVariants = theme == null || (_theme$components = theme.components) == null || (_theme$components = _theme$components[componentName]) == null ? void 0 : _theme$components.variants;
+          return processStyleArg({
+            variants: themeVariants
+          }, (0, _extends2.default)({}, props, {
+            theme
+          }), theme.modularCssLayers ? "theme" : void 0);
+        });
+      }
+      if (!skipSx) {
+        expressionsWithDefaultTheme.push(systemSx);
+      }
+      const numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length;
+      if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) {
+        const placeholders = new Array(numOfCustomFnsApplied).fill("");
+        transformedStyleArg = [...styleArg, ...placeholders];
+        transformedStyleArg.raw = [...styleArg.raw, ...placeholders];
+      }
+      const Component = defaultStyledResolver(transformedStyleArg, ...expressionsWithDefaultTheme);
+      if (process.env.NODE_ENV !== "production") {
+        let displayName;
+        if (componentName) {
+          displayName = `${componentName}${(0, _capitalize.default)(componentSlot || "")}`;
+        }
+        if (displayName === void 0) {
+          displayName = `Styled(${(0, _getDisplayName.default)(tag)})`;
+        }
+        Component.displayName = displayName;
+      }
+      if (tag.muiName) {
+        Component.muiName = tag.muiName;
+      }
+      return Component;
+    };
+    if (defaultStyledResolver.withConfig) {
+      muiStyledResolver.withConfig = defaultStyledResolver.withConfig;
+    }
+    return muiStyledResolver;
+  };
+}
+export {
+  _default as default
+};

package/dist/node_modules/@mui/system/esm/DefaultPropsProvider/DefaultPropsProvider.js

@@ -0,0 +1,53 @@
+import * as React from "react";
+import PropTypes from "../../../../prop-types/index.js";
+import "react/jsx-runtime";
+import resolveProps from "../../node_modules/@mui/utils/esm/resolveProps/resolveProps.js";
+const PropsContext = /* @__PURE__ */ React.createContext(void 0);
+process.env.NODE_ENV !== "production" ? {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: PropTypes.node,
+  /**
+   * @ignore
+   */
+  value: PropTypes.object
+} : void 0;
+function getThemeProps(params) {
+  const {
+    theme,
+    name,
+    props
+  } = params;
+  if (!theme || !theme.components || !theme.components[name]) {
+    return props;
+  }
+  const config = theme.components[name];
+  if (config.defaultProps) {
+    return resolveProps(config.defaultProps, props);
+  }
+  if (!config.styleOverrides && !config.variants) {
+    return resolveProps(config, props);
+  }
+  return props;
+}
+function useDefaultProps({
+  props,
+  name
+}) {
+  const ctx = React.useContext(PropsContext);
+  return getThemeProps({
+    props,
+    name,
+    theme: {
+      components: ctx
+    }
+  });
+}
+export {
+  useDefaultProps
+};

package/dist/node_modules/@mui/system/esm/GlobalStyles/GlobalStyles.js

@@ -1,24 +1,48 @@
 import "react";
 import PropTypes from "../../../../prop-types/index.js";
+import { internal_serializeStyles } from "../../../styled-engine/index.js";
 import useTheme from "../useTheme.js";
 import { jsx } from "react/jsx-runtime";
 import GlobalStyles$1 from "../../../styled-engine/GlobalStyles/GlobalStyles.js";
+function wrapGlobalLayer(styles) {
+  const serialized = internal_serializeStyles(styles);
+  if (styles !== serialized && serialized.styles) {
+    if (!serialized.styles.match(/^@layer\s+[^{]*$/)) {
+      serialized.styles = `@layer global{${serialized.styles}}`;
+    }
+    return serialized;
+  }
+  return styles;
+}
 function GlobalStyles({
   styles,
   themeId,
   defaultTheme = {}
 }) {
   const upperTheme = useTheme(defaultTheme);
-  const globalStyles = typeof styles === "function" ? styles(themeId ? upperTheme[themeId] || upperTheme : upperTheme) : styles;
+  const resolvedTheme = themeId ? upperTheme[themeId] || upperTheme : upperTheme;
+  let globalStyles = typeof styles === "function" ? styles(resolvedTheme) : styles;
+  if (resolvedTheme.modularCssLayers) {
+    if (Array.isArray(globalStyles)) {
+      globalStyles = globalStyles.map((styleArg) => {
+        if (typeof styleArg === "function") {
+          return wrapGlobalLayer(styleArg(resolvedTheme));
+        }
+        return wrapGlobalLayer(styleArg);
+      });
+    } else {
+      globalStyles = wrapGlobalLayer(globalStyles);
+    }
+  }
   return /* @__PURE__ */ jsx(GlobalStyles$1, {
     styles: globalStyles
   });
 }
 process.env.NODE_ENV !== "production" ? GlobalStyles.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // |     To update them edit TypeScript types and run "yarn proptypes"  |
-  // ----------------------------------------------------------------------
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
   /**
    * @ignore
    */

package/dist/node_modules/@mui/system/esm/RtlProvider/index.js

@@ -0,0 +1,17 @@
+import "@babel/runtime/helpers/esm/extends";
+import "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import * as React from "react";
+import PropTypes from "../../../../prop-types/index.js";
+import "react/jsx-runtime";
+const RtlContext = /* @__PURE__ */ React.createContext();
+process.env.NODE_ENV !== "production" ? {
+  children: PropTypes.node,
+  value: PropTypes.bool
+} : void 0;
+const useRtl = () => {
+  const value = React.useContext(RtlContext);
+  return value != null ? value : false;
+};
+export {
+  useRtl
+};

package/dist/node_modules/@mui/system/esm/Stack/createStack.js

@@ -9,9 +9,9 @@ import { createUnarySpacing, getValue } from "../spacing.js";
 import { jsx } from "react/jsx-runtime";
 import extendSxProp from "../styleFunctionSx/extendSxProp.js";
 import useThemeProps from "../useThemeProps/useThemeProps.js";
-import deepmerge from "../../../utils/deepmerge/deepmerge.js";
-import composeClasses from "../../../utils/composeClasses/composeClasses.js";
-import generateUtilityClass from "../../../utils/generateUtilityClass/generateUtilityClass.js";
+import deepmerge from "../../node_modules/@mui/utils/esm/deepmerge/deepmerge.js";
+import composeClasses from "../../node_modules/@mui/utils/esm/composeClasses/composeClasses.js";
+import generateUtilityClass from "../../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js";
 import createTheme from "../createTheme/createTheme.js";
 const _excluded = ["component", "direction", "spacing", "divider", "children", "className", "useFlexGap"];
 const defaultTheme = createTheme();

package/dist/node_modules/@mui/system/esm/borders.js

@@ -9,51 +9,25 @@ function borderTransform(value) {
   }
   return `${value}px solid`;
 }
-const border = style({
-  prop: "border",
-  themeKey: "borders",
-  transform: borderTransform
-});
-const borderTop = style({
-  prop: "borderTop",
-  themeKey: "borders",
-  transform: borderTransform
-});
-const borderRight = style({
-  prop: "borderRight",
-  themeKey: "borders",
-  transform: borderTransform
-});
-const borderBottom = style({
-  prop: "borderBottom",
-  themeKey: "borders",
-  transform: borderTransform
-});
-const borderLeft = style({
-  prop: "borderLeft",
-  themeKey: "borders",
-  transform: borderTransform
-});
-const borderColor = style({
-  prop: "borderColor",
-  themeKey: "palette"
-});
-const borderTopColor = style({
-  prop: "borderTopColor",
-  themeKey: "palette"
-});
-const borderRightColor = style({
-  prop: "borderRightColor",
-  themeKey: "palette"
-});
-const borderBottomColor = style({
-  prop: "borderBottomColor",
-  themeKey: "palette"
-});
-const borderLeftColor = style({
-  prop: "borderLeftColor",
-  themeKey: "palette"
-});
+function createBorderStyle(prop, transform) {
+  return style({
+    prop,
+    themeKey: "borders",
+    transform
+  });
+}
+const border = createBorderStyle("border", borderTransform);
+const borderTop = createBorderStyle("borderTop", borderTransform);
+const borderRight = createBorderStyle("borderRight", borderTransform);
+const borderBottom = createBorderStyle("borderBottom", borderTransform);
+const borderLeft = createBorderStyle("borderLeft", borderTransform);
+const borderColor = createBorderStyle("borderColor");
+const borderTopColor = createBorderStyle("borderTopColor");
+const borderRightColor = createBorderStyle("borderRightColor");
+const borderBottomColor = createBorderStyle("borderBottomColor");
+const borderLeftColor = createBorderStyle("borderLeftColor");
+const outline = createBorderStyle("outline", borderTransform);
+const outlineColor = createBorderStyle("outlineColor");
 const borderRadius = (props) => {
   if (props.borderRadius !== void 0 && props.borderRadius !== null) {
     const transformer = createUnaryUnit(props.theme, "shape.borderRadius", 4, "borderRadius");
@@ -68,7 +42,7 @@ borderRadius.propTypes = process.env.NODE_ENV !== "production" ? {
   borderRadius: responsivePropType
 } : {};
 borderRadius.filterProps = ["borderRadius"];
-compose(border, borderTop, borderRight, borderBottom, borderLeft, borderColor, borderTopColor, borderRightColor, borderBottomColor, borderLeftColor, borderRadius);
+compose(border, borderTop, borderRight, borderBottom, borderLeft, borderColor, borderTopColor, borderRightColor, borderBottomColor, borderLeftColor, borderRadius, outline, outlineColor);
 export {
   border,
   borderBottom,
@@ -81,5 +55,7 @@ export {
   borderRightColor,
   borderTop,
   borderTopColor,
-  borderTransform
+  borderTransform,
+  outline,
+  outlineColor
 };

package/dist/node_modules/@mui/system/esm/breakpoints.js

@@ -1,5 +1,5 @@
 import "@babel/runtime/helpers/esm/extends";
-import deepmerge from "../../utils/deepmerge/deepmerge.js";
+import deepmerge from "../node_modules/@mui/utils/esm/deepmerge/deepmerge.js";
 const values = {
   xs: 0,
   // phone

package/dist/node_modules/@mui/system/esm/colorManipulator.js

@@ -1,11 +1,12 @@
-import formatMuiErrorMessage from "../../utils/formatMuiErrorMessage/formatMuiErrorMessage.js";
-function clamp(value, min = 0, max = 1) {
+import formatMuiErrorMessage from "../node_modules/@mui/utils/esm/formatMuiErrorMessage/formatMuiErrorMessage.js";
+import clamp from "../node_modules/@mui/utils/esm/clamp/clamp.js";
+function clampWrapper(value, min = 0, max = 1) {
   if (process.env.NODE_ENV !== "production") {
     if (value < min || value > max) {
       console.error(`MUI: The value provided ${value} is out of range [${min}, ${max}].`);
     }
   }
-  return Math.min(Math.max(min, value), max);
+  return clamp(value, min, max);
 }
 function hexToRgb(color) {
   color = color.slice(1);
@@ -74,46 +75,9 @@ function recomposeColor(color) {
   }
   return `${type}(${values})`;
 }
-function hslToRgb(color) {
-  color = decomposeColor(color);
-  const {
-    values
-  } = color;
-  const h = values[0];
-  const s = values[1] / 100;
-  const l = values[2] / 100;
-  const a = s * Math.min(l, 1 - l);
-  const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
-  let type = "rgb";
-  const rgb = [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255)];
-  if (color.type === "hsla") {
-    type += "a";
-    rgb.push(values[3]);
-  }
-  return recomposeColor({
-    type,
-    values: rgb
-  });
-}
-function getLuminance(color) {
-  color = decomposeColor(color);
-  let rgb = color.type === "hsl" || color.type === "hsla" ? decomposeColor(hslToRgb(color)).values : color.values;
-  rgb = rgb.map((val) => {
-    if (color.type !== "color") {
-      val /= 255;
-    }
-    return val <= 0.03928 ? val / 12.92 : ((val + 0.055) / 1.055) ** 2.4;
-  });
-  return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3));
-}
-function getContrastRatio(foreground, background) {
-  const lumA = getLuminance(foreground);
-  const lumB = getLuminance(background);
-  return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05);
-}
 function alpha(color, value) {
   color = decomposeColor(color);
-  value = clamp(value);
+  value = clampWrapper(value);
   if (color.type === "rgb" || color.type === "hsl") {
     color.type += "a";
   }
@@ -124,46 +88,9 @@ function alpha(color, value) {
   }
   return recomposeColor(color);
 }
-function darken(color, coefficient) {
-  color = decomposeColor(color);
-  coefficient = clamp(coefficient);
-  if (color.type.indexOf("hsl") !== -1) {
-    color.values[2] *= 1 - coefficient;
-  } else if (color.type.indexOf("rgb") !== -1 || color.type.indexOf("color") !== -1) {
-    for (let i = 0; i < 3; i += 1) {
-      color.values[i] *= 1 - coefficient;
-    }
-  }
-  return recomposeColor(color);
-}
-function lighten(color, coefficient) {
-  color = decomposeColor(color);
-  coefficient = clamp(coefficient);
-  if (color.type.indexOf("hsl") !== -1) {
-    color.values[2] += (100 - color.values[2]) * coefficient;
-  } else if (color.type.indexOf("rgb") !== -1) {
-    for (let i = 0; i < 3; i += 1) {
-      color.values[i] += (255 - color.values[i]) * coefficient;
-    }
-  } else if (color.type.indexOf("color") !== -1) {
-    for (let i = 0; i < 3; i += 1) {
-      color.values[i] += (1 - color.values[i]) * coefficient;
-    }
-  }
-  return recomposeColor(color);
-}
-function emphasize(color, coefficient = 0.15) {
-  return getLuminance(color) > 0.5 ? darken(color, coefficient) : lighten(color, coefficient);
-}
 export {
   alpha,
-  darken,
   decomposeColor,
-  emphasize,
-  getContrastRatio,
-  getLuminance,
   hexToRgb,
-  hslToRgb,
-  lighten,
   recomposeColor
 };