Éclairer ou obscurcir programmatiquement une couleur hexadécimale( ou RVB, et les couleurs de mélange)

TL;DR? -- voulez-vous un éclairage simple / assombri (ombrage)? Passez à la Version 2, choisissez celle pour RGB ou Hex. -- Vous voulez un shader/blender/converter complet avec errorcheck et alpha et hex à 3 chiffres? Utilisez la Version 3 près du fond.

Jouer avec la version 3.1: jsfiddle > shadeBlendConvert Exemple

Version 3.1 at GitHub: Goto Github > PJs > pSBC

---

après quelques réflexions... J'ai décidé de répondre à ma propre question. Un an et demi plus tard. Ce fut vraiment une aventure avec des idées de plusieurs utilisateurs serviables, et je vous remercie tous! Celui-ci est pour l'équipe! Bien que ce ne soit pas nécessairement la réponse que je cherchais. Parce que si ce que dit James Khoury est vrai, alors il n'y a pas de vrai hex math en javascript, je dois utiliser des décimales, cette double conversion est nécessaire. Si nous faisons cette hypothèse, alors c'est probablement la façon la plus rapide que j'ai vu (ou peut penser) pour éclairer (ajouter le blanc) ou assombrir (ajouter le noir) une couleur RBG arbitraire par pourcentage. Il explique également les questions acide frais mentionnés sur sa réponse à cette question (il pads 0s). Mais cette version appelle toString une seule fois. Cela tient aussi pour hors de portée (il va appliquer 0 et 255 comme limites).

mais attention, l'entrée de couleur doit être exactement 7 caractères, comme #08a35c . (ou 6 Si vous utilisez la version supérieure)

merci à Pablo pour l'inspiration et l'idée d'utiliser le pourcentage. Pour cela, je vais garder le nom de la fonction de même! lol! Cependant, celui-ci est différent, car il normalise le pourcentage à 255 et ajoute ainsi la même quantité à chaque couleur (plus de blanc). Si vous passez en 100 pour percent il rendra votre couleur blanc pur. Si vous passez à 0 pour percent , il ne se passera rien. Si vous passez à 1 pour percent il ajoutera 3 teintes pour toutes les couleurs (2,55 teintes pour 1%, arrondi). Donc votre vraiment passer dans un pourcentage de blanc (ou noir, utilisez négatif). Par conséquent, cette version vous permet d'alléger rouge pur (FF0000), par exemple.

j'ai aussi utilisé insight de la réponse de Keith Mashinter à cette question: comment convertir décimal en hex en JavaScript?

j'ai supprimé quelques parenthèses apparemment inutiles. (comme dans la double déclaration ternaire et dans crafting G) Je ne sais pas si cela va affecter la priorité de l'opérateur dans certains environnements. Testé bon dans FireFox.

function shadeColor1(color, percent) {  // deprecated. See below.
    var num = parseInt(color,16),
    amt = Math.round(2.55 * percent),
    R = (num >> 16) + amt,
    G = (num >> 8 & 0x00FF) + amt,
    B = (num & 0x0000FF) + amt;
    return (0x1000000 + (R<255?R<1?0:R:255)*0x10000 + (G<255?G<1?0:G:255)*0x100 + (B<255?B<1?0:B:255)).toString(16).slice(1);
}

Ou, si vous le souhaitez gérer le "#":

function shadeColor1(color, percent) {  // deprecated. See below.
    var num = parseInt(color.slice(1),16), amt = Math.round(2.55 * percent), R = (num >> 16) + amt, G = (num >> 8 & 0x00FF) + amt, B = (num & 0x0000FF) + amt;
    return "#" + (0x1000000 + (R<255?R<1?0:R:255)*0x10000 + (G<255?G<1?0:G:255)*0x100 + (B<255?B<1?0:B:255)).toString(16).slice(1);
}

comment ça pour deux lignes de code?

EDIT: Corrigé B<->G swap gaffe. Merci svachalek!

---

-- mise à jour-Version 2 avec mélange --

Un peu plus d'un an plus tard, à nouveau, et son toujours en cours. Mais cette fois je pense que sa fait. Notant les problèmes mentionnés sur le fait de ne pas utiliser HSL pour éclairer correctement la couleur. Il y a une technique qui élimine la plupart de cette inexactitude sans avoir à convertir en HSL. Le problème principal est qu'un canal de couleur sera complètement saturé avant le reste de la couleur. Provoquant un changement de teinte après ce point. J'ai trouvé ces questions ici , ici et ici qui m'a mis sur la bonne voie. Marque Rançon du post m'a montré la différence, et Keith post m'a montré le chemin. Lerp est le sauveur. C'est la même chose que le mélange des couleurs, donc j'ai créé une fonction blendColors aussi.

---

TL; DR - pour alléger/assombrir simple utiliser cette fonction shadeColor2 ci-dessous. Ou son homologue du RVB shadeRGBColor plus bas, et donnez-moi une voix. Mais, si vous voulez tout et/ou tous les goodies. Comme la possibilité d'utiliser les couleurs RGB et Hex, la vérification des erreurs, le décodage hex à 3 chiffres, le mélange, les canaux Alpha et les conversions Rgb2hex / Hex2RGB. Ensuite, passez à la Version 3 pour shadeBlendConvert pour obtenir toutes les cloches et sifflets et me donner deux votes. Vous pouvez ensuite supprimer quelques lignes à supprimer certains de ces éléments, si désiré. Et vous obtenez un vote si vous vous souvenez que La Version 1 shadeColor1 ci-dessus est dépréciée pour tous les usages.

---

Alors, sans plus tarder:

- Version 2 Hex -

function shadeColor2(color, percent) {   
    var f=parseInt(color.slice(1),16),t=percent<0?0:255,p=percent<0?percent*-1:percent,R=f>>16,G=f>>8&0x00FF,B=f&0x0000FF;
    return "#"+(0x1000000+(Math.round((t-R)*p)+R)*0x10000+(Math.round((t-G)*p)+G)*0x100+(Math.round((t-B)*p)+B)).toString(16).slice(1);
}

function blendColors(c0, c1, p) {
    var f=parseInt(c0.slice(1),16),t=parseInt(c1.slice(1),16),R1=f>>16,G1=f>>8&0x00FF,B1=f&0x0000FF,R2=t>>16,G2=t>>8&0x00FF,B2=t&0x0000FF;
    return "#"+(0x1000000+(Math.round((R2-R1)*p)+R1)*0x10000+(Math.round((G2-G1)*p)+G1)*0x100+(Math.round((B2-B1)*p)+B1)).toString(16).slice(1);
}

suite ado:

il n'y a pas de vérification d'erreur, de sorte que les valeurs qui sont passées en dehors de la plage causeront des résultats inattendus. De plus, l'entrée de couleur doit être exactement 7 caractères, comme #08a35c . Mais tous les autres goodies sont encore ici comme le capsulage de gamme de sortie (sorties 00-FF), le rembourrage (0A), les poignées # , et utilisable sur des couleurs solides, comme #FF0000 .

cette nouvelle version de shadeColor prend un float pour son second paramètre. Pour shadeColor2 , la plage valide pour le second paramètre (pourcentage) est -1.0 à 1.0 .

et pour blendColors la fourchette valide pour le troisième (pourcentage) le paramètre est 0.0 à 1.0 , négatifs, pas autorisés ici.

cette nouvelle version ne prend plus un pourcentage de blanc pur, comme l'ancienne version. C'est prendre un pourcentage de la DISTANCE de la couleur donnée au blanc pur. Dans l'ancienne version, il était facile de saturer la couleur, et en conséquence, de nombreuses couleurs computerait au blanc pur en utilisant un pourcentage appréciable. Cette nouvelle façon, il ne calcule blanc pur si vous passez dans 1.0 , ou noir pur, utilisez -1.0 .

appelant blendColors(color, "#FFFFFF", 0.5) est le même que shadeColor2(color,0.5) . Ainsi que, blendColors(color,"#000000", 0.5) est la même que shadeColor2(color,-0.5) . Juste un peu plus lentement.

shadeColor2 est plus lent que shadeColor1 , mais pas d'un montant notable. (Attendez, c'est une auto-contredire!)

la précision obtenue peut être vue ici:

-- Version 2 RGB --

function shadeRGBColor(color, percent) {
    var f=color.split(","),t=percent<0?0:255,p=percent<0?percent*-1:percent,R=parseInt(f[0].slice(4)),G=parseInt(f[1]),B=parseInt(f[2]);
    return "rgb("+(Math.round((t-R)*p)+R)+","+(Math.round((t-G)*p)+G)+","+(Math.round((t-B)*p)+B)+")";
}

function blendRGBColors(c0, c1, p) {
    var f=c0.split(","),t=c1.split(","),R=parseInt(f[0].slice(4)),G=parseInt(f[1]),B=parseInt(f[2]);
    return "rgb("+(Math.round((parseInt(t[0].slice(4))-R)*p)+R)+","+(Math.round((parseInt(t[1])-G)*p)+G)+","+(Math.round((parseInt(t[2])-B)*p)+B)+")";
}

Usages:

var color1 = "rbg(63,131,163)";
var lighterColor = shadeRGBColor(color1, 0.5);  //  rgb(159,193,209)
var darkerColor = shadeRGBColor(color1, -0.25); //  rgb(47,98,122)

var color2 = "rbg(244,128,0)";
var blend1 = blendRGBColors(color1, color2, 0.75);  //  rgb(199,129,41)
var blend2 = blendRGBColors(color2, color1, 0.62);  //  rgb(132,130,101)

-- Version 2 Universelle --

function shade(color, percent){
    if (color.length > 7 ) return shadeRGBColor(color,percent);
    else return shadeColor2(color,percent);
}

function blend(color1, color2, percent){
    if (color1.length > 7) return blendRGBColors(color1,color2,percent);
    else return blendColors(color1,color2,percent);
}

Utilisation:

var color1 = shade("rbg(63,131,163)", 0.5);
var color2 = shade("#3f83a3", 0.5);
var color3 = blend("rbg(63,131,163)", "rbg(244,128,0)", 0.5);
var color4 = blend("#3f83a3", "#f48000", 0.5);

-- Version 2 Universal B --

Ok, très bien! La popularité de cette réponse m'a fait penser que je pourrais faire une bien meilleure version universelle de cela. Si vous pouvez y aller! Cette version est une fonction tout-en-un copy/paste-able shader/blender pour les couleurs RGB et Hex. Celle-ci n'est pas vraiment différente de l'autre version Uni fournie ci-dessus. Sauf que c'est beaucoup plus petit et juste une fonction à coller et utiliser. Je pense que la taille est passée d'environ 1 592 caractères à 557 caractères, si vous la compressez en une ligne. bien sûr, si vous n'avez pas besoin de l'utiliser de façon interchangeable entre RGB et Hex, alors vous n'avez pas besoin D'un universel version comme cela de toute façon, lol. il suffit d'utiliser une des versions beaucoup plus petites et plus rapides ci-dessus; approprié pour votre arrangement de couleur. Aller de l'avant... À certains égards, il est un peu plus rapide, à certains égards, il est un peu plus lent. Je n'ai pas fait d'analyse finale de vitesse. Il y a deux différences d'utilisation: premièrement, le pourcentage est maintenant le premier paramètre de la fonction, au lieu du dernier. Deuxièmement, lorsque le mélange, vous pouvez utiliser des nombres négatifs. Ils vont juste être convertis en nombres positifs.

Sans plus tarder:

function shadeBlend(p,c0,c1) {
    var n=p<0?p*-1:p,u=Math.round,w=parseInt;
    if(c0.length>7){
        var f=c0.split(","),t=(c1?c1:p<0?"rgb(0,0,0)":"rgb(255,255,255)").split(","),R=w(f[0].slice(4)),G=w(f[1]),B=w(f[2]);
        return "rgb("+(u((w(t[0].slice(4))-R)*n)+R)+","+(u((w(t[1])-G)*n)+G)+","+(u((w(t[2])-B)*n)+B)+")"
    }else{
        var f=w(c0.slice(1),16),t=w((c1?c1:p<0?"#000000":"#FFFFFF").slice(1),16),R1=f>>16,G1=f>>8&0x00FF,B1=f&0x0000FF;
        return "#"+(0x1000000+(u(((t>>16)-R1)*n)+R1)*0x10000+(u(((t>>8&0x00FF)-G1)*n)+G1)*0x100+(u(((t&0x0000FF)-B1)*n)+B1)).toString(16).slice(1)
    }
}

Utilisation:

var color1 = "#FF343B";
var color2 = "#343BFF";
var color3 = "rgb(234,47,120)";
var color4 = "rgb(120,99,248)";
var shadedcolor1 = shadeBlend(0.75,color1);
var shadedcolor3 = shadeBlend(-0.5,color3);
var blendedcolor1 = shadeBlend(0.333,color1,color2);
var blendedcolor34 = shadeBlend(-0.8,color3,color4); // Same as using 0.8

Maintenant il pourrait être parfait! ;) @ Mevin

* V2 autres langues *

-- extension Swift-RGB (par Matej Ukmar) --

extension UIColor {
    func shadeColor(factor: CGFloat) -> UIColor {
        var r: CGFloat = 0
        var g: CGFloat = 0
        var b: CGFloat = 0
        var a: CGFloat = 0
        var t: CGFloat = factor < 0 ? 0 : 1
        var p: CGFloat = factor < 0 ? -factor : factor
        getRed(&r, green: &g, blue: &b, alpha: &a)
        r = (t-r)*p+r
        g = (t-g)*p+g
        b = (t-b)*p+b
        return UIColor(red: r, green: g, blue: b, alpha: a)
    }
}

-- version PHP-HEX (by Kevin M) --

function shadeColor2($color, $percent) {
    $color = str_replace("#", "", $color);
    $t=$percent<0?0:255;
    $p=$percent<0?$percent*-1:$percent;
    $RGB = str_split($color, 2);
    $R=hexdec($RGB[0]);
    $G=hexdec($RGB[1]);
    $B=hexdec($RGB[2]);
    return '#'.substr(dechex(0x1000000+(round(($t-$R)*$p)+$R)*0x10000+(round(($t-$G)*$p)+$G‌​)*0x100+(round(($t-$B)*$p)+$B)),1);
}

---

-- mise à JOUR -- Version 3.1 Universelle --

(ceci a été ajouté à ma bibliothèque à GitHub )

Dans quelques mois, il aura encore été une année depuis la dernière version universelle. Si... grâce à sricks commentaire perspicace. J'ai décidé de le prendre au prochain niveau, encore une fois. Ce n'est plus le démon de la vitesse à deux lignes comme il avait commencé, lol. Mais, pour ce qu'il fait, il est assez rapide et petit. C'est environ 1600 octets. Si vous supprimez ErrorChecking et supprimer le décodage à 3 chiffres, vous pouvez le faire descendre à environ 1200 octets et son plus rapide. C'est beaucoup de pouvoir sur un K. imaginez, vous pouvez charger ce sur un Commodore64 et encore de l'espace pour 50 de plus! (Sans tenir compte du fait que le moteur JavaScript est plus grand que 63k)

apparemment, il y avait plus à faire:

const shadeBlendConvert = function (p, from, to) {
    if(typeof(p)!="number"||p<-1||p>1||typeof(from)!="string"||(from[0]!='r'&&from[0]!='#')||(to&&typeof(to)!="string"))return null; //ErrorCheck
    if(!this.sbcRip)this.sbcRip=(d)=>{
        let l=d.length,RGB={};
        if(l>9){
            d=d.split(",");
            if(d.length<3||d.length>4)return null;//ErrorCheck
            RGB[0]=i(d[0].split("(")[1]),RGB[1]=i(d[1]),RGB[2]=i(d[2]),RGB[3]=d[3]?parseFloat(d[3]):-1;
        }else{
            if(l==8||l==6||l<4)return null; //ErrorCheck
            if(l<6)d="#"+d[1]+d[1]+d[2]+d[2]+d[3]+d[3]+(l>4?d[4]+""+d[4]:""); //3 or 4 digit
            d=i(d.slice(1),16),RGB[0]=d>>16&255,RGB[1]=d>>8&255,RGB[2]=d&255,RGB[3]=-1;
            if(l==9||l==5)RGB[3]=r((RGB[2]/255)*10000)/10000,RGB[2]=RGB[1],RGB[1]=RGB[0],RGB[0]=d>>24&255;
        }
    return RGB;}
    var i=parseInt,r=Math.round,h=from.length>9,h=typeof(to)=="string"?to.length>9?true:to=="c"?!h:false:h,b=p<0,p=b?p*-1:p,to=to&&to!="c"?to:b?"#000000":"#FFFFFF",f=this.sbcRip(from),t=this.sbcRip(to);
    if(!f||!t)return null; //ErrorCheck
    if(h)return "rgb"+(f[3]>-1||t[3]>-1?"a(":"(")+r((t[0]-f[0])*p+f[0])+","+r((t[1]-f[1])*p+f[1])+","+r((t[2]-f[2])*p+f[2])+(f[3]<0&&t[3]<0?")":","+(f[3]>-1&&t[3]>-1?r(((t[3]-f[3])*p+f[3])*10000)/10000:t[3]<0?f[3]:t[3])+")");
    else return "#"+(0x100000000+r((t[0]-f[0])*p+f[0])*0x1000000+r((t[1]-f[1])*p+f[1])*0x10000+r((t[2]-f[2])*p+f[2])*0x100+(f[3]>-1&&t[3]>-1?r(((t[3]-f[3])*p+f[3])*255):t[3]>-1?r(t[3]*255):f[3]>-1?r(f[3]*255):255)).toString(16).slice(1,f[3]>-1||t[3]>-1?undefined:-2);
}

Jouer avec la version 3.1: jsfiddle > shadeBlendConvert Exemple

le calcul de base de cette version est le même qu'avant. Mais, j'ai fait quelques modification majeure. Cela a permis une fonctionnalité et un contrôle beaucoup plus grands. Il convertit maintenant intrinsèquement RGB2Hex et Hex2RGB.

toutes les anciennes fonctionnalités de v2 ci-dessus devraient encore être ici. J'ai essayé de tester tout ça, merci de poster un commentaire si vous trouvez quelque chose de mal. Quoi qu'il en soit, voici les nouvelles fonctionnalités:

• Accepte les codes de couleur hexadécimaux à 3 chiffres (ou 4 chiffres), sous la forme #RGB (ou #ARGB). Elle permettra d'élargir. supprimer la ligne marquée de //3 digit pour supprimer cette caractéristique.
• accepte et mélange les canaux alpha. Si la couleur from ou la couleur to a un canal alpha, alors le résultat aura un canal alpha. Si les deux couleurs ont un canal alpha, le résultat sera un mélange des deux canaux alpha, en utilisant le pourcentage donné (comme si c'était normal d'un canal de couleur). Si une seule des deux couleurs a un canal alpha, cet alpha sera passé au résultat. Cela permet de mélanger/ombrager une couleur transparente tout en maintenant le transparent niveau. Ou, si le niveau transparent devrait se fondre aussi, assurez-vous que les deux couleurs ont des alphas. L'ombrage passera par le canal alpha, si vous voulez l'ombrage de base qui mélange également le canal alpha, puis utilisez rgb(0,0,0,1) ou rgb(255,255,255,1) comme votre couleur to (ou leurs équivalents hexadécimaux). Pour les couleurs RVB, le canal alpha sera arrondi à 4 décimales.
Les conversions
• RGB2Hex et Hex2RGB sont maintenant implicites lorsqu'on utilise le mélange. Le résultat couleur toujours être sous la forme de la couleur to , si on existe. S'il n'y a pas de couleur to , alors passer 'c' en tant que la couleur to et il va ombre et convertir. Si la conversion seulement est désirée, alors passer 0 comme le pourcentage aussi bien.
• Une fonction secondaire est ajouté au global. sbcRip peut passer une couleur hex ou rbg et renvoie un objet contenant cette information de couleur. Son sous la forme: {0:R,1:G,2:B,3:A} . Où R G et B ont une portée 0 à 255 . Et quand il n'y a pas d'alpha: A est -1 . Autrement: A a une portée 0.0000 à 1.0000 .
• la vérification des erreurs mineures a été ajoutée. Il n'est pas parfait. Il peut encore l'écrasement. Mais il attrapera des trucs. Fondamentalement, si la structure est erronée d'une certaine manière ou si le pourcentage n'est pas un nombre ou hors champ, il retournera null . Un exemple: shadeBlendConvert(0.5,"salt") = null , où comme il pense #salt est une couleur valide. supprimer les quatre lignes marquées //ErrorCheck pour supprimer cette caractéristique.

les Usages:

let color1 = "rgb(20,60,200)";
let color2 = "rgba(20,60,200,0.67423)";
let color3 = "#67DAF0";
let color4 = "#5567DAF0";
let color5 = "#F3A";
let color6 = "#F3A9";
let color7 = "rgb(200,60,20)";
let color8 = "rgba(200,60,20,0.98631)";
let c;

// Shade (Lighten or Darken)
c = shadeBlendConvert ( 0.42, color1 ); // rgb(20,60,200) + [42% Lighter] => rgb(119,142,223)
c = shadeBlendConvert ( -0.4, color5 ); // #F3A + [40% Darker] => #991f66
c = shadeBlendConvert ( 0.42, color8 ); // rgba(200,60,20,0.98631) + [42% Lighter] => rgba(223,142,119,0.98631)
// Shade with Conversion (use "c" as your "to" color)
c = shadeBlendConvert ( 0.42, color2, "c" ); // rgba(20,60,200,0.67423) + [42% Lighter] + [Convert] => #778edfac
// RGB2Hex & Hex2RGB Conversion Only (set percentage to zero)
c = shadeBlendConvert ( 0, color6, "c" ); // #F3A9 + [Convert] => rgba(255,51,170,0.6)
// Blending
c = shadeBlendConvert ( -0.5, color2, color8 ); // rgba(20,60,200,0.67423) + rgba(200,60,20,0.98631) + [50% Blend] => rgba(110,60,110,0.8303)
c = shadeBlendConvert ( 0.7, color2, color7 ); // rgba(20,60,200,0.67423) + rgb(200,60,20) + [70% Blend] => rgba(146,60,74,0.67423)
c = shadeBlendConvert ( 0.25, color3, color7 ); // #67DAF0 + rgb(200,60,20) + [25% Blend] => rgb(127,179,185)
c = shadeBlendConvert ( 0.75, color7, color3 ); // rgb(200,60,20) + #67DAF0 + [75% Blend] => #7fb3b9
// Error Checking
c = shadeBlendConvert ( 0.42, "#FFBAA" ); // #FFBAA + [42% Lighter] => null  (Invalid Input Color)
c = shadeBlendConvert ( 42, color1, color5 ); // rgb(20,60,200) + #F3A + [4200% Blend] => null  (Invalid Percentage Range)
c = shadeBlendConvert ( 0.42, {} ); // [object Object] + [42% Lighter] => null  (Strings Only for Color)
c = shadeBlendConvert ( "42", color1 ); // rgb(20,60,200) + ["42"] => null  (Numbers Only for Percentage)
c = shadeBlendConvert ( 0.42, "salt" ); // salt + [42% Lighter] => null  (A Little Salt is No Good...)
// Error Check Fails (Some Errors are not Caught)
c = shadeBlendConvert ( 0.42, "#salt" ); // #salt + [42% Lighter] => #6b6b6b00  (...and a Pound of Salt is Jibberish)
// Ripping
c = sbcRip ( color4 ); // #5567DAF0 + [Rip] => [object Object] => {'0':85,'1':103,'2':218,'3':0.9412}

j'hésite maintenant à dire que c'est fait... encore...

PT

--Modifier: a changé la version 3 pour utiliser let , et une fonction de flèche, et ajouté this à sbcRip appels.

----===<| MODIFICATION MAJEURE(3/9/18) |>===----

j'ai tellement honte! apparemment, je n'utilise pas les chaînes alpha dans mes propres projets... ET... apparemment, j'ai fait de terribles tests. La Version 3 n'a pas lu ni écrit les couleurs avec les canaux alpha correctement. Il y avait quelques points que je viens d'avoir faux ou n'a jamais réellement appris:

• Hex couleurs avec alpha #RGBA (pas #ARGB). La Version 3 lisait et écrivait à l'envers.
"15192360920 de couleurs RGB avec des alphas doit être rgba() et non pas rgb() ; la version 3 ne jamais sortie rgba() .
• Version 3 n'a pas accepté rgba() mais a accepté alphas dans rgb() , ce qui ne devrait pas se produire.

I tout à l'heure a remplacé la Version 3 par la Version 3.1 où ces questions sont abordées. Je ne l'ai pas posté comme une fonction séparée ici; vu que l'ancienne Version 3 devrait être supprimée de l'existence et remplacée par celle-ci. Et c'est ce que j'ai fait. La Version 3 ci-dessus est en fait la version 3.1.

toutes les anciennes fonctionnalités d'en haut sont toujours là avec ces mises à jour:

• se lit correctement et écrit des couleurs avec des canaux alpha. Les deux Hex et RGB.
• la couleur to accepte maintenant une couleur de chaîne ou une falsy (qui peut encore être undefined ).
• la fonction est maintenant constante.

... Je suis content d'avoir hésité à dire que c'était encore fait. Nous voici, une autre année ou deux plus tard ... encore le perfectionner...

PT