text: /**
   * Returns a number whose value is limited to the given range.
   *
   * @param {number} value The value to be clamped
   * @param {number} min The lower boundary of the output range
   * @param {number} max The upper boundary of the output range
   * @returns {number} A number in the range [min, max]
   */
  export const clamp = (value) => {
      var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
      var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    
      if (process.env.NODE_ENV !== 'production') {
        if (value < min || value > max) {
          console.error("Material-UI: the value provided ".concat(value, " is out of range [").concat(min, ", ").concat(max, "]."));
        }
      }
    
      return Math.min(Math.max(min, value), max);
    }
    /**
     * Converts a color from CSS hex format to CSS rgb format.
     *
     * @param {string} color - Hex color, i.e. #nnn or #nnnnnn
     * @returns {string} A CSS rgb color string
     */
    
    
    export const hexToRgb = (color) => {
      color = color.substr(1);
      var re = new RegExp(".{1,".concat(color.length / 3, "}"), 'g');
      var colors = color.match(re);
    
      if (colors && colors[0].length === 1) {
        colors = colors.map(function (n) {
          return n + n;
        });
      }
    
      return colors ? "rgb(".concat(colors.map(function (n) {
        return parseInt(n, 16);
      }).join(', '), ")") : '';
    }
    
    export const intToHex = (int) => {
      var hex = int.toString(16);
      return hex.length === 1 ? "0".concat(hex) : hex;
    }
    /**
     * Converts a color from CSS rgb format to CSS hex format.
     *
     * @param {string} color - RGB color, i.e. rgb(n, n, n)
     * @returns {string} A CSS rgb color string, i.e. #nnnnnn
     */
    
    
    export const rgbToHex = (color) => {
      // Idempotent
      if (color.indexOf('#') === 0) {
        return color;
      }
    
      var _decomposeColor = decomposeColor(color),
          values = _decomposeColor.values;
    
      return "#".concat(values.map(function (n) {
        return intToHex(n);
      }).join(''));
    }
    /**
     * Converts a color from hsl format to rgb format.
     *
     * @param {string} color - HSL color values
     * @returns {string} rgb color values
     */
    
    
    export const hslToRgb = (color) => {
      color = decomposeColor(color);
      var _color = color,
          values = _color.values;
      var h = values[0];
      var s = values[1] / 100;
      var l = values[2] / 100;
      var a = s * Math.min(l, 1 - l);
    
      var f = function f(n) {
        var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 30) % 12;
        return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
      };
    
      var type = 'rgb';
      var 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: type,
        values: rgb
      });
    }
    /**
     * Returns an object with the type and values of a color.
     *
     * Note: Does not support rgb % values.
     *
     * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @returns {object} - A MUI color object: {type: string, values: number[]}
     */
    
    
    export const decomposeColor = (color) => {
      // Idempotent
      if (color.type) {
        return color;
      }
    
      if (color.charAt(0) === '#') {
        return decomposeColor(hexToRgb(color));
      }
    
      var marker = color.indexOf('(');
      var type = color.substring(0, marker);
    
      if (['rgb', 'rgba', 'hsl', 'hsla'].indexOf(type) === -1) {
        throw new Error(["Material-UI: unsupported `".concat(color, "` color."), 'We support the following formats: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla().'].join('\n'));
      }
    
      var values = color.substring(marker + 1, color.length - 1).split(',');
      values = values.map(function (value) {
        return parseFloat(value);
      });
      return {
        type: type,
        values: values
      };
    }
    /**
     * Converts a color object with type and values to a string.
     *
     * @param {object} color - Decomposed color
     * @param {string} color.type - One of: 'rgb', 'rgba', 'hsl', 'hsla'
     * @param {array} color.values - [n,n,n] or [n,n,n,n]
     * @returns {string} A CSS color string
     */
    
    
    export const recomposeColor = (color) => {
      var type = color.type;
      var values = color.values;
    
      if (type.indexOf('rgb') !== -1) {
        // Only convert the first 3 values to int (i.e. not alpha)
        values = values.map(function (n, i) {
          return i < 3 ? parseInt(n, 10) : n;
        });
      } else if (type.indexOf('hsl') !== -1) {
        values[1] = "".concat(values[1], "%");
        values[2] = "".concat(values[2], "%");
      }
    
      return "".concat(type, "(").concat(values.join(', '), ")");
    }
    /**
     * Calculates the contrast ratio between two colors.
     *
     * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
     *
     * @param {string} foreground - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @param {string} background - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @returns {number} A contrast ratio value in the range 0 - 21.
     */
    
    
    export const getContrastRatio = (foreground, background) => {
      var lumA = getLuminance(foreground);
      var lumB = getLuminance(background);
      return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05);
    }
    /**
     * The relative brightness of any point in a color space,
     * normalized to 0 for darkest black and 1 for lightest white.
     *
     * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
     *
     * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @returns {number} The relative brightness of the color in the range 0 - 1
     */
    
    
    export const getLuminance = (color) => {
      color = decomposeColor(color);
      var rgb = color.type === 'hsl' ? decomposeColor(hslToRgb(color)).values : color.values;
      rgb = rgb.map(function (val) {
        val /= 255; // normalized
    
        return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
      }); // Truncate at 3 digits
    
      return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3));
    }
    /**
     * Darken or lighten a color, depending on its luminance.
     * Light colors are darkened, dark colors are lightened.
     *
     * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @param {number} coefficient=0.15 - multiplier in the range 0 - 1
     * @returns {string} A CSS color string. Hex input values are returned as rgb
     */
    
    
    export const emphasize = (color) => {
      var coefficient = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.15;
      return getLuminance(color) > 0.5 ? darken(color, coefficient) : lighten(color, coefficient);
    }
    /**
     * Set the absolute transparency of a color.
     * Any existing alpha values are overwritten.
     *
     * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @param {number} value - value to set the alpha channel to in the range 0 -1
     * @returns {string} A CSS color string. Hex input values are returned as rgb
     */
    
    
    export const fade = (color, value) => {
      color = decomposeColor(color);
      value = clamp(value);
    
      if (color.type === 'rgb' || color.type === 'hsl') {
        color.type += 'a';
      }
    
      color.values[3] = value;
      return recomposeColor(color);
    }
    /**
     * Darkens a color.
     *
     * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @param {number} coefficient - multiplier in the range 0 - 1
     * @returns {string} A CSS color string. Hex input values are returned as rgb
     */
    
    
    export const 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) {
        for (var i = 0; i < 3; i += 1) {
          color.values[i] *= 1 - coefficient;
        }
      }
    
      return recomposeColor(color);
    }
    /**
     * Lightens a color.
     *
     * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
     * @param {number} coefficient - multiplier in the range 0 - 1
     * @returns {string} A CSS color string. Hex input values are returned as rgb
     */
    
    
    export const 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 (var i = 0; i < 3; i += 1) {
          color.values[i] += (255 - color.values[i]) * coefficient;
        }
      }
    
      return recomposeColor(color);
    }