1	/*!
2	 * jQuery Color Animations v2.1.0
3	 * http://jquery.com/
4	 *
5	 * Copyright 2012 jQuery Foundation and other contributors
6	 * Released under the MIT license.
7	 * http://jquery.org/license
8	 *
9	 * Date: Fri Aug 24 12:02:24 2012 -0500
10	 */
11	(function( jQuery, undefined ) {
12	
13	        var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
14	
15	        // plusequals test for += 100 -= 100
16	        rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
17	        // a set of RE's that can match strings and generate color tuples.
18	        stringParsers = [{
19	                        re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
20	                        parse: function( execResult ) {
21	                                return [
22	                                        execResult[ 1 ],
23	                                        execResult[ 2 ],
24	                                        execResult[ 3 ],
25	                                        execResult[ 4 ]
26	                                ];
27	                        }
28	                }, {
29	                        re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
30	                        parse: function( execResult ) {
31	                                return [
32	                                        execResult[ 1 ] * 2.55,
33	                                        execResult[ 2 ] * 2.55,
34	                                        execResult[ 3 ] * 2.55,
35	                                        execResult[ 4 ]
36	                                ];
37	                        }
38	                }, {
39	                        // this regex ignores A-F because it's compared against an already lowercased string
40	                        re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
41	                        parse: function( execResult ) {
42	                                return [
43	                                        parseInt( execResult[ 1 ], 16 ),
44	                                        parseInt( execResult[ 2 ], 16 ),
45	                                        parseInt( execResult[ 3 ], 16 )
46	                                ];
47	                        }
48	                }, {
49	                        // this regex ignores A-F because it's compared against an already lowercased string
50	                        re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
51	                        parse: function( execResult ) {
52	                                return [
53	                                        parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
54	                                        parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
55	                                        parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
56	                                ];
57	                        }
58	                }, {
59	                        re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,
60	                        space: "hsla",
61	                        parse: function( execResult ) {
62	                                return [
63	                                        execResult[ 1 ],
64	                                        execResult[ 2 ] / 100,
65	                                        execResult[ 3 ] / 100,
66	                                        execResult[ 4 ]
67	                                ];
68	                        }
69	                }],
70	
71	        // jQuery.Color( )
72	        color = jQuery.Color = function( color, green, blue, alpha ) {
73	                return new jQuery.Color.fn.parse( color, green, blue, alpha );
74	        },
75	        spaces = {
76	                rgba: {
77	                        props: {
78	                                red: {
79	                                        idx: 0,
80	                                        type: "byte"
81	                                },
82	                                green: {
83	                                        idx: 1,
84	                                        type: "byte"
85	                                },
86	                                blue: {
87	                                        idx: 2,
88	                                        type: "byte"
89	                                }
90	                        }
91	                },
92	
93	                hsla: {
94	                        props: {
95	                                hue: {
96	                                        idx: 0,
97	                                        type: "degrees"
98	                                },
99	                                saturation: {
100	                                        idx: 1,
101	                                        type: "percent"
102	                                },
103	                                lightness: {
104	                                        idx: 2,
105	                                        type: "percent"
106	                                }
107	                        }
108	                }
109	        },
110	        propTypes = {
111	                "byte": {
112	                        floor: true,
113	                        max: 255
114	                },
115	                "percent": {
116	                        max: 1
117	                },
118	                "degrees": {
119	                        mod: 360,
120	                        floor: true
121	                }
122	        },
123	        support = color.support = {},
124	
125	        // element for support tests
126	        supportElem = jQuery( "<p>" )[ 0 ],
127	
128	        // colors = jQuery.Color.names
129	        colors,
130	
131	        // local aliases of functions called often
132	        each = jQuery.each;
133	
134	// determine rgba support immediately
135	supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
136	support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
137	
138	// define cache name and alpha properties
139	// for rgba and hsla spaces
140	each( spaces, function( spaceName, space ) {
141	        space.cache = "_" + spaceName;
142	        space.props.alpha = {
143	                idx: 3,
144	                type: "percent",
145	                def: 1
146	        };
147	});
148	
149	function clamp( value, prop, allowEmpty ) {
150	        var type = propTypes[ prop.type ] || {};
151	
152	        if ( value == null ) {
153	                return (allowEmpty || !prop.def) ? null : prop.def;
154	        }
155	
156	        // ~~ is an short way of doing floor for positive numbers
157	        value = type.floor ? ~~value : parseFloat( value );
158	
159	        // IE will pass in empty strings as value for alpha,
160	        // which will hit this case
161	        if ( isNaN( value ) ) {
162	                return prop.def;
163	        }
164	
165	        if ( type.mod ) {
166	                // we add mod before modding to make sure that negatives values
167	                // get converted properly: -10 -> 350
168	                return (value + type.mod) % type.mod;
169	        }
170	
171	        // for now all property types without mod have min and max
172	        return 0 > value ? 0 : type.max < value ? type.max : value;
173	}
174	
175	function stringParse( string ) {
176	        var inst = color(),
177	                rgba = inst._rgba = [];
178	
179	        string = string.toLowerCase();
180	
181	        each( stringParsers, function( i, parser ) {
182	                var parsed,
183	                        match = parser.re.exec( string ),
184	                        values = match && parser.parse( match ),
185	                        spaceName = parser.space || "rgba";
186	
187	                if ( values ) {
188	                        parsed = inst[ spaceName ]( values );
189	
190	                        // if this was an rgba parse the assignment might happen twice
191	                        // oh well....
192	                        inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
193	                        rgba = inst._rgba = parsed._rgba;
194	
195	                        // exit each( stringParsers ) here because we matched
196	                        return false;
197	                }
198	        });
199	
200	        // Found a stringParser that handled it
201	        if ( rgba.length ) {
202	
203	                // if this came from a parsed string, force "transparent" when alpha is 0
204	                // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
205	                if ( rgba.join() === "0,0,0,0" ) {
206	                        jQuery.extend( rgba, colors.transparent );
207	                }
208	                return inst;
209	        }
210	
211	        // named colors
212	        return colors[ string ];
213	}
214	
215	color.fn = jQuery.extend( color.prototype, {
216	        parse: function( red, green, blue, alpha ) {
217	                if ( red === undefined ) {
218	                        this._rgba = [ null, null, null, null ];
219	                        return this;
220	                }
221	                if ( red.jquery || red.nodeType ) {
222	                        red = jQuery( red ).css( green );
223	                        green = undefined;
224	                }
225	
226	                var inst = this,
227	                        type = jQuery.type( red ),
228	                        rgba = this._rgba = [],
229	                        source;
230	
231	                // more than 1 argument specified - assume ( red, green, blue, alpha )
232	                if ( green !== undefined ) {
233	                        red = [ red, green, blue, alpha ];
234	                        type = "array";
235	                }
236	
237	                if ( type === "string" ) {
238	                        return this.parse( stringParse( red ) || colors._default );
239	                }
240	
241	                if ( type === "array" ) {
242	                        each( spaces.rgba.props, function( key, prop ) {
243	                                rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
244	                        });
245	                        return this;
246	                }
247	
248	                if ( type === "object" ) {
249	                        if ( red instanceof color ) {
250	                                each( spaces, function( spaceName, space ) {
251	                                        if ( red[ space.cache ] ) {
252	                                                inst[ space.cache ] = red[ space.cache ].slice();
253	                                        }
254	                                });
255	                        } else {
256	                                each( spaces, function( spaceName, space ) {
257	                                        var cache = space.cache;
258	                                        each( space.props, function( key, prop ) {
259	
260	                                                // if the cache doesn't exist, and we know how to convert
261	                                                if ( !inst[ cache ] && space.to ) {
262	
263	                                                        // if the value was null, we don't need to copy it
264	                                                        // if the key was alpha, we don't need to copy it either
265	                                                        if ( key === "alpha" || red[ key ] == null ) {
266	                                                                return;
267	                                                        }
268	                                                        inst[ cache ] = space.to( inst._rgba );
269	                                                }
270	
271	                                                // this is the only case where we allow nulls for ALL properties.
272	                                                // call clamp with alwaysAllowEmpty
273	                                                inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
274	                                        });
275	
276	                                        // everything defined but alpha?
277	                                        if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
278	                                                // use the default of 1
279	                                                inst[ cache ][ 3 ] = 1;
280	                                                if ( space.from ) {
281	                                                        inst._rgba = space.from( inst[ cache ] );
282	                                                }
283	                                        }
284	                                });
285	                        }
286	                        return this;
287	                }
288	        },
289	        is: function( compare ) {
290	                var is = color( compare ),
291	                        same = true,
292	                        inst = this;
293	
294	                each( spaces, function( _, space ) {
295	                        var localCache,
296	                                isCache = is[ space.cache ];
297	                        if (isCache) {
298	                                localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
299	                                each( space.props, function( _, prop ) {
300	                                        if ( isCache[ prop.idx ] != null ) {
301	                                                same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
302	                                                return same;
303	                                        }
304	                                });
305	                        }
306	                        return same;
307	                });
308	                return same;
309	        },
310	        _space: function() {
311	                var used = [],
312	                        inst = this;
313	                each( spaces, function( spaceName, space ) {
314	                        if ( inst[ space.cache ] ) {
315	                                used.push( spaceName );
316	                        }
317	                });
318	                return used.pop();
319	        },
320	        transition: function( other, distance ) {
321	                var end = color( other ),
322	                        spaceName = end._space(),
323	                        space = spaces[ spaceName ],
324	                        startColor = this.alpha() === 0 ? color( "transparent" ) : this,
325	                        start = startColor[ space.cache ] || space.to( startColor._rgba ),
326	                        result = start.slice();
327	
328	                end = end[ space.cache ];
329	                each( space.props, function( key, prop ) {
330	                        var index = prop.idx,
331	                                startValue = start[ index ],
332	                                endValue = end[ index ],
333	                                type = propTypes[ prop.type ] || {};
334	
335	                        // if null, don't override start value
336	                        if ( endValue === null ) {
337	                                return;
338	                        }
339	                        // if null - use end
340	                        if ( startValue === null ) {
341	                                result[ index ] = endValue;
342	                        } else {
343	                                if ( type.mod ) {
344	                                        if ( endValue - startValue > type.mod / 2 ) {
345	                                                startValue += type.mod;
346	                                        } else if ( startValue - endValue > type.mod / 2 ) {
347	                                                startValue -= type.mod;
348	                                        }
349	                                }
350	                                result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
351	                        }
352	                });
353	                return this[ spaceName ]( result );
354	        },
355	        blend: function( opaque ) {
356	                // if we are already opaque - return ourself
357	                if ( this._rgba[ 3 ] === 1 ) {
358	                        return this;
359	                }
360	
361	                var rgb = this._rgba.slice(),
362	                        a = rgb.pop(),
363	                        blend = color( opaque )._rgba;
364	
365	                return color( jQuery.map( rgb, function( v, i ) {
366	                        return ( 1 - a ) * blend[ i ] + a * v;
367	                }));
368	        },
369	        toRgbaString: function() {
370	                var prefix = "rgba(",
371	                        rgba = jQuery.map( this._rgba, function( v, i ) {
372	                                return v == null ? ( i > 2 ? 1 : 0 ) : v;
373	                        });
374	
375	                if ( rgba[ 3 ] === 1 ) {
376	                        rgba.pop();
377	                        prefix = "rgb(";
378	                }
379	
380	                return prefix + rgba.join() + ")";
381	        },
382	        toHslaString: function() {
383	                var prefix = "hsla(",
384	                        hsla = jQuery.map( this.hsla(), function( v, i ) {
385	                                if ( v == null ) {
386	                                        v = i > 2 ? 1 : 0;
387	                                }
388	
389	                                // catch 1 and 2
390	                                if ( i && i < 3 ) {
391	                                        v = Math.round( v * 100 ) + "%";
392	                                }
393	                                return v;
394	                        });
395	
396	                if ( hsla[ 3 ] === 1 ) {
397	                        hsla.pop();
398	                        prefix = "hsl(";
399	                }
400	                return prefix + hsla.join() + ")";
401	        },
402	        toHexString: function( includeAlpha ) {
403	                var rgba = this._rgba.slice(),
404	                        alpha = rgba.pop();
405	
406	                if ( includeAlpha ) {
407	                        rgba.push( ~~( alpha * 255 ) );
408	                }
409	
410	                return "#" + jQuery.map( rgba, function( v, i ) {
411	
412	                        // default to 0 when nulls exist
413	                        v = ( v || 0 ).toString( 16 );
414	                        return v.length === 1 ? "0" + v : v;
415	                }).join("");
416	        },
417	        toString: function() {
418	                return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
419	        }
420	});
421	color.fn.parse.prototype = color.fn;
422	
423	// hsla conversions adapted from:
424	// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
425	
426	function hue2rgb( p, q, h ) {
427	        h = ( h + 1 ) % 1;
428	        if ( h * 6 < 1 ) {
429	                return p + (q - p) * h * 6;
430	        }
431	        if ( h * 2 < 1) {
432	                return q;
433	        }
434	        if ( h * 3 < 2 ) {
435	                return p + (q - p) * ((2/3) - h) * 6;
436	        }
437	        return p;
438	}
439	
440	spaces.hsla.to = function ( rgba ) {
441	        if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
442	                return [ null, null, null, rgba[ 3 ] ];
443	        }
444	        var r = rgba[ 0 ] / 255,
445	                g = rgba[ 1 ] / 255,
446	                b = rgba[ 2 ] / 255,
447	                a = rgba[ 3 ],
448	                max = Math.max( r, g, b ),
449	                min = Math.min( r, g, b ),
450	                diff = max - min,
451	                add = max + min,
452	                l = add * 0.5,
453	                h, s;
454	
455	        if ( min === max ) {
456	                h = 0;
457	        } else if ( r === max ) {
458	                h = ( 60 * ( g - b ) / diff ) + 360;
459	        } else if ( g === max ) {
460	                h = ( 60 * ( b - r ) / diff ) + 120;
461	        } else {
462	                h = ( 60 * ( r - g ) / diff ) + 240;
463	        }
464	
465	        if ( l === 0 || l === 1 ) {
466	                s = l;
467	        } else if ( l <= 0.5 ) {
468	                s = diff / add;
469	        } else {
470	                s = diff / ( 2 - add );
471	        }
472	        return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
473	};
474	
475	spaces.hsla.from = function ( hsla ) {
476	        if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
477	                return [ null, null, null, hsla[ 3 ] ];
478	        }
479	        var h = hsla[ 0 ] / 360,
480	                s = hsla[ 1 ],
481	                l = hsla[ 2 ],
482	                a = hsla[ 3 ],
483	                q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
484	                p = 2 * l - q,
485	                r, g, b;
486	
487	        return [
488	                Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
489	                Math.round( hue2rgb( p, q, h ) * 255 ),
490	                Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
491	                a
492	        ];
493	};
494	
495	
496	each( spaces, function( spaceName, space ) {
497	        var props = space.props,
498	                cache = space.cache,
499	                to = space.to,
500	                from = space.from;
501	
502	        // makes rgba() and hsla()
503	        color.fn[ spaceName ] = function( value ) {
504	
505	                // generate a cache for this space if it doesn't exist
506	                if ( to && !this[ cache ] ) {
507	                        this[ cache ] = to( this._rgba );
508	                }
509	                if ( value === undefined ) {
510	                        return this[ cache ].slice();
511	                }
512	
513	                var ret,
514	                        type = jQuery.type( value ),
515	                        arr = ( type === "array" || type === "object" ) ? value : arguments,
516	                        local = this[ cache ].slice();
517	
518	                each( props, function( key, prop ) {
519	                        var val = arr[ type === "object" ? key : prop.idx ];
520	                        if ( val == null ) {
521	                                val = local[ prop.idx ];
522	                        }
523	                        local[ prop.idx ] = clamp( val, prop );
524	                });
525	
526	                if ( from ) {
527	                        ret = color( from( local ) );
528	                        ret[ cache ] = local;
529	                        return ret;
530	                } else {
531	                        return color( local );
532	                }
533	        };
534	
535	        // makes red() green() blue() alpha() hue() saturation() lightness()
536	        each( props, function( key, prop ) {
537	                // alpha is included in more than one space
538	                if ( color.fn[ key ] ) {
539	                        return;
540	                }
541	                color.fn[ key ] = function( value ) {
542	                        var vtype = jQuery.type( value ),
543	                                fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
544	                                local = this[ fn ](),
545	                                cur = local[ prop.idx ],
546	                                match;
547	
548	                        if ( vtype === "undefined" ) {
549	                                return cur;
550	                        }
551	
552	                        if ( vtype === "function" ) {
553	                                value = value.call( this, cur );
554	                                vtype = jQuery.type( value );
555	                        }
556	                        if ( value == null && prop.empty ) {
557	                                return this;
558	                        }
559	                        if ( vtype === "string" ) {
560	                                match = rplusequals.exec( value );
561	                                if ( match ) {
562	                                        value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
563	                                }
564	                        }
565	                        local[ prop.idx ] = value;
566	                        return this[ fn ]( local );
567	                };
568	        });
569	});
570	
571	// add cssHook and .fx.step function for each named hook.
572	// accept a space separated string of properties
573	color.hook = function( hook ) {
574	        var hooks = hook.split( " " );
575	        each( hooks, function( i, hook ) {
576	                jQuery.cssHooks[ hook ] = {
577	                        set: function( elem, value ) {
578	                                var parsed, curElem,
579	                                        backgroundColor = "";
580	
581	                                if ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) {
582	                                        value = color( parsed || value );
583	                                        if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
584	                                                curElem = hook === "backgroundColor" ? elem.parentNode : elem;
585	                                                while (
586	                                                        (backgroundColor === "" || backgroundColor === "transparent") &&
587	                                                        curElem && curElem.style
588	                                                ) {
589	                                                        try {
590	                                                                backgroundColor = jQuery.css( curElem, "backgroundColor" );
591	                                                                curElem = curElem.parentNode;
592	                                                        } catch ( e ) {
593	                                                        }
594	                                                }
595	
596	                                                value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
597	                                                        backgroundColor :
598	                                                        "_default" );
599	                                        }
600	
601	                                        value = value.toRgbaString();
602	                                }
603	                                try {
604	                                        elem.style[ hook ] = value;
605	                                } catch( value ) {
606	                                        // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
607	                                }
608	                        }
609	                };
610	                jQuery.fx.step[ hook ] = function( fx ) {
611	                        if ( !fx.colorInit ) {
612	                                fx.start = color( fx.elem, hook );
613	                                fx.end = color( fx.end );
614	                                fx.colorInit = true;
615	                        }
616	                        jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
617	                };
618	        });
619	
620	};
621	
622	color.hook( stepHooks );
623	
624	jQuery.cssHooks.borderColor = {
625	        expand: function( value ) {
626	                var expanded = {};
627	
628	                each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
629	                        expanded[ "border" + part + "Color" ] = value;
630	                });
631	                return expanded;
632	        }
633	};
634	
635	// Basic color names only.
636	// Usage of any of the other color names requires adding yourself or including
637	// jquery.color.svg-names.js.
638	colors = jQuery.Color.names = {
639	        // 4.1. Basic color keywords
640	        aqua: "#00ffff",
641	        black: "#000000",
642	        blue: "#0000ff",
643	        fuchsia: "#ff00ff",
644	        gray: "#808080",
645	        green: "#008000",
646	        lime: "#00ff00",
647	        maroon: "#800000",
648	        navy: "#000080",
649	        olive: "#808000",
650	        purple: "#800080",
651	        red: "#ff0000",
652	        silver: "#c0c0c0",
653	        teal: "#008080",
654	        white: "#ffffff",
655	        yellow: "#ffff00",
656	
657	        // 4.2.3. ‘transparent’ color keyword
658	        transparent: [ null, null, null, 0 ],
659	
660	        _default: "#ffffff"
661	};
662	
663	})( jQuery );
664	
665	/*!
666	 * jQuery Color Animations v2.1.0 - SVG Color Names
667	 * http://jquery.org/
668	 *
669	 * Remaining HTML/CSS color names per W3C's CSS Color Module Level 3.
670	 * http://www.w3.org/TR/css3-color/#svg-color
671	 *
672	 * Copyright 2012 jQuery Foundation and other contributors
673	 * Released under the MIT license.
674	 * http://jquery.org/license
675	 *
676	 * Date: Fri Aug 24 12:02:24 2012 -0500
677	 */
678	jQuery.extend( jQuery.Color.names, {
679	        // 4.3. Extended color keywords (minus the basic ones in core color plugin)
680	        aliceblue: "#f0f8ff",
681	        antiquewhite: "#faebd7",
682	        aquamarine: "#7fffd4",
683	        azure: "#f0ffff",
684	        beige: "#f5f5dc",
685	        bisque: "#ffe4c4",
686	        blanchedalmond: "#ffebcd",
687	        blueviolet: "#8a2be2",
688	        brown: "#a52a2a",
689	        burlywood: "#deb887",
690	        cadetblue: "#5f9ea0",
691	        chartreuse: "#7fff00",
692	        chocolate: "#d2691e",
693	        coral: "#ff7f50",
694	        cornflowerblue: "#6495ed",
695	        cornsilk: "#fff8dc",
696	        crimson: "#dc143c",
697	        cyan: "#00ffff",
698	        darkblue: "#00008b",
699	        darkcyan: "#008b8b",
700	        darkgoldenrod: "#b8860b",
701	        darkgray: "#a9a9a9",
702	        darkgreen: "#006400",
703	        darkgrey: "#a9a9a9",
704	        darkkhaki: "#bdb76b",
705	        darkmagenta: "#8b008b",
706	        darkolivegreen: "#556b2f",
707	        darkorange: "#ff8c00",
708	        darkorchid: "#9932cc",
709	        darkred: "#8b0000",
710	        darksalmon: "#e9967a",
711	        darkseagreen: "#8fbc8f",
712	        darkslateblue: "#483d8b",
713	        darkslategray: "#2f4f4f",
714	        darkslategrey: "#2f4f4f",
715	        darkturquoise: "#00ced1",
716	        darkviolet: "#9400d3",
717	        deeppink: "#ff1493",
718	        deepskyblue: "#00bfff",
719	        dimgray: "#696969",
720	        dimgrey: "#696969",
721	        dodgerblue: "#1e90ff",
722	        firebrick: "#b22222",
723	        floralwhite: "#fffaf0",
724	        forestgreen: "#228b22",
725	        gainsboro: "#dcdcdc",
726	        ghostwhite: "#f8f8ff",
727	        gold: "#ffd700",
728	        goldenrod: "#daa520",
729	        greenyellow: "#adff2f",
730	        grey: "#808080",
731	        honeydew: "#f0fff0",
732	        hotpink: "#ff69b4",
733	        indianred: "#cd5c5c",
734	        indigo: "#4b0082",
735	        ivory: "#fffff0",
736	        khaki: "#f0e68c",
737	        lavender: "#e6e6fa",
738	        lavenderblush: "#fff0f5",
739	        lawngreen: "#7cfc00",
740	        lemonchiffon: "#fffacd",
741	        lightblue: "#add8e6",
742	        lightcoral: "#f08080",
743	        lightcyan: "#e0ffff",
744	        lightgoldenrodyellow: "#fafad2",
745	        lightgray: "#d3d3d3",
746	        lightgreen: "#90ee90",
747	        lightgrey: "#d3d3d3",
748	        lightpink: "#ffb6c1",
749	        lightsalmon: "#ffa07a",
750	        lightseagreen: "#20b2aa",
751	        lightskyblue: "#87cefa",
752	        lightslategray: "#778899",
753	        lightslategrey: "#778899",
754	        lightsteelblue: "#b0c4de",
755	        lightyellow: "#ffffe0",
756	        limegreen: "#32cd32",
757	        linen: "#faf0e6",
758	        mediumaquamarine: "#66cdaa",
759	        mediumblue: "#0000cd",
760	        mediumorchid: "#ba55d3",
761	        mediumpurple: "#9370db",
762	        mediumseagreen: "#3cb371",
763	        mediumslateblue: "#7b68ee",
764	        mediumspringgreen: "#00fa9a",
765	        mediumturquoise: "#48d1cc",
766	        mediumvioletred: "#c71585",
767	        midnightblue: "#191970",
768	        mintcream: "#f5fffa",
769	        mistyrose: "#ffe4e1",
770	        moccasin: "#ffe4b5",
771	        navajowhite: "#ffdead",
772	        oldlace: "#fdf5e6",
773	        olivedrab: "#6b8e23",
774	        orange: "#ffa500",
775	        orangered: "#ff4500",
776	        orchid: "#da70d6",
777	        palegoldenrod: "#eee8aa",
778	        palegreen: "#98fb98",
779	        paleturquoise: "#afeeee",
780	        palevioletred: "#db7093",
781	        papayawhip: "#ffefd5",
782	        peachpuff: "#ffdab9",
783	        peru: "#cd853f",
784	        pink: "#ffc0cb",
785	        plum: "#dda0dd",
786	        powderblue: "#b0e0e6",
787	        rosybrown: "#bc8f8f",
788	        royalblue: "#4169e1",
789	        saddlebrown: "#8b4513",
790	        salmon: "#fa8072",
791	        sandybrown: "#f4a460",
792	        seagreen: "#2e8b57",
793	        seashell: "#fff5ee",
794	        sienna: "#a0522d",
795	        skyblue: "#87ceeb",
796	        slateblue: "#6a5acd",
797	        slategray: "#708090",
798	        slategrey: "#708090",
799	        snow: "#fffafa",
800	        springgreen: "#00ff7f",
801	        steelblue: "#4682b4",
802	        tan: "#d2b48c",
803	        thistle: "#d8bfd8",
804	        tomato: "#ff6347",
805	        turquoise: "#40e0d0",
806	        violet: "#ee82ee",
807	        wheat: "#f5deb3",
808	        whitesmoke: "#f5f5f5",
809	        yellowgreen: "#9acd32",
810	});