[css-color] Markup tweak

Author: tabatkins

css-color/Overview.bs

@@ -2483,10 +2483,10 @@ APIs for Parsing and Manipulating Colors</h2>
 
 		<li>
 			It allows colors to be manipulated in any of the syntaxes that CSS exposes:
-			<a idl>RGBColor</a> for RGBA colors, with components ranging from 0-1;
-			<a idl>HexColor</a> for RGBA colors, with components ranging from 0-255;
-			<a idl>HSLColor</a> for HSLA colors, corresponding to the ''hsla()'' syntax;
-			and <a idl>CMYKColor</a> for CMYK colors, corresponding to the ''device-cmyk()'' syntax.
+			{{RGBColor}} for RGBA colors, with components ranging from 0-1;
+			{{HexColor}} for RGBA colors, with components ranging from 0-255;
+			{{HSLColor}} for HSLA colors, corresponding to the ''hsla()'' syntax;
+			and {{CMYKColor}} for CMYK colors, corresponding to the ''device-cmyk()'' syntax.
 
 			All of these expose their components as attributes you can manipulate directly,
 			and colors can be easily converted between any of the classes with methods like <code>toRGB()</code> and <code>toHSL()</code>.
@@ -2513,13 +2513,13 @@ APIs for Parsing and Manipulating Colors</h2>
 <h3 id='api-RGBColor'>
 The RGBColor Object</h3>
 
-	The <a idl>RGBColor</a> class is the "primary" color class,
+	The {{RGBColor}} class is the "primary" color class,
 	because all CSS colors must be RGB-compatible
 	(that is, capable of being converted into a roughly equivalent RGB color).
 	As a result, it's always possible to convert a UA-defined color class
 	(and any properly-designed author-defined color classes,
 		see [[#api-extending]])
-	into an equivalent <a idl>RGBColor</a> instance.
+	into an equivalent {{RGBColor}} instance.
 	This fact is used to aid in automatic handling of several methods common to all color classes.
 
 	<pre class='idl'>
@@ -2588,7 +2588,7 @@ The RGBColor Object</h3>
 			not 0 to 255.
 			See the <a idl for>HexColor</a> class if you prefer working in the 0-255 range.
 
-		<dt><dfn constructor title="RGBColor(rgb)">RGBColor</dfn>(<a idl>RGBColor</a> <dfn argument for="RGBColor(rgb)">rgb</dfn>)
+		<dt><dfn constructor title="RGBColor(rgb)">RGBColor</dfn>({{RGBColor}} <dfn argument for="RGBColor(rgb)">rgb</dfn>)
 		<dd>
 			Defined as follows in ECMAScript:
 
@@ -2636,7 +2636,7 @@ The RGBColor Object</h3>
 		<dd>
 			<a>Parse a component value</a> from the passed string.
 			If this operation succeeds and the result is a valid CSS color,
-			construct an instance of the <a idl>RGBColor</a> class
+			construct an instance of the {{RGBColor}} class
 			with attributes initialized to represent that color.
 
 			Otherwise, throw an XXXError.
@@ -2698,7 +2698,7 @@ The RGBColor Object</h3>
 		<dt><dfn attribute>b</dfn> <span attribute-info for="RGBColor/b"></span>
 		<dt><dfn attribute>a</dfn> <span attribute-info for="RGBColor/a"></span>
 		<dd link-for="RGBColor">
-			The <a idl>r</a>, <a idl>g</a>, <a idl>b</a>, and <a idl>a</a> attributes
+			The {{r}}, {{g}}, {{b}}, and {{a}} attributes
 			represent the red, green, blue, and alpha channels of the RGB color
 			that the <a idl for>RGBColor</a> instance represents.
 
@@ -2864,7 +2864,7 @@ The HSLColor Class</h3>
 		<dd>
 			<a>Parse a component value</a> from the passed string.
 			If this operation succeeds and the result is a valid CSS color,
-			construct an instance of the <a idl>HSLColor</a> class
+			construct an instance of the {{HSLColor}} class
 			with attributes initialized to represent that color.
 
 			Otherwise, throw an XXXError.
@@ -2910,7 +2910,7 @@ The HSLColor Class</h3>
 		<dt><dfn attribute>l</dfn> <span attribute-info for="HSLColor/l"></span>
 		<dt><dfn attribute>a</dfn> <span attribute-info for="HSLColor/a"></span>
 		<dd link-for="HSLColor">
-			The <a idl>h</a>, <a idl>s</a>, <a idl>l</a>, and <a idl>a</a> attributes
+			The {{h}}, {{s}}, {{l}}, and {{a}} attributes
 			represent the hue, saturation, lightness, and alpha channels of the HSL color
 			that the <a idl for>HSLColor</a> instance represents.
 
@@ -2984,7 +2984,7 @@ The HexColor Class</h3>
 			}
 			</pre>
 
-		<dt><dfn constructor title="HexColor(rgb)">HexColor</dfn>(<a idl>RGBColor</a> <dfn argument for="HexColor/HexColor(rgb)">rgb</dfn>)
+		<dt><dfn constructor title="HexColor(rgb)">HexColor</dfn>({{RGBColor}} <dfn argument for="HexColor/HexColor(rgb)">rgb</dfn>)
 		<dd>
 			Defined as follows in ECMAScript:
 
@@ -3049,7 +3049,7 @@ The HexColor Class</h3>
 		<dd>
 			<a>Parse a component value</a> from the passed string.
 			If this operation succeeds and the result is a valid CSS color,
-			construct an instance of the <a idl>HexColor</a> class
+			construct an instance of the {{HexColor}} class
 			with attributes initialized to represent that color.
 
 			Otherwise, throw an XXXError.
@@ -3069,7 +3069,7 @@ The HexColor Class</h3>
 		<dt><dfn attribute>b</dfn> <span attribute-info for="HexColor/b"></span>
 		<dt><dfn attribute>a</dfn> <span attribute-info for="HexColor/a"></span>
 		<dd link-for="HexColor">
-			The <a idl>r</a>, <a idl>g</a>, <a idl>b</a>, and <a idl>a</a> attributes
+			The {{r}}, {{g}}, {{b}}, and {{a}} attributes
 			represent the red, blue, green, and alpha channels of the RGB color
 			that the <a idl for>HexColor</a> instance represents.
 
@@ -3148,7 +3148,7 @@ The CMYKColor Class</h3>
 			}
 			</pre>
 
-		<dt><dfn constructor title="CMYKColor(rgb)">CMYKColor</dfn>(<a idl>RGBColor</a> <dfn argument for="CMYKColor/CMYKColor(rgb)">rgb</dfn>)
+		<dt><dfn constructor title="CMYKColor(rgb)">CMYKColor</dfn>({{RGBColor}} <dfn argument for="CMYKColor/CMYKColor(rgb)">rgb</dfn>)
 		<dd>
 			Defined as follows in ECMAScript:
 
@@ -3229,11 +3229,11 @@ The CMYKColor Class</h3>
 		<dd>
 			<a>Parse a component value</a> from the passed string.
 			If this operation succeeds and the result is a valid ''device-cmyk()'' function,
-			construct an instance of the <a idl>CMYKColor</a> class
+			construct an instance of the {{CMYKColor}} class
 			with attributes initialized to represent that color.
 
 			Otherwise, if the operation succeeds and the result is any other type of valid CSS color,
-			construct an instance of the <a idl>CMYKColor</a> class
+			construct an instance of the {{CMYKColor}} class
 			with attributes initialized to represent that color
 			converted to CMYK,
 			per [[#cmyk-rgb]].
@@ -3261,7 +3261,7 @@ The CMYKColor Class</h3>
 		<dt><dfn attribute>a</dfn> <span attribute-info for="CMYKColor/a"></span>
 		<dt><dfn attribute>fallback</dfn> <span attribute-info for="CMYKColor/fallback"></span>
 		<dd link-for="CMYKColor">
-			The <a idl>c</a>, <a idl>m</a>, <a idl>y</a>, <a idl>k</a>, <a idl>a</a>, and <a idl>fallback</a> attributes
+			The {{c}}, {{m}}, {{y}}, {{k}}, {{a}}, and {{fallback}} attributes
 			represent the red, blue, green, and alpha channels of the CMYK color
 			that the <a idl for>CMYKColor</a> instance represents.
 
@@ -3320,8 +3320,8 @@ Adding New Color-Manipulating Methods</h4>
 
 	<ol>
 		<li>
-			Define the method for <a idl>RGBColor</a>s,
-			by adding it to <code><a idl>RGBColor</a>.prototype</code>.
+			Define the method for {{RGBColor}}s,
+			by adding it to <code>{{RGBColor}}.prototype</code>.
 
 		<li>
 			Define a forwarding method for all other color classes,
@@ -3363,7 +3363,7 @@ Adding New Color-Manipulating Methods</h4>
 		Without any further effort,
 		the <code>lightness()</code> method
 		is now available for other color classes,
-		like instances of <a idl>CMYKColor</a>.
+		like instances of {{CMYKColor}}.
 	</div>
 
 <h4 id='api-adding-classes'>
@@ -3374,7 +3374,7 @@ Adding New Color Classes</h4>
 	For example,
 	even though HSL colors are conceptually equivalent to RGB colors,
 	it is still sometimes useful to be able to directly alter the hue angle of the color,
-	which the <a idl>HSLColor</a> class allows.
+	which the {{HSLColor}} class allows.
 
 	If, as an author, you wish to work with colors in your application in a color space that CSS does not directly support,
 	you can easily add your own color class.
@@ -3386,22 +3386,22 @@ Adding New Color Classes</h4>
 
 	<ol>
 		<li>
-			Subclass <a idl>CSSColor</a>,
+			Subclass {{CSSColor}},
 			such as via:
 
 			<pre>MyNewColor.prototype = Object.create(CSSColor.prototype);</pre>
 
 		<li>
 			Implement a <code>toRGB()</code> method,
 			which can be called without any arguments
-			and which returns an equivalent <a idl>RGBColor</a> instance.
-			(Remember that the normal range of <a idl>RGBColor</a> components
+			and which returns an equivalent {{RGBColor}} instance.
+			(Remember that the normal range of {{RGBColor}} components
 			is between 0 and 1, not 0 and 255.)
 
 		<li>
 			Implement a constructor that,
-			when passed an <a idl>RGBColor</a> instance as its sole argument,
-			will produce a color equivalent to the <a idl>RGBColor</a>.
+			when passed an {{RGBColor}} instance as its sole argument,
+			will produce a color equivalent to the {{RGBColor}}.
 			(Same disclaimer as previous item.)
 	</ol>
 
@@ -3504,21 +3504,21 @@ Adding New Color Classes</h4>
 			and turn it into an instance of your class.
 
 		<li>
-			A <code>toMyColor()</code> method on <code><a idl>RGBColor</a>.prototype</code>,
+			A <code>toMyColor()</code> method on <code>{{RGBColor}}.prototype</code>,
 			that transforms any type of color into your color class.
 
 		<li>
 			If your class is very similar to an existing class,
 			such that you can do a better/faster conversion between the existing class and yours directly
-			rather than doing through <a idl>RGBColor</a> first,
+			rather than doing through {{RGBColor}} first,
 			an <code>toMyColor()</code> method on <code>TheOtherColor.prototype</code>,
 			and a <code>toTheOtherColor()</code> method on <code>MyNewColor.prototype</code>.
 			Add cases to your constructor to handle these classes as well.
 
 		<li>
 			Custom stringifiers on the <code>stringifiers</code> object for one of the UA-defined color classes,
 			if it's more accurate/efficient to convert your color class into one of the UA-defined types directly
-			than it is to first convert it into an <a idl>RGBColor</a>.
+			than it is to first convert it into an {{RGBColor}}.
 
 			Note: It is <strong>not</strong> generally useful to define a special stringifier for your class itself;
 			the main purpose of the stringifier is to allow the object to be used in a CSS property,
@@ -3678,29 +3678,29 @@ The CSSColor Object</h3>
 
 	In addition,
 	it provides two static methods:
-	<a idl>parse()</a>,
+	{{parse()}},
 	which takes a string containing a CSS color value
 	and returns an appropriate color class
 	representing that value;
-	and <a idl>forward()</a>,
+	and {{forward()}},
 	which is a helper function for adding new methods to all color classes
 	(see [[#api-adding-methods]] for more detail on using this function).
 
 	<div class='example'>
 		The most common use of this interface is to parse color strings into an appropriate color object.
 
-		The following code sets <code>color</code> to a <a idl>HexColor</a> object:
+		The following code sets <code>color</code> to a {{HexColor}} object:
 
 		<pre>var color = CSSColor.parse("#96c");</pre>
 
-		While this code sets <code>color</code> to an <a idl>HSLColor</a> object:
+		While this code sets <code>color</code> to an {{HSLColor}} object:
 
 		<pre>var color = CSSColor.parse("hsl(120deg, 100%, 50%)");</pre>
 
 		Note that this returns a color class matching the type of input provided to it.
 		If a particular color class is desired,
 		the class's constructor can be passed a string instead.
-		For example, the following will set <code>color</code> to an <a idl>RGBColor</a> object,
+		For example, the following will set <code>color</code> to an {{RGBColor}} object,
 		even though it uses the ''hsl()'' function:
 
 		<pre>var color = new RGBColor("hsl(120deg, 100%, 50%)")</pre>
@@ -3738,7 +3738,7 @@ The CSSColor Object</h3>
 		<dd>
 			Throw an XXXError.
 
-			Note: All <a idl>CSSColor</a> subclasses have to implement this method themselves.
+			Note: All {{CSSColor}} subclasses have to implement this method themselves.
 
 		<dt><dfn method title="parse()">parse</dfn>(
 			DOMString <dfn argument for="CSSColor/parse()">css</dfn>,
@@ -3753,7 +3753,7 @@ The CSSColor Object</h3>
 			Throws if it can't parse a color out of the string,
 			or if you give it "currentcolor" but no element to resolve against.
 
-		<dt><dfn method title="toString()">toString</dfn>(optional <a idl>ColorStringifierType</a> <dfn argument for="CSSColor/toString()">type</dfn>, any... args)
+		<dt><dfn method title="toString()">toString</dfn>(optional {{ColorStringifierType}} <dfn argument for="CSSColor/toString()">type</dfn>, any... args)
 		<dd>
 			Defined as follows in ECMAScript:
 
@@ -3769,7 +3769,7 @@ The CSSColor Object</h3>
 					type = "rgb";
 				}
 
-				if(/* <var>type</var> is not a <a idl>ColorStringifierType</a> value */) {
+				if(/* <var>type</var> is not a {{ColorStringifierType}} value */) {
 					throw XXXError("Invalid stringifier type: " + type);
 				}
 
@@ -3787,10 +3787,10 @@ The CSSColor Object</h3>
 			This function automates "forwarding" methods to a canonical definition in RGBColor,
 			so that authors can add new methods to color objects
 			without having to explicitly add variants of the method to every single color class.
-			It adds a default version of a method to <code><a idl>CSSColor</a>.prototype</code>
+			It adds a default version of a method to <code>{{CSSColor}}.prototype</code>
 			(which will get picked up by all subclasses,
 				unless explicitly overridden)
-			that converts the color into an <a idl>RGBColor</a>
+			that converts the color into an {{RGBColor}}
 			and calls the method there.
 
 			Note: For this to work correctly,
@@ -3813,25 +3813,25 @@ The CSSColor Object</h3>
 
 		<dt><dfn method title="forwardToSameClass()">forwardToSameClass</dfn>(<dfn argument for="CSSColor/forwardToSameClass()">methodName</dfn>)
 		<dd>
-			Similar to the <a idl>forward()</a> method,
+			Similar to the {{forward()}} method,
 			but used when the method returns a color object,
 			and you'd like it to return the same type of color object as you called the method on.
 
 			<div class='example'>
-				It is always safe to use <a idl>forward()</a> on a method;
+				It is always safe to use {{forward()}} on a method;
 				if it returns a color,
 				it will just be an RGBColor.
 				For example, if you use <code>CSSColor.forward("lighten");</code>
 				to forward a <code>lighten(%)</code> method to all color types,
-				when you call <code>c.lighten(.2)</code> on an <a idl>HSLColor</a> object,
-				you'll get back the lightened color as an <a idl>RGBColor</a> object.
+				when you call <code>c.lighten(.2)</code> on an {{HSLColor}} object,
+				you'll get back the lightened color as an {{RGBColor}} object.
 
-				However, you probably want <code>lighten()</code> called on an <a idl>HSLColor</a> object
-				to return another <a idl>HSLColor</a> object.
+				However, you probably want <code>lighten()</code> called on an {{HSLColor}} object
+				to return another {{HSLColor}} object.
 				Using <code>CSSColor.forwardToSameClass("lighten");</code> will make this happen automatically.
 
 				Obviously, if a method does not return a color
-				you should not use <a idl>forwardToSameClass()</a>;
+				you should not use {{forwardToSameClass()}};
 				the results will probably not be what you want,
 				as it will attempt to convert whatever the return value is into an instance of the color class.
 			</div>
@@ -3853,7 +3853,7 @@ The CSSColor Object</h3>
 		<dt><dfn method>toCMYK()</dfn>
 		<dt><dfn method>toName()</dfn>
 		<dd>
-			All of these methods delegate to the appropriate methods on <a idl>RGBColor</a>,
+			All of these methods delegate to the appropriate methods on {{RGBColor}},
 			exactly as if created by calling <code>CSSColor.forward("asHSL")</code>, etc.
 
 	</dl>