color-2-name 1.3.1 → 1.3.3

package/lib/browser/color-2-name.js

@@ -1,510 +1,802 @@
-"use strict";
-var color2name = (() => {
-  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);
+var color2name = (function (exports) {
+    'use strict';
 
-  // src/color-2-name.ts
-  var color_2_name_exports = {};
-  __export(color_2_name_exports, {
-    color2name: () => src_exports
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    closest: () => closest,
-    closestRGB: () => closestRGB,
-    distance: () => distance,
-    getColor: () => getColor,
-    getColors: () => getColors,
-    isDark: () => isDark,
-    isLight: () => isLight,
-    parseColor: () => parseColor,
-    rgbToHex: () => rgbToHex
-  });
-
-  // src/data/colorSet.ts
-  var colorSet = [
-    [255, 255, 255, "white"],
-    [0, 0, 0, "black"],
-    [255, 0, 0, "red"],
-    [0, 128, 0, "green"],
-    [0, 0, 255, "blue"],
-    [255, 165, 0, "orange"],
-    [128, 128, 128, "grey"],
-    [255, 255, 0, "yellow"],
-    [255, 0, 255, "magenta"],
-    [154, 205, 50, "yellowgreen"],
-    [192, 192, 192, "silver"],
-    [0, 255, 0, "lime"],
-    [128, 0, 128, "purple"],
-    [255, 99, 71, "tomato"],
-    [64, 224, 208, "turquoise"],
-    [255, 127, 80, "coral"],
-    [0, 255, 255, "cyan"],
-    [255, 250, 240, "floralwhite"],
-    [255, 192, 203, "pink"],
-    [34, 139, 34, "forestgreen"],
-    [245, 245, 220, "beige"],
-    [255, 0, 255, "fuchsia"],
-    [220, 220, 220, "gainsboro"],
-    [248, 248, 255, "ghostwhite"],
-    [255, 215, 0, "gold"],
-    [218, 165, 32, "goldenrod"],
-    [173, 255, 47, "greenyellow"],
-    [238, 130, 238, "violet"],
-    [245, 222, 179, "wheat"],
-    [245, 245, 245, "whitesmoke"],
-    [139, 0, 0, "darkred"],
-    [240, 248, 255, "aliceblue"],
-    [205, 92, 92, "indianred"],
-    [75, 0, 130, "indigo"],
-    [250, 235, 215, "antiquewhite"],
-    [0, 255, 255, "aqua"],
-    [127, 255, 212, "aquamarine"],
-    [240, 255, 255, "azure"],
-    [255, 228, 196, "bisque"],
-    [255, 235, 205, "blanchedalmond"],
-    [138, 43, 226, "blueviolet"],
-    [165, 42, 42, "brown"],
-    [222, 184, 135, "burlywood"],
-    [95, 158, 160, "cadetblue"],
-    [127, 255, 0, "chartreuse"],
-    [210, 105, 30, "chocolate"],
-    [100, 149, 237, "cornflowerblue"],
-    [255, 248, 220, "cornsilk"],
-    [220, 20, 60, "crimson"],
-    [0, 0, 139, "darkblue"],
-    [0, 139, 139, "darkcyan"],
-    [184, 134, 11, "darkgoldenrod"],
-    [169, 169, 169, "darkgrey"],
-    [0, 100, 0, "darkgreen"],
-    [189, 183, 107, "darkkhaki"],
-    [139, 0, 139, "darkmagenta"],
-    [85, 107, 47, "darkolivegreen"],
-    [255, 140, 0, "darkorange"],
-    [153, 50, 204, "darkorchid"],
-    [233, 150, 122, "darksalmon"],
-    [143, 188, 143, "darkseagreen"],
-    [72, 61, 139, "darkslateblue"],
-    [47, 79, 79, "darkslategrey"],
-    [0, 206, 209, "darkturquoise"],
-    [148, 0, 211, "darkviolet"],
-    [255, 20, 147, "deeppink"],
-    [0, 191, 255, "deepskyblue"],
-    [105, 105, 105, "dimgrey"],
-    [30, 144, 255, "dodgerblue"],
-    [178, 34, 34, "firebrick"],
-    [240, 255, 240, "honeydew"],
-    [255, 105, 180, "hotpink"],
-    [255, 255, 240, "ivory"],
-    [240, 230, 140, "khaki"],
-    [230, 230, 250, "lavender"],
-    [255, 240, 245, "lavenderblush"],
-    [124, 252, 0, "lawngreen"],
-    [255, 250, 205, "lemonchiffon"],
-    [173, 216, 230, "lightblue"],
-    [240, 128, 128, "lightcoral"],
-    [224, 255, 255, "lightcyan"],
-    [250, 250, 210, "lightgoldenrodyellow"],
-    [144, 238, 144, "lightgreen"],
-    [211, 211, 211, "lightgrey"],
-    [255, 182, 193, "lightpink"],
-    [255, 160, 122, "lightsalmon"],
-    [32, 178, 170, "lightseagreen"],
-    [135, 206, 250, "lightskyblue"],
-    [119, 136, 153, "lightslategrey"],
-    [176, 196, 222, "lightsteelblue"],
-    [255, 255, 224, "lightyellow"],
-    [50, 205, 50, "limegreen"],
-    [250, 240, 230, "linen"],
-    [128, 0, 0, "maroon"],
-    [102, 205, 170, "mediumaquamarine"],
-    [0, 0, 205, "mediumblue"],
-    [186, 85, 211, "mediumorchid"],
-    [147, 112, 219, "mediumpurple"],
-    [60, 179, 113, "mediumseagreen"],
-    [123, 104, 238, "mediumslateblue"],
-    [0, 250, 154, "mediumspringgreen"],
-    [72, 209, 204, "mediumturquoise"],
-    [199, 21, 133, "mediumvioletred"],
-    [25, 25, 112, "midnightblue"],
-    [245, 255, 250, "mintcream"],
-    [255, 228, 225, "mistyrose"],
-    [255, 228, 181, "moccasin"],
-    [255, 222, 173, "navajowhite"],
-    [0, 0, 128, "navy"],
-    [253, 245, 230, "oldlace"],
-    [128, 128, 0, "olive"],
-    [107, 142, 35, "olivedrab"],
-    [255, 69, 0, "orangered"],
-    [218, 112, 214, "orchid"],
-    [238, 232, 170, "palegoldenrod"],
-    [152, 251, 152, "palegreen"],
-    [175, 238, 238, "paleturquoise"],
-    [219, 112, 147, "palevioletred"],
-    [255, 239, 213, "papayawhip"],
-    [255, 218, 185, "peachpuff"],
-    [205, 133, 63, "peru"],
-    [221, 160, 221, "plum"],
-    [176, 224, 230, "powderblue"],
-    [102, 51, 153, "rebeccapurple"],
-    [188, 143, 143, "rosybrown"],
-    [65, 105, 225, "royalblue"],
-    [139, 69, 19, "saddlebrown"],
-    [250, 128, 114, "salmon"],
-    [244, 164, 96, "sandybrown"],
-    [46, 139, 87, "seagreen"],
-    [255, 245, 238, "seashell"],
-    [160, 82, 45, "sienna"],
-    [135, 206, 235, "skyblue"],
-    [106, 90, 205, "slateblue"],
-    [112, 128, 144, "slategrey"],
-    [255, 250, 250, "snow"],
-    [0, 255, 127, "springgreen"],
-    [70, 130, 180, "steelblue"],
-    [210, 180, 140, "tan"],
-    [0, 128, 128, "teal"],
-    [216, 191, 216, "thistle"]
-  ];
-  var colorSet_default = colorSet;
+    const colorSet = [
+        [255, 255, 255, "white"],
+        [0, 0, 0, "black"],
+        [255, 0, 0, "red"],
+        [0, 128, 0, "green"],
+        [0, 0, 255, "blue"],
+        [255, 165, 0, "orange"],
+        [128, 128, 128, "grey"],
+        [255, 255, 0, "yellow"],
+        [255, 0, 255, "magenta"],
+        [154, 205, 50, "yellowgreen"],
+        [192, 192, 192, "silver"],
+        [0, 255, 0, "lime"],
+        [128, 0, 128, "purple"],
+        [255, 99, 71, "tomato"],
+        [64, 224, 208, "turquoise"],
+        [255, 127, 80, "coral"],
+        [0, 255, 255, "cyan"],
+        [255, 250, 240, "floralwhite"],
+        [255, 192, 203, "pink"],
+        [34, 139, 34, "forestgreen"],
+        [245, 245, 220, "beige"],
+        [255, 0, 255, "fuchsia"],
+        [220, 220, 220, "gainsboro"],
+        [248, 248, 255, "ghostwhite"],
+        [255, 215, 0, "gold"],
+        [218, 165, 32, "goldenrod"],
+        [173, 255, 47, "greenyellow"],
+        [238, 130, 238, "violet"],
+        [245, 222, 179, "wheat"],
+        [245, 245, 245, "whitesmoke"],
+        [139, 0, 0, "darkred"],
+        [240, 248, 255, "aliceblue"],
+        [205, 92, 92, "indianred"],
+        [75, 0, 130, "indigo"],
+        [250, 235, 215, "antiquewhite"],
+        [0, 255, 255, "aqua"],
+        [127, 255, 212, "aquamarine"],
+        [240, 255, 255, "azure"],
+        [255, 228, 196, "bisque"],
+        [255, 235, 205, "blanchedalmond"],
+        [138, 43, 226, "blueviolet"],
+        [165, 42, 42, "brown"],
+        [222, 184, 135, "burlywood"],
+        [95, 158, 160, "cadetblue"],
+        [127, 255, 0, "chartreuse"],
+        [210, 105, 30, "chocolate"],
+        [100, 149, 237, "cornflowerblue"],
+        [255, 248, 220, "cornsilk"],
+        [220, 20, 60, "crimson"],
+        [0, 0, 139, "darkblue"],
+        [0, 139, 139, "darkcyan"],
+        [184, 134, 11, "darkgoldenrod"],
+        [169, 169, 169, "darkgrey"],
+        [0, 100, 0, "darkgreen"],
+        [189, 183, 107, "darkkhaki"],
+        [139, 0, 139, "darkmagenta"],
+        [85, 107, 47, "darkolivegreen"],
+        [255, 140, 0, "darkorange"],
+        [153, 50, 204, "darkorchid"],
+        [233, 150, 122, "darksalmon"],
+        [143, 188, 143, "darkseagreen"],
+        [72, 61, 139, "darkslateblue"],
+        [47, 79, 79, "darkslategrey"],
+        [0, 206, 209, "darkturquoise"],
+        [148, 0, 211, "darkviolet"],
+        [255, 20, 147, "deeppink"],
+        [0, 191, 255, "deepskyblue"],
+        [105, 105, 105, "dimgrey"],
+        [30, 144, 255, "dodgerblue"],
+        [178, 34, 34, "firebrick"],
+        [240, 255, 240, "honeydew"],
+        [255, 105, 180, "hotpink"],
+        [255, 255, 240, "ivory"],
+        [240, 230, 140, "khaki"],
+        [230, 230, 250, "lavender"],
+        [255, 240, 245, "lavenderblush"],
+        [124, 252, 0, "lawngreen"],
+        [255, 250, 205, "lemonchiffon"],
+        [173, 216, 230, "lightblue"],
+        [240, 128, 128, "lightcoral"],
+        [224, 255, 255, "lightcyan"],
+        [250, 250, 210, "lightgoldenrodyellow"],
+        [144, 238, 144, "lightgreen"],
+        [211, 211, 211, "lightgrey"],
+        [255, 182, 193, "lightpink"],
+        [255, 160, 122, "lightsalmon"],
+        [32, 178, 170, "lightseagreen"],
+        [135, 206, 250, "lightskyblue"],
+        [119, 136, 153, "lightslategrey"],
+        [176, 196, 222, "lightsteelblue"],
+        [255, 255, 224, "lightyellow"],
+        [50, 205, 50, "limegreen"],
+        [250, 240, 230, "linen"],
+        [128, 0, 0, "maroon"],
+        [102, 205, 170, "mediumaquamarine"],
+        [0, 0, 205, "mediumblue"],
+        [186, 85, 211, "mediumorchid"],
+        [147, 112, 219, "mediumpurple"],
+        [60, 179, 113, "mediumseagreen"],
+        [123, 104, 238, "mediumslateblue"],
+        [0, 250, 154, "mediumspringgreen"],
+        [72, 209, 204, "mediumturquoise"],
+        [199, 21, 133, "mediumvioletred"],
+        [25, 25, 112, "midnightblue"],
+        [245, 255, 250, "mintcream"],
+        [255, 228, 225, "mistyrose"],
+        [255, 228, 181, "moccasin"],
+        [255, 222, 173, "navajowhite"],
+        [0, 0, 128, "navy"],
+        [253, 245, 230, "oldlace"],
+        [128, 128, 0, "olive"],
+        [107, 142, 35, "olivedrab"],
+        [255, 69, 0, "orangered"],
+        [218, 112, 214, "orchid"],
+        [238, 232, 170, "palegoldenrod"],
+        [152, 251, 152, "palegreen"],
+        [175, 238, 238, "paleturquoise"],
+        [219, 112, 147, "palevioletred"],
+        [255, 239, 213, "papayawhip"],
+        [255, 218, 185, "peachpuff"],
+        [205, 133, 63, "peru"],
+        [221, 160, 221, "plum"],
+        [176, 224, 230, "powderblue"],
+        [102, 51, 153, "rebeccapurple"],
+        [188, 143, 143, "rosybrown"],
+        [65, 105, 225, "royalblue"],
+        [139, 69, 19, "saddlebrown"],
+        [250, 128, 114, "salmon"],
+        [244, 164, 96, "sandybrown"],
+        [46, 139, 87, "seagreen"],
+        [255, 245, 238, "seashell"],
+        [160, 82, 45, "sienna"],
+        [135, 206, 235, "skyblue"],
+        [106, 90, 205, "slateblue"],
+        [112, 128, 144, "slategrey"],
+        [255, 250, 250, "snow"],
+        [0, 255, 127, "springgreen"],
+        [70, 130, 180, "steelblue"],
+        [210, 180, 140, "tan"],
+        [0, 128, 128, "teal"],
+        [216, 191, 216, "thistle"],
+    ];
 
-  // src/common.ts
-  var hexRegex = /^#([\da-f]{3,8})/i;
-  var rgbRegex = /^rgba?\(([^)]+)\)/i;
-  var hslRegex = /^hsla?\(([^)]+)\)/i;
-  var isNumeric = /^-?\d*\.?\d+$/i;
-  var stripComments = /(\/\*[^*]*\*\/)|(\/\/[^*]*)/g;
-  var BLACKANDWHITE = [
-    [255, 255, 255, "white"],
-    [1, 1, 1, "black"]
-  ];
-  var RGBSET = [
-    [255, 0, 0, "red"],
-    [0, 255, 0, "green"],
-    [0, 0, 255, "blue"]
-  ];
-  function splitValues(rawValues) {
-    return rawValues.split(rawValues.includes(",") ? "," : " ").map((s) => s.trim());
-  }
-  function normalizeDegrees(angle) {
-    let degAngle = parseFloat(angle) || 0;
-    if (angle.indexOf("deg") > -1) {
-      degAngle = parseFloat(angle.substring(0, angle.length - 3));
-    } else if (angle.indexOf("rad") > -1) {
-      degAngle = Math.round(parseFloat(angle.substring(0, angle.length - 3)) * (180 / Math.PI));
-    } else if (angle.indexOf("turn") > -1) {
-      degAngle = Math.round(parseFloat(angle.substring(0, angle.length - 4)) * 360);
-    }
-    while (degAngle < 0) {
-      degAngle += 360;
-    }
-    if (degAngle >= 360)
-      degAngle %= 360;
-    return degAngle;
-  }
-  function limitValue(value, min = 0, max = 0) {
-    return Math.min(Math.max(Math.round(value), min), max);
-  }
-  function calculateValue(valueString, multiplier) {
-    const regex = /calc\(([^)]+)\)/;
-    const match = valueString.match(regex);
-    if (match) {
-      valueString = match[1];
-    }
-    return convertToInt8(valueString, multiplier);
-  }
-  function cleanDefinition(string) {
-    const cleanString = string.replace(stripComments, "");
-    const firstParenthesisIndex = cleanString.indexOf("(");
-    const lastParenthesisIndex = cleanString.lastIndexOf(")");
-    return cleanString.slice(firstParenthesisIndex + 1, lastParenthesisIndex).trim();
-  }
-  function normalizePercentage(value, multiplier) {
-    return parseFloat(value) / 100 * multiplier;
-  }
-  function colorValueFallbacks(value, err) {
-    if (value === "infinity") {
-      console.warn(err || `Positive infinity value has been set to 255: ${value}`);
-      return 255;
-    }
-    if (value === "currentColor")
-      console.warn(err || `The "currentColor" value has been set to 0: ${value}`);
-    if (value === "transparent")
-      console.warn(err || `The "transparent" value has been set to 0: ${value}`);
-    if (value === "NaN")
-      console.warn(err || `"NaN" value has been set to 0: ${value}`);
-    if (value === "-infinity")
-      console.warn(err || `"Negative" infinity value has been set to 0: ${value}`);
-    if (value === "none")
-      console.warn(err || `The none keyword is invalid in legacy color syntax: ${value}`);
-    return 0;
-  }
-  function convertToInt8(value, multiplier = 255) {
-    value = value ? value?.trim() : "0";
-    if (isNumeric.test(value)) {
-      return limitValue(parseFloat(value) || 0, 0, multiplier);
-    } else if (value.endsWith("%")) {
-      return normalizePercentage(value, multiplier) || 0;
-    } else if (value.endsWith("deg") || value.endsWith("rad") || value.endsWith("turn")) {
-      return normalizeDegrees(value);
-    } else if (value.startsWith("calc")) {
-      return limitValue(calculateValue(value, multiplier), 0, multiplier);
-    }
-    return colorValueFallbacks(value, `Invalid value: ${value}`);
-  }
+    /** The maximum distance possible between colors */
+    /** A regex to match hex colors */
+    const hexRegex = /^#([\da-f]{3,8})/i;
+    /** A regex to match rgb colors */
+    const rgbRegex = /^rgba?\(([^)]+)\)/i;
+    /** A regex to match hsl colors */
+    const hslRegex = /^hsla?\(([^)]+)\)/i;
+    /** A regex to match strings that are only valid numbers with and without decimals and the number can be negative and without the 0 in the beginning  */
+    const isNumeric = /^-?\d*\.?\d+$/i;
+    /** Remove comments from string */
+    const stripComments = /(\/\*[^*]*\*\/)|(\/\/[^*]*)/g;
+    /**
+     * This set is used to detect if the color is bright or dark
+     *
+     * @note the set has been corrected to get pure RGB values (eg. pure red, pure green) in the "bright" area
+     */
+    const BLACKANDWHITE = [
+        [255, 255, 255, "white"],
+        [1, 1, 1, "black"],
+    ];
+    /**
+     * This set is used to detect the nearest rgb color
+     */
+    const RGBSET = [
+        [255, 0, 0, "red"],
+        [0, 255, 0, "green"],
+        [0, 0, 255, "blue"],
+    ];
+    /**
+     * split the content of rgb and hsl colors depending on the parsed value of the css property
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/rgb#syntax
+     *
+     * @param {string} rawValues - the value inside the rgb(.*) css color definition
+     *
+     * @return {Array} the array of rgb values found inside the passed string
+     */
+    function splitValues(rawValues) {
+        return rawValues
+            .split(rawValues.includes(",") ? "," : " ")
+            .map((s) => s.trim());
+    }
+    /**
+     * If the value is an angle in degrees, convert it to the 0-360 range
+     *
+     * @param {string} angle - the degrees to convert into a number
+     *
+     * @return {number} the converted value
+     */
+    function normalizeDegrees(angle) {
+        // Strip label and convert to degrees (if necessary)
+        let degAngle = Number.parseFloat(angle) || 0;
+        if (angle.indexOf("deg") > -1) {
+            degAngle = Number.parseFloat(angle.substring(0, angle.length - 3));
+        }
+        else if (angle.indexOf("rad") > -1) {
+            degAngle = Math.round(Number.parseFloat(angle.substring(0, angle.length - 3)) * (180 / Math.PI));
+        }
+        else if (angle.indexOf("turn") > -1) {
+            degAngle = Math.round(Number.parseFloat(angle.substring(0, angle.length - 4)) * 360);
+        }
+        while (degAngle < 0) {
+            degAngle += 360;
+        }
+        // Make sure it's a number between 0 and 360
+        if (degAngle >= 360)
+            degAngle %= 360;
+        return degAngle;
+    }
+    /**
+     * Returns a value that is limited between a minimum and maximum value.
+     *
+     * @param {number} value - The value to be limited.
+     * @param {number} min - The minimum allowed value (default is 0).
+     * @param {number} max - The maximum allowed value (default is 0).
+     * @return {number} The limited value.
+     */
+    function limitValue(value, min = 0, max = 0) {
+        return Math.min(Math.max(Math.round(value), min), max);
+    }
+    /**
+     * Calculates the value based on a given string and multiplier.
+     *
+     * @param {string} valueString - The string representing the value to be calculated.
+     * @param {number} multiplier - The multiplier to be applied to the calculated value.
+     * @return {number} The calculated value.
+     */
+    function calculateValue(valueString, multiplier) {
+        // Regular expression to match the calc() function and extract the numerical value
+        const regex = /calc\(([^)]+)\)/;
+        // Match the calc() function in the CSS string
+        const match = valueString.match(regex);
+        return convertToInt8(match ? match[1] : valueString, multiplier);
+    }
+    /**
+     * Removes comments from the input string and extracts the content between the first opening parenthesis
+     * and the last closing parenthesis.
+     *
+     * @param {string} string - The input string.
+     * @return {string} The content between the first opening parenthesis and the last closing parenthesis.
+     */
+    function cleanDefinition(string) {
+        // Remove comments from the string
+        const cleanString = string.replace(stripComments, "");
+        // Find the positions of the first opening and the last closing parentheses
+        const firstParenthesisIndex = cleanString.indexOf("(");
+        const lastParenthesisIndex = cleanString.lastIndexOf(")");
+        // Extract the content between the parentheses
+        return cleanString
+            .slice(firstParenthesisIndex + 1, lastParenthesisIndex)
+            .trim();
+    }
+    /**
+     * Normalizes a percentage value by dividing it by 100 and multiplying it by a given multiplier.
+     *
+     * @param {string} value - The percentage value to be normalized.
+     * @param {number} multiplier - The number to multiply the normalized percentage by.
+     * @return {number} The normalized percentage value.
+     */
+    function normalizePercentage(value, multiplier) {
+        return (Number.parseFloat(value) / 100) * multiplier;
+    }
+    /**
+     * Calculates the color value fallbacks for a given value.
+     *
+     * @param {string} value - The color value to calculate fallbacks for.
+     * @param {string} [err] - An optional error message to display.
+     * @return {number} - The calculated color value fallbacks.
+     */
+    function colorValueFallbacks(value, err) {
+        if (value === "infinity") {
+            console.warn(err || `Positive infinity value has been set to 255: ${value}`);
+            return 255;
+        }
+        if (value === "currentColor")
+            console.warn(err || `The "currentColor" value has been set to 0: ${value}`);
+        if (value === "transparent")
+            console.warn(err || `The "transparent" value has been set to 0: ${value}`);
+        if (value === "NaN")
+            console.warn(err || `"NaN" value has been set to 0: ${value}`);
+        if (value === "-infinity")
+            console.warn(err || `"Negative" infinity value has been set to 0: ${value}`);
+        if (value === "none")
+            console.warn(err || `The none keyword is invalid in legacy color syntax: ${value}`);
+        return 0;
+    }
+    /**
+     * Takes a string with a css value that could be a number or percentage or an angle in degrees and returns the corresponding 8bit value
+     *
+     * @param value - a valid value for the css color definition (like 255, "100%", "324deg", etc.) *
+     * @param multiplier - the number that represent the maximum - default is 255 decimal - 100 hex
+     *
+     * @example convertToInt8('100%'); // 255
+     *
+     * @return {string} the corresponding value in 8-bit format
+     */
+    function convertToInt8(value, multiplier = 255) {
+        const newValue = typeof value === "string" ? value?.trim() : "0";
+        if (isNumeric.test(newValue)) {
+            // limit the min and the max newValue
+            return limitValue(Number.parseFloat(newValue) || 0, 0, multiplier);
+        }
+        if (newValue.endsWith("%")) {
+            // If the newValue is a percentage, divide it by 100 to get a newValue from 0 to 1
+            // and then multiply it by 255 to get a newValue from 0 to 255
+            return normalizePercentage(newValue, multiplier) || 0;
+        }
+        if (newValue.endsWith("deg") ||
+            newValue.endsWith("rad") ||
+            newValue.endsWith("turn")) {
+            return normalizeDegrees(newValue);
+        }
+        if (newValue.startsWith("calc")) {
+            // get the newValue from the calc function
+            return limitValue(calculateValue(newValue, multiplier), 0, multiplier);
+        }
+        // If the value is not a percentage or an angle in degrees, it is invalid
+        return colorValueFallbacks(newValue, `Invalid value: ${value}`);
+    }
 
-  // src/rgb-utils.ts
-  function fallbackRGB(rgb, err = `Invalid RGB color`) {
-    console.warn(err);
-    return [rgb[0] ?? 0, rgb[1] ?? 0, rgb[2]];
-  }
-  function parseRgb(rgbAsString) {
-    const rgbvalue = cleanDefinition(rgbAsString);
-    const rgb = splitValues(rgbvalue);
-    if (rgb.length !== 3 && rgb.length !== 4) {
-      return fallbackRGB(rgb, `Too few values to define rgb: ${rgbAsString} -> ${rgbvalue}`);
-    } else {
-      return [rgb[0], rgb[1], rgb[2]];
-    }
-  }
-  function getRgbValues(rgb) {
-    return {
-      r: limitValue(Math.round(convertToInt8(rgb[0])), 0, 255) || 0,
-      g: limitValue(Math.round(convertToInt8(rgb[1])), 0, 255) || 0,
-      b: limitValue(Math.round(convertToInt8(rgb[2])), 0, 255) || 0
-    };
-  }
-  function RGB(rgb) {
-    return `rgb(${rgb.r},${rgb.g},${rgb.b})`;
-  }
+    function fallbackRGB(rgb, err = "Invalid RGB color") {
+        console.warn(err);
+        return [rgb[0] ?? 0, rgb[1] ?? 0, rgb[2]];
+    }
+    /**
+     * Get the values of the rgb string
+     *
+     * @param rgbAsString - the rgb color as string split into values
+     *
+     * @return {Array} the values of the rgb string as Array of strings that represent the rgb color
+     */
+    function parseRgb(rgbAsString) {
+        const rgbvalue = cleanDefinition(rgbAsString);
+        const rgb = splitValues(rgbvalue);
+        if (rgb.length !== 3 && rgb.length !== 4) {
+            return fallbackRGB(rgb, `Too few values to define rgb: ${rgbAsString} -> ${rgbvalue}`);
+        }
+        return [rgb[0], rgb[1], rgb[2]];
+    }
+    /**
+     * This function takes an array of strings and returns and object with the rgb values converted into INT8 (0-255)
+     *
+     * @param {Array} rgb - rgb color as Array of strings
+     *
+     * @return {Object} an object that contains the r, g and b values as INT8
+     */
+    function getRgbValues(rgb) {
+        // use the channel key as the new array key
+        return {
+            r: limitValue(Math.round(convertToInt8(rgb[0])), 0, 255) || 0,
+            g: limitValue(Math.round(convertToInt8(rgb[1])), 0, 255) || 0,
+            b: limitValue(Math.round(convertToInt8(rgb[2])), 0, 255) || 0,
+        };
+    }
+    /**
+     * returns a string representation of the rgb values
+     *
+     * @param {Object} rgb the rgb color object
+     *
+     * @return {string} a string representation of the rgb values
+     */
+    function RGB(rgb) {
+        return `rgb(${rgb.r},${rgb.g},${rgb.b})`;
+    }
 
-  // src/hex-utils.ts
-  function shortHexToLongHex(value) {
-    return Array.from(value).map((v) => (v + v).toUpperCase());
-  }
-  function isHex(num) {
-    return Boolean(num.match(/^[0-9a-f]+$/i));
-  }
-  function parseHex(value) {
-    const hexColor = value.substring(1);
-    let hexArray = [];
-    if (hexColor) {
-      if (hexColor.length === 3 || hexColor.length === 4) {
-        hexArray = shortHexToLongHex(hexColor);
-      } else if (hexColor.length === 6 || hexColor.length === 8) {
-        hexArray = (hexColor.match(/../g) || []).map((value2) => value2);
-      }
-    }
-    if (hexArray.length) {
-      hexArray?.forEach((value2, index) => {
-        if (isHex(value2)) {
-          hexArray[index] = value2.toUpperCase();
-        } else {
-          console.warn(`Invalid Hex value: ${value2}`);
+    /**
+     * It returns an object with the hex values of the 3 digit hex color
+     *
+     * @param {string} value 3 digit hex
+     * @return {string[]} 6 digit hex
+     */
+    function shortHexToLongHex(value) {
+        // split the string in to an array of digits then return an array that contains that digit doubled for each item
+        return Array.from(value).map((v) => (v + v).toUpperCase());
+    }
+    /**
+     * Checks if a given string represents a hexadecimal number.
+     *
+     * @param {string} num - The string to be checked.
+     * @return {boolean} Returns true if the string is a valid hexadecimal number, false otherwise.
+     */
+    function isHex(num) {
+        return Boolean(num.match(/^[0-9a-f]+$/i));
+    }
+    /**
+     * Get the hex value of the color and convert it to an Object of R G And B values (still in hex format)
+     *
+     * @param value the string that contains the color in hex format
+     *
+     * @return {string[]} an array of 6 digit hex values in a triplet of R G and B (HEX format)
+     */
+    function parseHex(value) {
+        // remove # at the beginning of the hex color
+        const hexColor = value.substring(1);
+        /**
+         * then if the number of digits is greater than 2 (so it's something like 123 or abc456)
+         * breakdown the string into an object that contains the r g and b values in hex
+         */
+        let hexArray = [];
+        if (hexColor) {
+            if (hexColor.length === 3 || hexColor.length === 4) {
+                hexArray = shortHexToLongHex(hexColor);
+            }
+            else if (hexColor.length === 6 || hexColor.length === 8) {
+                // match the hex value in groups of 2
+                hexArray = (hexColor.match(/../g) || []).map((value) => value);
+            }
+        }
+        if (hexArray.length) {
+            hexArray?.forEach((value, index) => {
+                if (isHex(value)) {
+                    hexArray[index] = value.toUpperCase();
+                }
+                else {
+                    console.warn(`Invalid Hex value: ${value}`);
+                }
+            });
+            return hexArray;
         }
-      });
-      return hexArray;
-    }
-    console.warn(`Invalid Hex: ${value}`);
-    return fallbackRGB(hexArray);
-  }
-  function hexToRgb(hex) {
-    return {
-      r: parseInt(hex[0], 16),
-      g: parseInt(hex[1], 16),
-      b: parseInt(hex[2], 16)
-    };
-  }
-  function toHex(int8) {
-    return int8.toString(16).padStart(2, "0");
-  }
-  function valuesToHex(rgb) {
-    return `#${toHex(rgb?.r)}${toHex(rgb?.g)}${toHex(rgb?.b)}`;
-  }
+        console.warn(`Invalid Hex: ${value}`);
+        return fallbackRGB(hexArray);
+    }
+    /**
+     * Converts a Hex color to rgb
+     *
+     * @param {string} hex a tuple of hex values
+     *
+     * @return {string} the rgb color values for the given hex color
+     */
+    function hexToRgb(hex) {
+        // Extract the RGB values from the hex string
+        return {
+            r: Number.parseInt(hex[0], 16),
+            g: Number.parseInt(hex[1], 16),
+            b: Number.parseInt(hex[2], 16),
+        };
+    }
+    /**
+     * Convert a INT8 value to HEX
+     *
+     * @param {number} int8 - the integer value to convert
+     *
+     * @return {string} the hex string
+     */
+    function toHex(int8) {
+        return int8.toString(16).padStart(2, "0");
+    }
+    /**
+     * Convert rgb values to hex color
+     *
+     * @param {Object} rgb an object with the rgb values
+     *
+     * @return {string} the hex string
+     */
+    function valuesToHex(rgb) {
+        // Extract the RGB values from the hex string
+        return `#${toHex(rgb?.r)}${toHex(rgb?.g)}${toHex(rgb?.b)}`;
+    }
 
-  // src/hsl-utils.ts
-  function fallbackHSL(hsl, err = `Invalid HSL color`) {
-    console.warn(err);
-    return [hsl[0] ?? 0, hsl[1] ?? 0, hsl[2]];
-  }
-  function parseHsl(hslAsString) {
-    const hslvalue = cleanDefinition(hslAsString);
-    let hsl = splitValues(hslvalue);
-    if (hsl.length !== 3 && hsl.length !== 4) {
-      hsl = fallbackHSL(hsl);
-    }
-    return [hsl[0], hsl[1], hsl[2]];
-  }
-  var angleError = (value) => `Invalid angle: ${value} - The none keyword is invalid in legacy color syntax `;
-  function getHslValues(hsl) {
-    return {
-      h: colorValueFallbacks(hsl[0], angleError(hsl[0])) || Math.round(normalizeDegrees(hsl[0])) || 0,
-      s: colorValueFallbacks(hsl[1]) || convertToInt8(hsl[1], 100) || 0,
-      l: colorValueFallbacks(hsl[2]) || convertToInt8(hsl[2], 100) || 0
-    };
-  }
-  function getHue(c, x, h) {
-    if (h < 60)
-      return [c, x, 0];
-    if (h < 120)
-      return [x, c, 0];
-    if (h < 180)
-      return [0, c, x];
-    if (h < 240)
-      return [0, x, c];
-    if (h < 300)
-      return [x, 0, c];
-    return [c, 0, x];
-  }
-  function hslToRgb(hslColor) {
-    const hsl = getHslValues(hslColor), s = hsl.s / 100, l = hsl.l / 100;
-    const c = (1 - Math.abs(2 * l - 1)) * s;
-    const x = c * (1 - Math.abs(hsl.h / 60 % 2 - 1));
-    const m = l - c / 2;
-    let [r, g, b] = getHue(c, x, hsl.h);
-    r = Math.round((r + m) * 255);
-    g = Math.round((g + m) * 255);
-    b = Math.round((b + m) * 255);
-    return { r, g, b };
-  }
-  function valuesToHsl({ r, g, b }) {
-    r /= 255;
-    g /= 255;
-    b /= 255;
-    const cmin = Math.min(r, g, b);
-    const cmax = Math.max(r, g, b);
-    const delta = cmax - cmin;
-    let h = 0;
-    let s = 0;
-    let l = 0;
-    if (delta === 0) {
-      h = 0;
-    } else if (cmax === r) {
-      h = (g - b) / delta % 6;
-    } else if (cmax === g) {
-      h = (b - r) / delta + 2;
-    } else {
-      h = (r - g) / delta + 4;
-    }
-    h = Math.round(h * 60);
-    if (h < 0) {
-      h += 360;
-    }
-    l = (cmax + cmin) / 2;
-    s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
-    s = +(s * 100).toFixed(1);
-    l = +(l * 100).toFixed(1);
-    return HSL({ h, s, l });
-  }
-  function HSL(hsl) {
-    return `hsl(${hsl.h},${hsl.s}%,${hsl.l}%)`;
-  }
+    function fallbackHSL(hsl, err = "Invalid HSL color") {
+        console.warn(err);
+        return [hsl[0] ?? 0, hsl[1] ?? 0, hsl[2]];
+    }
+    /**
+     * Get the values of the hsl string
+     *
+     * @param {string} hslAsString - the valid hsl color string
+     * @return {string[]} the values of the hsl string
+     */
+    function parseHsl(hslAsString) {
+        const hslvalue = cleanDefinition(hslAsString);
+        let hsl = splitValues(hslvalue);
+        if (hsl.length !== 3 && hsl.length !== 4) {
+            hsl = fallbackHSL(hsl);
+        }
+        return [hsl[0], hsl[1], hsl[2]];
+    }
+    /**
+     * The error message for invalid angle
+     * @param value - the invalid angle
+     */
+    const angleError = (value) => `Invalid angle: ${value} - The none keyword is invalid in legacy color syntax `;
+    /**
+     * This function takes an array of strings and returns and object with the hsl values converted into INT8 (0-255)
+     *
+     * @param {string[]} hsl - the hsl values to parse from string to int8 values
+     *
+     */
+    function getHslValues(hsl) {
+        return {
+            h: colorValueFallbacks(hsl[0], angleError(hsl[0])) ||
+                Math.round(normalizeDegrees(hsl[0])) ||
+                0,
+            s: colorValueFallbacks(hsl[1]) || convertToInt8(hsl[1], 100) || 0,
+            l: colorValueFallbacks(hsl[2]) || convertToInt8(hsl[2], 100) || 0,
+        };
+    }
+    /**
+     * Takes the hsl values and returns the rgb values
+     * @param c chroma
+     * @param x X
+     * @param h Y
+     */
+    function getHue(c, x, h) {
+        if (h < 60)
+            return [c, x, 0];
+        if (h < 120)
+            return [x, c, 0];
+        if (h < 180)
+            return [0, c, x];
+        if (h < 240)
+            return [0, x, c];
+        if (h < 300)
+            return [x, 0, c];
+        return [c, 0, x];
+    }
+    /**
+     * Given the HSL color it convert the color into RGB
+     *
+     * @param {string[]} hslColor the HSL value to parse
+     * @return {Object} rgb value
+     */
+    function hslToRgb(hslColor) {
+        const hsl = getHslValues(hslColor);
+        const s = hsl.s / 100;
+        const l = hsl.l / 100;
+        const c = (1 - Math.abs(2 * l - 1)) * s;
+        const x = c * (1 - Math.abs(((hsl.h / 60) % 2) - 1));
+        const m = l - c / 2;
+        let [r, g, b] = getHue(c, x, hsl.h);
+        r = Math.round((r + m) * 255);
+        g = Math.round((g + m) * 255);
+        b = Math.round((b + m) * 255);
+        return { r, g, b };
+    }
+    /**
+     * Given the RGB color it convert the color into HSL
+     *
+     * @param {number} r - red
+     * @param {number} g - green
+     * @param {number} b - blue
+     *
+     * @return {Object} hsl value
+     */
+    function valuesToHsl({ r, g, b }) {
+        // Make r, g, and b fractions of 1
+        r /= 255;
+        g /= 255;
+        b /= 255;
+        // Find greatest and smallest channel values
+        const cmin = Math.min(r, g, b);
+        const cmax = Math.max(r, g, b);
+        const delta = cmax - cmin;
+        let h = 0;
+        let s = 0;
+        let l = 0;
+        // Calculate hue
+        if (delta === 0) {
+            // No difference
+            h = 0;
+        }
+        else if (cmax === r) {
+            // Red is max
+            h = ((g - b) / delta) % 6;
+        }
+        else if (cmax === g) {
+            // Green is max
+            h = (b - r) / delta + 2;
+        }
+        else {
+            h = (r - g) / delta + 4;
+        } // Blue is max
+        h = Math.round(h * 60);
+        // Make negative hues positive behind 360°
+        if (h < 0) {
+            h += 360;
+        }
+        // Calculate lightness
+        l = (cmax + cmin) / 2;
+        // Calculate saturation
+        s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+        // Multiply l and s by 100
+        s = +(s * 100).toFixed(1);
+        l = +(l * 100).toFixed(1);
+        return HSL({ h, s, l });
+    }
+    /**
+     * Converts an HSL color object to a string representation.
+     *
+     * @param {Object} hsl - Object containing the HSL color values.
+     * @param {number} hsl.h - The hue value of the color.
+     * @param {number} hsl.s - The saturation value of the color.
+     * @param {number} hsl.l - The lightness value of the color.
+     * @return {string} The HSL color as a string.
+     */
+    function HSL(hsl) {
+        return `hsl(${hsl.h},${hsl.s}%,${hsl.l}%)`;
+    }
 
-  // src/color-utils.ts
-  function getColor(searchedColor, set = colorSet_default) {
-    const found = set.find((color) => color[3] === searchedColor);
-    if (typeof found !== "undefined") {
-      const [r, g, b] = found;
-      return {
-        hex: valuesToHex({ r, g, b }),
-        rgb: RGB({ r, g, b }),
-        hsl: valuesToHsl({ r, g, b })
-      };
-    }
-    throw new Error(`Error: invalid color ${searchedColor} or empty colorSet`);
-  }
-  function getColors() {
-    const colors = colorSet_default.map((colorData) => {
-      const currentColor = {
-        name: colorData[3],
-        ...getColor(colorData[3])
-      };
-      return currentColor;
-    });
-    return colors;
-  }
+    /**
+     * This function was the opposite of the name of the repo and returns the color of the colorSet given the name
+     *
+     * @param {string} searchedColor -the name of the color to search for
+     * @param {Array} set - the colorSet to search in
+     */
+    function getColor(searchedColor, set = colorSet) {
+        const color = set.find((color) => color[3] === searchedColor);
+        if (typeof color !== "undefined") {
+            const [r, g, b] = color;
+            return {
+                hex: valuesToHex({ r, g, b }),
+                rgb: RGB({ r, g, b }),
+                hsl: valuesToHsl({ r, g, b }),
+            };
+        }
+        throw new Error(`Error: invalid color ${searchedColor} or empty colorSet`);
+    }
+    /**
+     * Get all the colors from the colorSet
+     */
+    function getColors() {
+        return colorSet.map((colorData) => {
+            return {
+                name: colorData[3],
+                ...getColor(colorData[3]),
+            };
+        });
+    }
 
-  // src/index.ts
-  function closest(color, set = colorSet_default, args) {
-    let closestGap = Number.MAX_SAFE_INTEGER;
-    const closestColor = { name: "error", color: "#F00" };
-    if (set.length < 1) {
-      return closestColor;
-    }
-    const rgbColorValues = Object.values(parseColor(color));
-    for (const tested of set) {
-      const gap = distance(rgbColorValues, tested, true);
-      if (gap < closestGap) {
-        closestGap = gap;
-        closestColor.name = tested[3];
-        closestColor.color = `rgb(${String(tested[0])},${String(tested[1])},${String(tested[2])})`;
-      }
-      if (gap === 0) {
-        break;
-      }
-    }
-    if (args?.info) {
-      const colorValue = getColor(closestColor.name, set);
-      return {
-        ...colorValue,
-        ...closestColor,
-        gap: Math.sqrt(closestGap)
-      };
-    }
-    return closestColor;
-  }
-  function isLight(color) {
-    return closest(color, BLACKANDWHITE).name === "white";
-  }
-  function isDark(color) {
-    return closest(color, BLACKANDWHITE).name === "black";
-  }
-  function closestRGB(color) {
-    return closest(color, RGBSET).name;
-  }
-  function distance(rgb1, rgb2, fast = false) {
-    const [rDiff, gDiff, bDiff] = [rgb2[0] - rgb1[0], rgb2[1] - rgb1[1], rgb2[2] - rgb1[2]];
-    const dist = rDiff * rDiff + gDiff * gDiff + bDiff * bDiff;
-    return fast ? dist : Math.sqrt(dist);
-  }
-  function rgbToHex(rgbString) {
-    if (rgbRegex.test(rgbString)) {
-      const rgb = parseRgb(rgbString);
-      const RgbValues = getRgbValues(rgb);
-      return valuesToHex(RgbValues);
-    }
-    throw new Error(`Invalid color: ${rgbString}`);
-  }
-  function parseColor(colorString) {
     const colorParsers = [
-      { regex: hexRegex, parser: parseHex, converter: hexToRgb },
-      { regex: rgbRegex, parser: parseRgb, converter: getRgbValues },
-      { regex: hslRegex, parser: parseHsl, converter: hslToRgb }
+        { regex: hexRegex, parser: parseHex, converter: hexToRgb },
+        { regex: rgbRegex, parser: parseRgb, converter: getRgbValues },
+        { regex: hslRegex, parser: parseHsl, converter: hslToRgb },
     ];
-    for (const { regex, parser, converter } of colorParsers) {
-      if (regex.test(colorString)) {
-        const result = parser(colorString);
-        return converter(result);
-      }
-    }
-    throw new Error(`Invalid color: ${colorString}`);
-  }
-  return __toCommonJS(color_2_name_exports);
-})();
-//# sourceMappingURL=color-2-name.js.map
+    /**
+     * Given a color string, it returns the closest corresponding name of the color.
+     * Uses the Euclidean distance formula to calculate the distance between colors in the RGB color space.
+     *
+     * @param {string} color - the color string you want to find the closest color name
+     * @param {Object} set - the color set that will be used to find the closest color
+     * @param {Object} args - Set a non nullish value to return some additional information (like the distance between the colors, or the hex color value)
+     * @param args.info - Set a non nullish value to return some additional information (like the distance between the colors, or the hex color value) about the closest color.
+     *
+     * @return {Object} the closest color name and rgb value
+     *
+     * @example // Returns the closest color name and rgb value given a css color string
+     * closest('#f00'); // { name: 'red', color: 'rgb(255,0,0)' }
+     *
+     * closest('#f00', undefined, {info:true}); // { name: 'red', color: 'rgb(255,0,0)', hex: '#ff0000', hsl: 'hsl(0, 100%, 50%)', distance: 0 ) }
+     */
+    function closest(color, set = colorSet, args) {
+        let closestGap = Number.MAX_SAFE_INTEGER;
+        const closestColor = { name: "error", color: "#F00" };
+        if (set.length < 1) {
+            return closestColor;
+        }
+        const rgbColorValues = Object.values(parseColor(color));
+        const colorSetLength = set.length;
+        // Precompute RGB values if needed
+        const precomputedRGBValues = set.map((item) => [item[0], item[1], item[2]]);
+        // Find the closest color in the color set
+        for (let i = 0; i < colorSetLength; i++) {
+            const tested = precomputedRGBValues[i];
+            const gap = distance(rgbColorValues, tested, true);
+            if (gap < closestGap) {
+                closestGap = gap;
+                closestColor.name = set[i][3];
+                closestColor.color = `rgb(${set[i][0]},${set[i][1]},${set[i][2]})`;
+            }
+            // Break if exact match found
+            if (gap === 0) {
+                break;
+            }
+        }
+        if (args?.info) {
+            const colorValue = getColor(closestColor.name, set);
+            return {
+                ...colorValue,
+                ...closestColor,
+                gap: Math.sqrt(closestGap),
+            };
+        }
+        return closestColor;
+    }
+    /**
+     * This function takes a string representing a color (color) and uses regular expressions to check if it matches any of the following formats: hex, hex+alpha, RGB, RGBA, HSL, or HSLA.
+     * If the color string matches one of these formats, the function returns an object with the type of color and the value of the color.
+     * If the color string does not match any of the formats, the function throws an error.
+     *
+     * @param {string} colorString - the color string to test and convert to rgb values
+     *
+     * @return {Object|Error} the object with rgb values of that color
+     */
+    function parseColor(colorString) {
+        for (const { regex, parser, converter } of colorParsers) {
+            if (regex.test(colorString)) {
+                const result = parser(colorString);
+                return converter(result);
+            }
+        }
+        // If the color string does not match any of the regular expressions, return an error
+        throw new Error(`Invalid color: ${colorString}`);
+    }
+    /**
+     * Given a color returns if the color is light (by light is meant more mathematically closer to white)
+     *
+     * @param {string} color - The color to check
+     *
+     * @returns {boolean} true when the color is light, false otherwise
+     *
+     * @example isLight('#ddd'); // true
+     */
+    function isLight(color) {
+        return closest(color, BLACKANDWHITE).name === "white";
+    }
+    /**
+     * Given a color returns if the color is dark (by dark is meant more mathematically closer to black)
+     *
+     * @param {string} color - The color to check
+     *
+     * @returns {boolean} true when the color is dark, false otherwise
+     *
+     * @example isDark('#333'); // true
+     */
+    function isDark(color) {
+        return closest(color, BLACKANDWHITE).name === "black";
+    }
+    /**
+     * Given a color returns if the color is closer to "red", "green" or "blue".
+     *
+     * @param {string} color - The color to check
+     *
+     * @returns {string} light when the color is close to white, dark otherwise
+     *
+     * @example closestRGB('#f00'); // 'red'
+     */
+    function closestRGB(color) {
+        return closest(color, RGBSET).name;
+    }
+    /**
+     * Compute the distance between the two RGB values
+     * There are two modes:
+     * fast = true -> the distance is calculated without using the Euclidean formula completely, it is reliable but its result is exponential
+     * fast = false -> the distance is calculated with the Euclidean formula, its result is linear
+     *
+     * @param rgb1 - The RGB value of the first color to compare
+     * @param rgb2 - The RGB value of the second color to compare
+     * @param fast - If you want to calculate the distance without calculating the square root, the result will be exponential otherwise is linear
+     *
+     * @return {number} the distance between the two RGB values
+     *
+     * @example distance([10, 20, 30], [120, 120, 120]); // 173.78147196982766
+     */
+    function distance(rgb1, rgb2, fast = false) {
+        const [rDiff, gDiff, bDiff] = [
+            rgb2[0] - rgb1[0],
+            rgb2[1] - rgb1[1],
+            rgb2[2] - rgb1[2],
+        ];
+        const dist = rDiff * rDiff + gDiff * gDiff + bDiff * bDiff;
+        return fast ? dist : Math.sqrt(dist);
+    }
+    /**
+     * Given a color string it returns the hex representation
+     *
+     * @param rgbString - the rgb color string to convert to hex
+     *
+     * @return {string} the corresponding color hex
+     *
+     * @example rgbToHex("rgba(100% 0 0 / .5)"); // #FF0000
+     */
+    function rgbToHex(rgbString) {
+        // if is a rgb string
+        if (rgbRegex.test(rgbString)) {
+            const rgb = parseRgb(rgbString);
+            const RgbValues = getRgbValues(rgb);
+            return valuesToHex(RgbValues);
+        }
+        throw new Error(`Invalid color: ${rgbString}`);
+    }
+
+    exports.closest = closest;
+    exports.closestRGB = closestRGB;
+    exports.colorParsers = colorParsers;
+    exports.distance = distance;
+    exports.getColor = getColor;
+    exports.getColors = getColors;
+    exports.isDark = isDark;
+    exports.isLight = isLight;
+    exports.parseColor = parseColor;
+    exports.rgbToHex = rgbToHex;
+
+    return exports;
+
+})({});