Chapter 4: Basic Data Types and Interfaces

In this specification, attributes are defined with an attribute definition table, which looks like this:

Name	Value	Initial value	Animatable
exampleattr	<length> | none	none	yes

In the Value column is a description of the attribute's syntax. There are six methods for describing an attribute's syntax:

1. Using the CSS Value Definition Syntax [css-values]. This is the notation used to define the syntax for most attributes in this specification and is the default.
2. By reference to an EBNF symbol defined in this or another specification [xml]. For external definitions, this is indicated by [EBNF] appearing in the Value column.
3. By reference to an ABNF symbol defined in another specification [rfc5234]. This is indicated by [ABNF] appearing in the Value column.
4. As a URL as defined by the URL Standard [URL]. This is indicated by [URL] appearing in the Value column.
5. As a type as defined by the HTML Standard [HTML]. This is indicated by [HTML] appearing in the Value column.
6. In prose, below the attibute definition table. This is indicated by the text "(see below)" appearing in the Value column.

When a presentation attribute defined using the CSS Value Definition Syntax is parsed, this is done as follows:

1. Let value be the value of the attribute.
2. Let grammar be the grammar given in the attribute definition table's Value column.
3. Replace all instances of <length> in grammar with [<length> | <number>].
4. Replace all instances of <angle> in grammar with [<angle> | <number>].
5. Return the result of parsing value with grammar.

The insertion of the <number> symbols allows for unitless length and angles to be used in presentation attribute while disallowing them in corresponding property values.

Note that all presentation attributes, since they are defined by reference to their corresponding CSS properties, are defined using the CSS Value Definition Syntax.

When any other attribute defined using the CSS Value Definition Syntax is parsed, this is done by parsing the attribute's value according to the grammar given in attribute definition table.

Note that this allows CSS comments and escapes to be used in such attributes. For example, a value of '10\px/**/' would successfully parse as '10px' in the ‘x’ presentation attribute of the ‘rect’ element.

When an attribute defined as a URL is parsed, this is done by invoking the URL parser with the attribute's value as input and the document's URL as base [URL].

The Initial value column gives the initial value for the attribute. When an attribute fails to parse according to the specified CSS Value Definition Syntax, ABNF or EBNF grammar, or if parsing according to the URL Standard or by the prose describing how to parse the attribute indicates failure, the attribute is assumed to have been specified as the given initial value.

The Animatable column indicates whether the attribute can be animated using animation elements as defined in the SVG Animation module.

4.4.1. Interface SVGElement

All of the SVG DOM interfaces that correspond directly to elements in the SVG language (such as the SVGPathElement interface for the ‘path’ element) derive from the SVGElement interface.

The CSSOM specification augments SVGElement with a style IDL attribute, so that the ‘style’ attribute can be accessed in the same way as on HTML elements.

[Exposed=Window]
interface SVGElement : Element {

  [SameObject] readonly attribute SVGAnimatedString className;

  readonly attribute SVGSVGElement? ownerSVGElement;
  readonly attribute SVGElement? viewportElement;
};

SVGElement includes GlobalEventHandlers;
SVGElement includes DocumentAndElementEventHandlers;
SVGElement includes SVGElementInstance;
SVGElement includes HTMLOrSVGElement;

The className IDL attribute reflects the ‘class’ attribute.

The ownerSVGElement IDL attribute represents the nearest ancestor ‘svg’ element. On getting ownerSVGElement, the nearest ancestor ‘svg’ element is returned; if the current element is the outermost svg element, then null is returned.

The viewportElement IDL attribute represents the element that provides the SVG viewport for the current element. On getting viewport, the nearest ancestor element that establishes an SVG viewport is returned; if the current element is the outermost svg element, then null is returned.

4.4.2. Interface SVGGraphicsElement

The SVGGraphicsElement interface represents SVG elements whose primary purpose is to directly render graphics into a group.

dictionary SVGBoundingBoxOptions {
  boolean fill = true;
  boolean stroke = false;
  boolean markers = false;
  boolean clipped = false;
};

interface SVGGraphicsElement : SVGElement {
  [SameObject] readonly attribute SVGAnimatedTransformList transform;

  DOMRect getBBox(optional SVGBoundingBoxOptions options);
  DOMMatrix? getCTM();
  DOMMatrix? getScreenCTM();
};

SVGGraphicsElement includes SVGTests;

The transform IDL attribute reflects the computed value of the transform property and its corresponding ‘transform’ presentation attribute.

The getBBox method is used to compute the bounding box of the current element. When the getBBox(options) method is called, the bounding box algorithm is invoked for the current element, with fill, stroke, markers and clipped members of the options dictionary argument used to control which parts of the element are included in the bounding box, using the element's local coordinate system as the coordinate system to return the bounding box in. A newly created DOMRect object that defines the computed bounding box is returned.

The getCTM method is used to get the matrix that transforms the current element's coordinate system to its SVG viewport's coordinate system. When getCTM() is called, the following steps are run:

1. If the current element is not in the document, then return null.
2. Let ctm be a matrix determined based on what the current element is:

   the current element is the outermost svg element

   ctm is a matrix that transforms the coordinate space of the ‘svg’ (including its transform property) to the coordinate space of the document's viewport. The matrix includes the transforms produced by the ‘viewBox’ and ‘preserveAspectRatio’ attributes, the transform property, and any transform due to currentScale and currentTranslate properties on the SVGSVGElement.

   any other element

   ctm is a matrix that transforms the coordinate space of the current element (including its transform property) to the coordinate space of its closest ancestor viewport-establishing element (also including its transform property).

3. Return a newly created, detached DOMMatrix object that represents the same matrix as ctm.

The getScreenCTM method is used to get the matrix that transforms the current element's coordinate system to the coordinate system of the SVG viewport for the SVG document fragment. When getScreenCTM() is called, the following steps are run:

1. If the current element is not in the document, then return null.
2. Let ctm be a matrix that transforms the coordinate space of the current element (including its transform property) to the coordinate space of the document's viewport.

   This will include:

   • all of the transforms from the current element up to the outermost svg element
   • any transforms due to ‘viewBox’, ‘preserveAspectRatio’, the transform property and any transform due to currentScale and currentTranslate properties on the SVGSVGElement for the outermost svg element
   • any transforms from the SVG viewport's coordinate space to the document's viewport, i.e. taking into account the positions of all of the CSS boxes from the outermost svg element's box to the initial containing block when the SVG document fragment is inline in an HTML document
3. Return a newly created, detached DOMMatrix object that represents the same matrix as ctm.

This method would have been more aptly named as getClientCTM, but the name getScreenCTM is kept for historical reasons.

4.4.3. Interface SVGGeometryElement

Interface SVGGeometryElement represents SVG elements whose rendering is defined by geometry with an equivalent path, and which can be filled and stroked. This includes paths and the basic shapes.

[Exposed=Window]
interface SVGGeometryElement : SVGGraphicsElement {
  [SameObject] readonly attribute SVGAnimatedNumber pathLength;

  boolean isPointInFill(DOMPointInit point);
  boolean isPointInStroke(DOMPointInit point);
  float getTotalLength();
  DOMPoint getPointAtLength(float distance);
};

The isPointInFill and isPointInStroke methods determine whether a given point is within the fill or stroke shape of an element. Normal hit testing rules apply; the value of the pointer-events property on the element determines whether a point is considered to be within the fill or stroke. The point argument is interpreted as a point in the local coordiante system of the element.

The pathLength IDL attribute reflects the ‘pathLength’ content attribute.

The getTotalLength method is used to compute the length of the path. When getTotalLength() is called, the user agent's computed value for the total length of the path, in user units, is returned.

The user agent's computed path length does not take the ‘pathLength’ attribute into account.

The getPointAtLength method is used to return the point at a given distance along the path. When getPointAtLength(distance) is called, the following steps are run:

1. Let length be the user agent's computed value for the total length of the path, in user units.

   As with getTotalLength, this does not take into account the ‘pathLength’ attribute.

2. Clamp distance to [0, length].
3. Let (x, y) be the point on the path at distance distance.
4. Return a newly created, detached DOMPoint object representing the point (x, y).

4.5.1. Interface SVGNumber

The SVGNumber interface is used primarily to represent a <number> value that is a part of an SVGNumberList. Individual SVGNumber objects can also be created by script.

An SVGNumber object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below. SVGNumber objects reflected through the animVal IDL attribute are always read only.

An SVGNumber object can be associated with a particular element. The associated element is used to determine which element's content attribute to update if the object reflects an attribute. Unless otherwise described, an SVGNumber object is not associated with any element.

An SVGNumber object maintains an internal number value, which is called its value.

[Exposed=Window]
interface SVGNumber {
  attribute float value;
};

The value IDL attribute represents the number. On getting value, the SVGNumber's value is returned.

On setting value, the following steps are run:

1. If the SVGNumber is read only, then throw a NoModificationAllowedError.
2. Set the SVGNumber's value to the value being assigned to the value member.
3. If the SVGNumber reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

4.5.2. Interface SVGLength

The SVGLength interface is used to represent a value that can be a <length>, <percentage> or <number> value.

An SVGLength object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below. SVGLength objects reflected through the animVal IDL attribute are always read only.

An SVGLength object can be associated with a particular element, as well as being designated with a directionality: horizontal, vertical or unspecified. The associated element and the directionality of the length are used to resolve percentage values to user units and is also used to determine which element's content attribute to update if the object reflects an attribute. Unless otherwise described, an SVGLength object is not associated with any element and has unspecified directionality.

An SVGLength object maintains an internal <length> or <percentage> or <number> value, which is called its value.

[Exposed=Window]
interface SVGLength {

  // Length Unit Types
  const unsigned short SVG_LENGTHTYPE_UNKNOWN = 0;
  const unsigned short SVG_LENGTHTYPE_NUMBER = 1;
  const unsigned short SVG_LENGTHTYPE_PERCENTAGE = 2;
  const unsigned short SVG_LENGTHTYPE_EMS = 3;
  const unsigned short SVG_LENGTHTYPE_EXS = 4;
  const unsigned short SVG_LENGTHTYPE_PX = 5;
  const unsigned short SVG_LENGTHTYPE_CM = 6;
  const unsigned short SVG_LENGTHTYPE_MM = 7;
  const unsigned short SVG_LENGTHTYPE_IN = 8;
  const unsigned short SVG_LENGTHTYPE_PT = 9;
  const unsigned short SVG_LENGTHTYPE_PC = 10;

  readonly attribute unsigned short unitType;
           attribute float value;
           attribute float valueInSpecifiedUnits;
           attribute DOMString valueAsString;

  void newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
  void convertToSpecifiedUnits(unsigned short unitType);
};

The numeric length unit type constants defined on SVGLength are used to represent the type of an SVGLength's value. Their meanings are as follows:

Constant	Meaning
SVG_LENGTHTYPE_NUMBER	A unitless <number> interpreted as a value in px.
SVG_LENGTHTYPE_PERCENTAGE	A <percentage>.
SVG_LENGTHTYPE_EMS	A <length> with an em unit.
SVG_LENGTHTYPE_EXS	A <length> with an ex unit.
SVG_LENGTHTYPE_PX	A <length> with a px unit.
SVG_LENGTHTYPE_CM	A <length> with a cm unit.
SVG_LENGTHTYPE_MM	A <length> with a mm unit.
SVG_LENGTHTYPE_IN	A <length> with an in unit.
SVG_LENGTHTYPE_PT	A <length> with a pt unit.
SVG_LENGTHTYPE_PC	A <length> with a pc unit.
SVG_LENGTHTYPE_UNKNOWN	Some other type of value.

The use of numeric length unit type constants is an anti-pattern and new constant values will not be introduced for any other units or length types supported by SVGLength. If other types of lengths are supported and used, the SVGLength uses the SVG_LENGTHTYPE_UNKNOWN unit type. See below for details on how the other properties of an SVGLength operate with these types of lengths.

The unitType IDL attribute represents the type of value that the SVGLength's value is. On getting unitType, the following steps are run:

1. If the SVGLength's value is a unitless <number>, a <percentage>, or a <length> with an em, ex, px, cm, mm, in, pt or pc unit, then return the corresponding constant value from the length unit type table above.
2. Otherwise, return SVG_LENGTHTYPE_UNKNOWN.

   For example, for a <length> with a ch unit or one that has a non-scalar value such as calc(), SVG_LENGTHTYPE_UNKNOWN would be returned.

The value IDL attribute represents the SVGLength's value in user units. On getting value, the following steps are run:

1. Let value be the SVGLength's value.
2. If value is a <number>, return that number.
3. Let viewport size be a basis to resolve percentages against, based on the SVGLength's associated element and directionality:

   has no associated element

   size is 100

   has an associated element and horizontal directionality

   size is the width of the associated element's SVG viewport

   has an associated element and vertical directionality

   size is the height of the associated element's SVG viewport

   has an associated element and unspecified directionality

   size is the length of the associated element's SVG viewport diagonal (see Units)

4. Let font size be a basis to resolve font size values against, based on the SVGLength's associated element:

   has no associated element

   font size is the absolute length of the initial value of the font-size property

   has an associated element

   size is the computed value of the associated element's font-size property

5. Return the result of converting value to an absolute length, using viewport size and font size as percentage and font size bases. If the conversion is not possible due to the lack of an associated element, return 0.

On setting value, the following steps are run:

1. If the SVGLength object is read only, then throw a NoModificationAllowedError.
2. Let value be the value being assigned to value.
3. Set the SVGLength's value to a <number> whose value is value.
4. If the SVGLength reflects the base value of a reflected attribute, reflects a presentation attribute, or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

The valueInSpecifiedUnits IDL attribute represents the numeric factor of the SVGLength's value. On getting valueInSpecifiedUnits, the following steps are run:

1. Let value be the SVGLength's value.
2. If value is a <number>, return that number.
3. Otherwise, if value is a <percentage> or any scalar <length> value, return the numeric factor before its unit.
4. Otherwise, return 0.

   Thus valueInSpecifiedUnits would return 12 for both '12%' and 12em, but 0 would be returned for non-scalar values like calc(12px + 5%).

On setting valueInSpecifiedUnits, the following steps are run:

1. If the SVGLength object is read only, then throw a NoModificationAllowedError.
2. Let value be the value being assigned to valueInSpecifiedUnits.
3. If the SVGLength's value is a <number>, then update its value to value.
4. Otherwise, if the SVGLength's value is a <percentage> or a scalar-valued <length>, then update its numeric factor to value.
5. Otherwise, the SVGLength's value is of some other type. Set it to a <number> whose value is value.
6. If the SVGLength reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

The valueAsString IDL attribute represents the SVGLength's value as a string. On getting valueAsString, the following steps are run:

1. Let value be the SVGLength's value.
2. Let string be an empty string.
3. If value is a <number>, <percentage> or scalar <length> value, then:
   1. Let factor be value's numeric factor, if it is a <percentage> or <length>, or value itself it is a <number>.
   2. Append to string an implementation specific string that, if parsed as a <number> using CSS syntax, would return the number value closest to factor, given the implementation's supported real number precision.
   3. If value is a <percentage> then append to string a single U+0025 PERCENT SIGN character.
   4. Otherwise, if value is a <length>, then append to string the canonical spelling of value's unit.
   5. Return string.
4. Otherwise, return an implementation specific string that, if parsed as a <length>, would return the closest length value to value, given the implementation's supported real number precision.

On setting valueAsString, the following steps are run:

1. If the SVGLength object is read only, then throw a NoModificationAllowedError.
2. Let value be the value being assigned to valueAsString.
3. Parse value using the CSS syntax [ <number> | <length> | <percentage> ].
4. If parsing failed, then throw a SyntaxError.
5. Otherwise, parsing succeeded. Set SVGLength's value to the parsed value.
6. If the SVGLength reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

The newValueSpecifiedUnits method is used to set the SVGLength's value in a typed manner. When newValueSpecifiedUnits(unitType, valueInSpecifiedUnits) is called, the following steps are run:

1. If the SVGLength object is read only, then throw a NoModificationAllowedError.
2. If unitType is SVG_LENGTHTYPE_UNKNOWN or is a value that does not appear in the length unit type table above, then throw a NotSupportedError.
3. Set SVGLength's value depending on the value of unitType:

   SVG_LENGTHTYPE_NUMBER

   a <number> whose value is valueInSpecifiedUnits

   SVG_LENGTHTYPE_PERCENTAGE

   a <percentage> whose numeric factor is valueInSpecifiedUnits

   anything else

   a <length> whose numeric factor is valueInSpecifiedUnits and whose unit is as indicated by the length unit type table above

4. If the SVGLength reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

The convertToSpecifiedUnits method is used to convert the SVGLength's value to a specific type. When convertToSpecifiedUnits(unitType) is called, the following steps are run:

1. If the SVGLength object is read only, then throw a NoModificationAllowedError.
2. If unitType is SVG_LENGTHTYPE_UNKNOWN or is a value that does not appear in the length unit type table above, then throw a NotSupportedError.
3. Let absolute be the value that would be returned from the value member.
4. If unitType is SVG_LENGTHTYPE_NUMBER, then:
   1. Set the SVGLength's value to a <number> whose value is absolute.
5. Otherwise, if unitType is SVG_LENGTHTYPE_PERCENTAGE, then:
   1. Let viewport size be a basis to resolve percentages against, based on the SVGLength's associated element and directionality:

      has no associated element

      size is 100

      has an associated element and horizontal directionality

      size is the width of the associated element's SVG viewport

      has an associated element and vertical directionality

      size is the height of the associated element's SVG viewport

      has an associated element and unspecified directionality

      size is the length of the associated element's SVG viewport diagonal (see Units)

   2. Set the SVGLength's value to the result of converting absolute to a <percentage>, using viewport size as the percentage basis.
6. Otherwise, if unitType is SVG_LENGTHTYPE_EMS or SVG_LENGTHTYPE_EXS, then:
   1. Let font size be a basis to resolve font size values against, based on the SVGLength's associated element:

      has no associated element

      font size is the absolute length of the initial value of the font-size property

      has an associated element

      size is the computed value of the associated element's font-size property

   2. Set the SVGLength's value to the result of converting absolute to a <length> with an em or ex unit (depending on unitType), using font size as the font-size basis.
7. Otherwise:
   1. Set the SVGLength's value to the result of converting absolute to a <length> with the unit found by looking up unitType in the length unit type table above.
8. If the SVGLength reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

4.5.3. Interface SVGAngle

The SVGAngle interface is used to represent a value that can be an <angle> or <number> value.

An SVGAngle object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below. An SVGAngle reflected through the animVal attribute is always read only.

An SVGAngle object can be associated with a particular element. The associated element is used to determine which element's content attribute to update if the object reflects an attribute. Unless otherwise described, an SVGAngle object is not associated with any element.

An SVGAngle object maintains an internal <angle> or <number> value, which is called its value.

[Exposed=Window]
interface SVGAngle {

  // Angle Unit Types
  const unsigned short SVG_ANGLETYPE_UNKNOWN = 0;
  const unsigned short SVG_ANGLETYPE_UNSPECIFIED = 1;
  const unsigned short SVG_ANGLETYPE_DEG = 2;
  const unsigned short SVG_ANGLETYPE_RAD = 3;
  const unsigned short SVG_ANGLETYPE_GRAD = 4;

  readonly attribute unsigned short unitType;
           attribute float value;
           attribute float valueInSpecifiedUnits;
           attribute DOMString valueAsString;

  void newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
  void convertToSpecifiedUnits(unsigned short unitType);
};

The numeric angle unit type constants defined on SVGAngle are used to represent the type of an SVGAngle's value. Their meanings are as follows:

Constant	Meaning
SVG_ANGLETYPE_UNSPECIFIED	A unitless <number> interpreted as a value in degrees.
SVG_ANGLETYPE_DEG	An <angle> with a deg unit.
SVG_ANGLETYPE_RAD	An <angle> with a rad unit.
SVG_ANGLETYPE_GRAD	An <angle> with a grad unit.
SVG_ANGLETYPE_UNKNOWN	Some other type of value.

The use of numeric angle unit type constants is an anti-pattern and new constant values will not be introduced for any other units or angle types supported by SVGAngle. If other types of angles are supported and used, the SVGAngle uses the SVG_ANGLETYPE_UNKNOWN unit type. See below for details on how the other properties of an SVGAngle operate with these types of angles.

The unitType IDL attribute represents the type of value that the SVGAngle's value is. On getting unitType, the following steps are run:

1. If the SVGAngle's value is a unitless <number> or a <length> with a deg, rad or grad unit, then return the corresponding constant value from the angle unit type table above.
2. Otherwise, return SVG_ANGLETYPE_UNKNOWN.

   For example, for an <angle> with a turn unit, SVG_ANGLETYPE_UNKNOWN would be returned.

The value IDL attribute represents the SVGAngle's value in user units. On getting value, the following steps are run:

1. Let value be the SVGAngle's value.
2. If value is a <number>, return that number.
3. Return the result of converting value to an angle in degrees.

On setting value, the following steps are run:

1. If the SVGAngle object is read only, then throw a NoModificationAllowedError.
2. Let value be the value being assigned to value.
3. Set the SVGAngle's value to a <number> whose value is value.
4. If the SVGAngle reflects the base value of a reflected attribute, then reserialize the reflected attribute.

The valueInSpecifiedUnits IDL attribute represents the numeric factor of the SVGAngle's value. On getting valueInSpecifiedUnits, the following steps are run:

1. Let value be the SVGAngle's value.
2. If value is a <number>, return that number.
3. Otherwise, value is an <angle> value. Return the numeric factor before its unit.

On setting valueInSpecifiedUnits, the following steps are run:

1. If the SVGAngle object is read only, then throw a NoModificationAllowedError.
2. Let value be the value being assigned to valueInSpecifiedUnits.
3. If the SVGAngle's value is a <number>, then update its value to value.
4. Otherwise, if the SVGAngle's value is an <angle>, then update its numeric factor to value.
5. If the SVGAngle reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

The valueAsString IDL attribute represents the SVGAngle's value as a string. On getting valueAsString, the following steps are run:

1. Let value be the SVGAngle's value.
2. Let string be an empty string.
3. Let factor be value's numeric factor, if it is an <angle>, or value itself it is a <number>.
4. Append to string an implementation specific string that, if parsed as a <number> using CSS syntax, would return the number value closest to factor, given the implementation's supported real number precision.
5. If value is an <angle>, then append to string the canonical spelling of value's unit.
6. Return string.

On setting valueAsString, the following steps are run:

1. If the SVGAngle object is read only, then throw a NoModificationAllowedError.
2. Let value be the value being assigned to valueAsString.
3. Parse value using the CSS syntax [ <number> | <angle> ].
4. If parsing failed, then throw a SyntaxError.
5. Otherwise, parsing succeeded. Set SVGAngle's value to the parsed value.
6. If the SVGAngle reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

The newValueSpecifiedUnits method is used to set the SVGAngle's value in a typed manner. When newValueSpecifiedUnits(unitType, valueInSpecifiedUnits) is called, the following steps are run:

1. If the SVGAngle object is read only, then throw a NoModificationAllowedError.
2. If unitType is SVG_ANGLETYPE_UNKNOWN or is a value that does not appear in the angle unit type table above, then throw a NotSupportedError.
3. Set SVGAngle's value depending on the value of unitType:

   SVG_ANGLETYPE_UNSPECIFIED

   a <number> whose value is valueInSpecifiedUnits

   anything else

   an <angle> whose numeric factor is valueInSpecifiedUnits and whose unit is as indicated by the angle unit type table above

4. If the SVGAngle reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

The convertToSpecifiedUnits method is used to convert the SVGAngle's value to a specific type. When convertToSpecifiedUnits(unitType) is called, the following steps are run:

1. If the SVGAngle object is read only, then throw a NoModificationAllowedError.
2. If unitType is SVG_ANGLETYPE_UNKNOWN or is a value that does not appear in the angle unit type table above, then throw a NotSupportedError.
3. Let degrees be the value that would be returned from the value member.
4. If unitType is SVG_ANGLETYPE_UNSPECIFIED, then:
   1. Set the SVGAngle's value to a <number> whose value is degrees.
5. Otherwise:
   1. Set the SVGAngle's value to the result of converting degrees to an <angle> with the unit found by looking up unitType in the angle unit type table above.
6. If the SVGAngle reflects the base value of a reflected attribute or reflects an element of the base value of a reflected attribute, then reserialize the reflected attribute.

4.5.4. List interfaces

Some SVG attributes contain lists of values, and to represent these values there are a number of SVG DOM list interfaces, one for each required element type – SVGNumberList, SVGLengthList, SVGPointList, SVGTransformList and SVGStringList. The first four are used to represent the base and animated components of SVGAnimatedNumberList, SVGAnimatedLengthList, SVGAnimatedPoints and SVGTransformList objects, while the fifth, SVGStringList, is used to reflect a few unanimated attributes that take a list of strings.

Most list interfaces take the following form:

interface SVGNameList {

  readonly attribute unsigned long length;
  readonly attribute unsigned long numberOfItems;

  void clear();
  Type initialize(Type newItem);
  getter Type getItem(unsigned long index);
  Type insertItemBefore(Type newItem, unsigned long index);
  Type replaceItem(Type newItem, unsigned long index);
  Type removeItem(unsigned long index);
  Type appendItem(Type newItem);
  setter void (unsigned long index, Type newItem);
};

where Name is a descriptive name for the list element's ("Number", "Length", "Point", "Transform" or "String") and Type is the IDL type of the list's elements (SVGNumber, SVGLength, DOMPoint, SVGTransform or DOMString).

The SVGTransformList interface takes the above form but has two additional methods on it.

All list interface objects apart from SVGTransformList reflect the base value of a reflected content attribute. SVGTransformList objects reflect a presentation attribute (‘transform’, ‘gradientTransform’ or ‘patternTransform’). All list interface objects are associated with a particular element. Unlike SVGLength and similar objects, there are no "detached" list interface objects.

A list interface object maintains an internal list of elements, which is referred to in the text below simply as "the list". The IDL attributes and methods are used to inspect and manipulate elements of the list. The list can also be changed in response to changes to the reflected content attribute and to animation of the content attribute (or, for SVGTransformList objects, in response to changes to the computed value of the transform property).

A list interface object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below. list interface objects reflected through the animVal IDL attribute are always read only.

A list interface object is synchronized by running the following steps:

1. Let value be the base value of the reflected content attribute (using the attribute's initial value if it is not present or invalid).
2. Let length be the number of items in the list.
3. Let new length be the number of values in value. If value is the keyword none (as supported by the transform property), new length is 0.
4. If the list element type is SVGNumber, SVGLength, DOMPoint or SVGTransform, then:
   1. If length > new length, then:
      1. Detach each object in the list at an index greater than or equal to new length.
      2. Truncate the list to length new length.
      3. Set length to new length.
   2. While length < new length:
      1. Let item be a newly created object of the list element type.
      2. Attach item to this list interface object.
      3. Append item to the list.
      4. Set length to length + 1.
   3. Let index be 0.
   4. While index < length:
      1. Let item be the object in the list at index index.
      2. Let v be the value in value at index index.
      3. Set item's value to v.
      4. If item is an SVGTransform object, then set the components of its matrix object to match the new transform function value.
      5. Set index to index + 1.
5. Otherwise, the list element type is DOMString:
   1. Replace the list with a new list consisting of the values in value.

Whenever a list element object is to be detached, the following steps are run, depending on the list element type:

SVGNumber

Set the SVGNumber to no longer be associated with any element. If the SVGNumber is read only, set it to be no longer read only.

SVGLength

Set the SVGLength to no longer be associated with any element. If the SVGLength is read only, set it to be no longer read only. Set the SVGLength to have unspecified directionality.

DOMPoint

Set the DOMPoint to no longer be associated with any element. If the DOMPoint is read only, set it to be no longer read only.

SVGTransform

Set the SVGTransform to no longer be associated with any element. If the SVGTransform is read only, set it to be no longer read only.

DOMString

Nothing is done.

Whenever a list element object is to be attached, the following steps are run, depending on the list element type:

The supported property indices of a list interface object is the set of all non-negative integers less than the length of the list.

The length and numberOfItems IDL attributes represents the length of the list, and on getting simply return the length of the list.

The clear method is used to remove all items in the list. When clear() is called, the following steps are run:

1. If the list is read only, then throw a NoModificationAllowedError.
2. Detach and then remove all elements in the list.
3. If the list reflects an attribute, or represents the base value of an object that reflects an attribute, then reserialize the reflected attribute.

The initialize method is used to clear the list and add a single, specified value to it. When initialize(newItem) is called, the following steps are run:

1. If the list is read only, then throw a NoModificationAllowedError.
2. Detach and then remove all elements in the list.
3. If newItem is an object type, and newItem is not a detached object, then set newItem to be a newly created object of the same type as newItem and which has the same (number or length) value.
4. Attach newItem to the list interface object.
5. Append newItem to this list.
6. If the list reflects an attribute, or represents the base value of an object that reflects an attribute, then reserialize the reflected attribute.
7. Return newItem.

The getItem method is used to get an item from the list at the specified position. When getItem(index) is called, the following steps are run:

1. If index is greater than or equal to the length of the list, then throw an IndexSizeError.
2. Return the element in the list at position index.

   Note that if the list's element type is an object type, such as SVGLength, then a reference to that object and not a copy of it is returned.

The insertItemBefore method is used to insert an element into the list at a specific position. When insertItemBefore(newItem, index) is called, the following steps are run:

1. If the list is read only, then throw a NoModificationAllowedError.
2. If newItem is an object type, and newItem is not a detached object, then set newItem to be a newly created object of the same type as newItem and which has the same (number or length) value.
3. If index is greater than the length of the list, then set index to be the list length.
4. Insert newItem into the list at index index.
5. Attach newItem to the list interface object.
6. If the list reflects an attribute, or represents the base value of an object that reflects an attribute, then reserialize the reflected attribute.
7. Return newItem.

The replaceItem method is used to replace an existing item in the list with a new item. When replaceItem(newItem, index) is called, the following steps are run:

1. If the list is read only, then throw a NoModificationAllowedError.
2. If index is greater than or equal to the length of the list, then throw an IndexSizeError.
3. If newItem is an object type, and newItem is not a detached object, then set newItem to be a newly created object of the same type as newItem and which has the same (number or length) value.
4. Detach the element in the list at index index.
5. Replace the element in the list at index index with newItem.
6. Attach newItem to the list interface object.
7. If the list reflects an attribute, or represents the base value of an object that reflects an attribute, then reserialize the reflected attribute.
8. Return newItem.

The removeItem method is used to remove an item from the list. When removeItem(index) is called, the following steps are run:

1. If the list is read only, then throw a NoModificationAllowedError.
2. If index is greater than or equal to the length of the list, then throw an IndexSizeError with code.
3. Let item be the list element at index index.
4. Detach item.
5. Remove the list element at index index.
6. Return item.

The appendItem method is used to append an item to the end of the list. When appendItem(newItem) is called, the following steps are run:

1. If the list is read only, then throw a NoModificationAllowedError.
2. If newItem is an object type, and newItem is not a detached object, then set newItem to be a newly created object of the same type as newItem and which has the same (number or length) value.
3. Let index be the length of the list.
4. Append newItem to the end of the list.
5. Attach newItem to the list interface object.
6. If the list reflects an attribute, or represents the base value of an object that reflects an attribute, then reserialize the reflected attribute.
7. Return newItem.

The behavior of the indexed property setter is the same as that for the replaceItem method.

4.5.5. Interface SVGNumberList

The SVGNumberList interface is a list interface whose elements are SVGNumber objects. An SVGNumberList object represents a list of numbers.

[Exposed=Window]
interface SVGNumberList {

  readonly attribute unsigned long length;
  readonly attribute unsigned long numberOfItems;

  void clear();
  SVGNumber initialize(SVGNumber newItem);
  getter SVGNumber getItem(unsigned long index);
  SVGNumber insertItemBefore(SVGNumber newItem, unsigned long index);
  SVGNumber replaceItem(SVGNumber newItem, unsigned long index);
  SVGNumber removeItem(unsigned long index);
  SVGNumber appendItem(SVGNumber newItem);
  setter void (unsigned long index, SVGNumber newItem);
};

The behavior of all of the interface members of SVGNumberList are defined in the List interfaces section above.

4.5.6. Interface SVGLengthList

The SVGLengthList interface is a list interface whose elements are SVGLength objects. An SVGLengthList object represents a list of lengths.

[Exposed=Window]
interface SVGLengthList {

  readonly attribute unsigned long length;
  readonly attribute unsigned long numberOfItems;

  void clear();
  SVGLength initialize(SVGLength newItem);
  getter SVGLength getItem(unsigned long index);
  SVGLength insertItemBefore(SVGLength newItem, unsigned long index);
  SVGLength replaceItem(SVGLength newItem, unsigned long index);
  SVGLength removeItem(unsigned long index);
  SVGLength appendItem(SVGLength newItem);
  setter void (unsigned long index, SVGLength newItem);
};

The behavior of all of the interface members of SVGLengthList are defined in the List interfaces section above.

4.6. DOM interfaces for reflecting SVG attributes

Some IDL attributes reflect the value of a content attribute or a property. The way this reflection is done depends on the type of the IDL attribute:

• If the type of the reflecting IDL attribute is a primitive type (such as long, as used by tabIndex on SVGElement) or DOMString (as used by title on SVGStyleElement), then the rules for reflecting content attributes in IDL attributes in HTML are used.
• If the type of the reflecting IDL attribute is an SVGAnimatedBoolean, SVGAnimatedString, SVGAnimatedEnumeration, SVGAnimatedNumber, SVGAnimatedNumberList, SVGAnimatedLength, SVGAnimatedLengthList, SVGAnimatedAngle, SVGAnimatedRect or SVGAnimatedPreserveAspectRatio, then the rules in the corresponding section defining the reflecting interface are used.

  At a high level, the object's baseVal is used to reflect the value of the content attribute. For objects that reflect a CSS property, the baseVal is used to reflect the presentation attribute.

1. If the reflecting object is a list interface object, then run the steps for synchronizing a list interface object.
2. Otherwise, update the object's value to be the base value of the reflected content attribute (using the attribute's initial value if it is not present or invalid).

   This will, for example, update the value of an SVGLength object.

When a reflected content attribute is to be reserialized, optionally using a specific value, the following steps must be performed:

1. Let value be the specific value given, or the value of the content attribute's reflecting IDL attribute if a specific value was not provided.
2. Depending on value's type:

   SVGAnimatedBoolean

   SVGAnimatedNumber

   SVGAnimatedLength

   SVGAnimatedAngle

   SVGAnimatedRect

   SVGAnimatedString

   SVGAnimatedNumberList

   SVGAnimatedLengthList

   SVGAnimatedTransformList

   Reserialize the content attribute using value's baseVal member.

   SVGAnimatedEnumeration

   1. Let number be the value of value's baseVal member.
   2. Let keyword be the content attribute's keyword value corresponding to number, or the empty string if number is 0.

      This means that if the enumeration value is set to the "unknown" value, the content attribute will be set to the empty string.

   3. Set the content attribute to keyword.

   boolean

   Set the content attribute to "true" if value is true, and "false" otherwise.

   float

   double

   Set the content attribute to an implementation specific string that, if parsed as a <number> using CSS syntax, would return the number value closest to value, given the implementation's supported real number precision.

   SVGLength

   Set the content attribute to the value that would be returned from getting value's valueAsString member.

   SVGAngle

   Set the content attribute to the value that would be returned from getting value's valueAsString member.

   DOMRect

   1. Let components be a list of four values, being the values of the x, y, width and height members of value.
   2. Let serialized components be a list of four strings, where each is an implementation specific string that, if parsed as a <number> using CSS syntax, would return the number value closest to the corresponding value in components, given the implementation's supported real number precision.
   3. Set the content attribute to a string consisting of the strings in serialized components joined and separated by single U+0020 SPACE characters.

   DOMString

   Set the content attribute to value.

   SVGNumberList

   SVGLengthList

   SVGPointList

   SVGTransformList

   SVGStringList

   1. Let elements be the list of values in value.

      The values will be SVGNumber, SVGLength, DOMPoint or SVGTransform objects, or DOMString values, depending on value's type.

   2. Let serialized elements be a list of strings, where each string is formed based on the corresponding value in elements and its type:

      an SVGNumber object

      The string is an implementation specific string that, if parsed as a <number> using CSS syntax, would return the number value closest to the SVGNumber object's value member, given the implementation's supported real number precision.

      an SVGLength object

      The string is the value that would be returned from getting the value's valueAsString member.

      a DOMPoint object

      The string value is computed as follows:

      1. Let string be an empty string.
      2. Let x and y be the values of the DOMPoint object's x and y coordinates, respectively.
      3. Append to string an implementation specific string that, if parsed as <number> using CSS syntax, would return the number value closest to x, given the implementation's supported real number precision.
      4. Append a single U+002C COMMA character to string.
      5. Append to string an implementation specific string that, if parsed as <number> using CSS syntax, would return the number value closest to y, given the implementation's supported real number precision.
      6. The string is string.

      a SVGTransform object

      The string is the serialization of the SVGTransform object's matrix object.

      a DOMString

      The string is the DOMString's value itself.

   3. Set the content attribute to a string consisting of the strings in serialized elements joined and separated by single U+0020 SPACE characters.

4.6.1. Interface SVGAnimatedBoolean

An SVGAnimatedBoolean object is used to reflect an animatable attribute that takes a boolean value.

[Exposed=Window]
interface SVGAnimatedBoolean {
           attribute boolean baseVal;
  readonly attribute boolean animVal;
};

The baseVal and animVal IDL attributes both represent the current non-animated value of the reflected attribute. On getting baseVal or animVal, the following steps are run:

1. Let value be the value of the reflected attribute, or the empty string if it is not present.
2. If value is not "true" or "false", then set value to the reflected attribute's initial value.
3. Return true if value is "true", and false otherwise.

On setting baseVal, the reflected attribute is set to "true" if the value is true, and "false" otherwise.

4.6.2. Interface SVGAnimatedEnumeration

An SVGAnimatedEnumeration object is used to reflect an animatable attribute that takes a keyword value (such as the ‘method’ attribute on ‘textPath’) or to reflect the type of value that an animatable attribute has (done only by the orientType IDL attribute for the ‘marker’ element's ‘orient’ attribute).

[Exposed=Window]
interface SVGAnimatedEnumeration {
           attribute unsigned short baseVal;
  readonly attribute unsigned short animVal;
};

For SVGAnimatedEnumeration objects that reflect an animatable attribute that takes only a keyword value, the baseVal and animVal IDL attributes represents the current non-animated value of the reflected attribute. For orientType, they represent the type of the current non-animated value of the reflected ‘orient’ attribute. On getting baseVal or animVal, the following steps are run:

1. Let value be the value of the reflected attribute (using the attribute's initial value if it is not present or invalid).
2. Return the numeric type value for value, according to the reflecting IDL attribute's definition.

On setting baseVal, the following steps are run:

1. Let value be the value being assigned to baseVal.
2. If value is 0 or is not the numeric type value for any value of the reflected attribute, then set the reflected attribute to the empty string.
3. Otherwise, if the reflecting IDL attribute is orientType and value is SVG_MARKER_ORIENT_ANGLE, then set the reflected attribute to the string "0".
4. Otherwise, value is the numeric type value for a specific, single keyword value for the reflected attribute. Set the reflected attribute to that value.

4.6.3. Interface SVGAnimatedInteger

An SVGAnimatedInteger object is used to reflect an animatable attribute that takes an integer value (such as ‘numOctaves’ on ‘feTurbulence’). It is also used to reflect one part of an animatable attribute that takes an integer followed by an optional second integer (such as ‘order’ on ‘feConvolveMatrix’).

This SVGAnimatedInteger interface is not used in this specification, however the Filter Effects specification has a number of uses of it.

[Exposed=Window]
interface SVGAnimatedInteger {
           attribute long baseVal;
  readonly attribute long animVal;
};

For SVGAnimatedInteger objects that reflect an animatable attribute that takes a single integer value, the baseVal and animVal IDL attributes represent the current non-animated value of the reflected attribute. For those that reflect one integer of an attribute that takes an integer followed by an optional second integer, they represent the current non-animated value of one of the two integers. On getting baseVal or animVal, the following steps are run:

1. Let value be the value of the reflected attribute (using the attribute's initial value if it is not present or invalid).
2. If the reflected attribute is defined to take an integer followed by an optional second integer, then:
   1. If this SVGAnimatedInteger object reflects the first integer, then return the first value in value.
   2. Otherwise, this SVGAnimatedInteger object reflects the second integer. Return the second value in value if it has been explicitly specified, and if not, return the implicit value as described in the definition of the attribute.

      For example, the definition of ‘order’ says that the implicit second integer is the same as the explicit first integer.

3. Otherwise, the reflected attribute is defined to take a single integer value. Return value.

On setting baseVal, the following steps are run:

1. Let value be the value being assigned to baseVal.
2. Let new be a list of integers.
3. If the reflected attribute is defined to take an integer followed by an optional second integer, then:
   1. Let current be the value of the reflected attribute (using the attribute's initial value if it is not present or invalid).
   2. Let first be the first integer in current.
   3. Let second be the second integer in current if it has been explicitly specified, and if not, the implicit value as described in the definition of the attribute.
   4. If this SVGAnimatedInteger object reflects the first integer, then set first to value. Otherwise, set second to value.
   5. Append first to new.
   6. Append second to new.
4. Otherwise, the reflected attribute is defined to take a single integer value. Append value to new.
5. Set the content attribute to a string consisting of each integer in new serialized to an implementation specific string that, if parsed as an <number> using CSS syntax, would return that integer, joined and separated by a single U+0020 SPACE character.

4.6.4. Interface SVGAnimatedNumber

An SVGAnimatedNumber object is used to reflect an animatable attribute that takes a number value (such as ‘pathLength’ on ‘path’). It is also used to reflect one part of an animatable attribute that takes an number followed by an optional second number (such as ‘kernelUnitLength’ on ‘feDiffuseLighting’).

[Exposed=Window]
interface SVGAnimatedNumber {
           attribute float baseVal;
  readonly attribute float animVal;
};

For SVGAnimatedNumber objects that reflect an animatable attribute that takes a single number value, the baseVal and animVal IDL attributes represent the current non-animated value of the reflected attribute. For those that reflect one number of an attribute that takes a number followed by an optional second number, they represent the current non-animated value of one of the two numbers. On getting baseVal or animVal, the following steps are run:

1. Let value be the value of the reflected attribute (using the attribute's initial value if it is not present or invalid).
2. If the reflected attribute is defined to take an number followed by an optional second number, then:
   1. If this SVGAnimatedNumber object reflects the first number, then return the first value in value.
   2. Otherwise, this SVGAnimatedNumber object reflects the second number. Return the second value in value if it has been explicitly specified, and if not, return the implicit value as described in the definition of the attribute.

      For example, the definition of ‘kernelUnitLength’ says that the implicit second number is the same as the explicit first number.

3. Otherwise, the reflected attribute is defined to take a single number value. Return value.

On setting baseVal, the following steps are run:

1. Let value be the value being assigned to baseVal.
2. Let new be a list of numbers.
3. If the reflected attribute is defined to take an number followed by an optional second number, then:
   1. Let current be the value of the reflected attribute (using the attribute's initial value if it is not present or invalid).
   2. Let first be the first number in current.
   3. Let second be the second number in current if it has been explicitly specified, and if not, the implicit value as described in the definition of the attribute.
   4. If this SVGAnimatedNumber object reflects the first number, then set first to value. Otherwise, set second to value.
   5. Append first to new.
   6. Append second to new.
4. Otherwise, the reflected attribute is defined to take a single number value. Append value to new.
5. Set the content attribute to a string consisting of each number in new serialized to an implementation specific string that, if parsed as an <number> using CSS syntax, would return the value closest to the number (given the implementation's supported Precisionreal number precision), joined and separated by a single U+0020 SPACE character.

4.6.5. Interface SVGAnimatedLength

An SVGAnimatedLength object is used to reflect either (a) an animatable attribute that takes a <length>, <percentage> or <number> value, or (b) a CSS property that takes one of these values and its corresponding presentation attribute.

[Exposed=Window]
interface SVGAnimatedLength {
  [SameObject] readonly attribute SVGLength baseVal;
  [SameObject] readonly attribute SVGLength animVal;
};

The baseVal and animVal IDL attributes represent the current value of the reflected content attribute. On getting baseVal or animVal, an SVGLength object is returned that:

• either reflects the base value of the reflected attribute or reflects the given presentation attribute,
• is associated with the SVG element that the object with the reflecting IDL attribute of type SVGAnimatedLength was obtained from, and
• has a directionality as defined by the specific reflected attribute.

4.6.6. Interface SVGAnimatedAngle

An SVGAnimatedAngle object is used to reflect the <angle> value of the animated ‘orient’ attribute on ‘marker’, through the orientAngle IDL attribute.

[Exposed=Window]
interface SVGAnimatedAngle {
  [SameObject] readonly attribute SVGAngle baseVal;
  [SameObject] readonly attribute SVGAngle animVal;
};

The baseVal and animVal IDL attributes represent the current non-animated <angle> value of the reflected ‘orient’ attribute. On getting baseVal or animVal, an SVGAngle object is returned that:

• reflects the base value of the reflected ‘orient’ attribute, and
• is associated with the SVG ‘marker’ element that the object with the reflecting IDL attribute of type SVGAnimatedAngle was obtained from.

4.6.7. Interface SVGAnimatedString

An SVGAnimatedString object is used to reflect an animatable attribute that takes a string value. It can optionally be defined to additionally reflect a second, deprecated attribute.

[Exposed=Window]
interface SVGAnimatedString {
           attribute DOMString baseVal;
  readonly attribute DOMString animVal;
};

The baseVal and animVal IDL attributes represent the current non-animated value of the reflected attribute. On getting baseVal or animVal, the following steps are run:

1. If the reflected attribute is not present, then:
   1. If the SVGAnimatedString object is defined to additionally reflect a second, deprecated attribute, and that attribute is present, then return its value.
   2. Otherwise, if the reflected attribute has an initial value, then return it.
   3. Otherwise, return the empty string.
2. Otherwise, the reflected attribute is present. Return its value.

For the href member on the SVGURIReference interface, this will result in the deprecated ‘xlink:href’ attribute being returned if it is present and the ‘href’ attribute is not, and in the ‘href’ attribute being returned in all other cases.

On setting baseVal, the following steps are run:

1. If the reflected attribute is not present, the SVGAnimatedString object is defined to additionally reflect a second, deprecated attribute, and that deprecated attribute is present, then set that deprecated attribute to the specified value.
2. Otherwise, set the reflected attribute to the specified value.

For the href member on the SVGURIReference interface, this will result in the deprecated ‘xlink:href’ attribute being set if it is present and the ‘href’ attribute is not, and in the ‘href’ attribute being set in all other cases.

4.6.8. Interface SVGAnimatedRect

An SVGAnimatedRect object is used to reflect an animatable attribute that takes a rectangle value as specified by an x, y, width and height.

In this specification the only attribute to be reflected as an SVGAnimatedRect is ‘viewBox’.

[Exposed=Window]
interface SVGAnimatedRect {
  [SameObject] readonly attribute DOMRect baseVal;
  [SameObject] readonly attribute DOMRectReadOnly animVal;
};

The baseVal and animVal IDL attributes represent the current non-animated rectangle value of the reflected attribute. On getting baseVal or animVal, a DOMRect object is returned.

Upon creation of the baseVal or animVal DOMRect objects, and afterwards whenever the reflected content attribute is added, removed, or changed, the following steps are run:

1. Let value be the value of the reflected attribute (using the attribute's initial value if it is not present or invalid).
2. Let x, y, width and height be those corresponding components of value.
3. Set the DOMRect object's x coordinate, y coordinate, width and height to x, y, width and height, respectively.

Whenever the x coordinate, y coordinate, width or height property of the baseVal or animVal DOMRect object changes, except as part of the previous algorithm that reflects the value of the content attribute into the DOMRect, the reflected content attribute must be reserialized.

4.6.9. Interface SVGAnimatedNumberList

An SVGAnimatedNumberList object is used to reflect an animatable attribute that takes a list of <number> values.

[Exposed=Window]
interface SVGAnimatedNumberList {
  [SameObject] readonly attribute SVGNumberList baseVal;
  [SameObject] readonly attribute SVGNumberList animVal;
};

The baseVal and animVal IDL attributes represent the current non-animated value of the reflected attribute. On getting baseVal or animVal, an SVGNumberList object is returned that reflects the base value of the reflected attribute.

4.6.10. Interface SVGAnimatedLengthList

An SVGAnimatedLengthList object is used to reflect an animatable attribute that takes a list of <length>, <percentage> or <number> values.

[Exposed=Window]
interface SVGAnimatedLengthList {
  [SameObject] readonly attribute SVGLengthList baseVal;
  [SameObject] readonly attribute SVGLengthList animVal;
};

The baseVal or animVal IDL attributes represent the current non-animated value of the reflected attribute. On getting baseVal or animVal, an SVGLengthList object is returned that reflects the base value of the reflected attribute.

4.6.11. Interface SVGStringList

The SVGStringList interface is a list interface whose elements are DOMString values. An SVGStringList object represents a list of strings.

[Exposed=Window]
interface SVGStringList {

  readonly attribute unsigned long length;
  readonly attribute unsigned long numberOfItems;

  void clear();
  DOMString initialize(DOMString newItem);
  getter DOMString getItem(unsigned long index);
  DOMString insertItemBefore(DOMString newItem, unsigned long index);
  DOMString replaceItem(DOMString newItem, unsigned long index);
  DOMString removeItem(unsigned long index);
  DOMString appendItem(DOMString newItem);
  setter void (unsigned long index, DOMString newItem);
};

The behavior of all of the interface members of SVGStringList are defined in the List interfaces section above.

4.7. Other DOM interfaces

4.7.1. Interface SVGUnitTypes

The SVGUnitTypes interface defines a commonly used set of constants used for reflecting ‘gradientUnits’, ‘patternContentUnits’ and other similar attributes.

[Exposed=Window]
interface SVGUnitTypes {
  // Unit Types
  const unsigned short SVG_UNIT_TYPE_UNKNOWN = 0;
  const unsigned short SVG_UNIT_TYPE_USERSPACEONUSE = 1;
  const unsigned short SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2;
};

The unit type constants defined on SVGUnitTypes have the following meanings:

Constant	Meaning
SVG_UNIT_TYPE_USERSPACEONUSE	Corresponds to the 'userSpaceOnUse' attribute value.
SVG_UNIT_TYPE_OBJECTBOUNDINGBOX	Corresponds to the 'objectBoundingBox' attribute value.
SVG_UNIT_TYPE_UNKNOWN	Some other type of value.

4.7.2. Mixin SVGTests

The SVGTests interface is used to reflect conditional processing attributes, and is mixed in to other interfaces for elements that support these attributes.

interface mixin SVGTests {
  [SameObject] readonly attribute SVGStringList requiredExtensions;
  [SameObject] readonly attribute SVGStringList systemLanguage;
};

The requiredExtensions IDL attribute reflects the ‘requiredExtensions’ content attribute.

The systemLanguage IDL attribute reflects the ‘systemLanguage’ content attribute.

4.7.3. Mixin SVGFitToViewBox

The SVGFitToViewBox interface is used to reflect the ‘viewBox’ and ‘preserveAspectRatio’ attributes, and is mixed in to other interfaces for elements that support these two attributes.

interface mixin SVGFitToViewBox {
  [SameObject] readonly attribute SVGAnimatedRect viewBox;
  [SameObject] readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
};

The viewBox IDL attribute reflects the ‘viewBox’ content attribute.

The preserveAspectRatio IDL attribute reflects the ‘preserveAspectRatio’ content attribute.

4.7.4. Mixin SVGZoomAndPan

The SVGZoomAndPan interface is used to reflect the ‘zoomAndPan’ attribute, and is mixed in to other interfaces for elements that support this attribute.

interface mixin SVGZoomAndPan {

  // Zoom and Pan Types
  const unsigned short SVG_ZOOMANDPAN_UNKNOWN = 0;
  const unsigned short SVG_ZOOMANDPAN_DISABLE = 1;
  const unsigned short SVG_ZOOMANDPAN_MAGNIFY = 2;

  attribute unsigned short zoomAndPan;
};

The zoom and pan type constants defined on SVGZoomAndPan have the following meanings:

Constant	Meaning
SVG_ZOOMANDPAN_DISABLE	Corresponds to the 'disable' attribute value.
SVG_ZOOMANDPAN_MAGNIFY	Corresponds to the 'magnify' attribute value.
SVG_ZOOMANDPAN_UNKNOWN	Some other type of value.

The zoomAndPan IDL attribute represents the value of the ‘zoomAndPan’ attribute. On getting zoomAndPan, the following steps are run:

1. Let value be the current value of the ‘zoomAndPan’ attribute (using the attribute's initial value if it is not present or invalid).
2. Return the corresponding constant in the zoom and pan type constant table above for value.

On setting zoomAndPan, the following steps are run:

1. Let value be the value being assigned to a zoomAndPan.
2. If value is SVG_ZOOMANDPAN_UNKNOWN or does not correspond to an entry in the zoom and pan type constant table above, then return.
3. Set the ‘zoomAndPan’ attribute to the keyword value in the zoom and pan type constant table above that corresponds to value.

4.7.5. Mixin SVGURIReference

The SVGURIReference interface is used to reflect the ‘href’ attribute and the deprecated ‘xlink:href’ attribute.

interface mixin SVGURIReference {
  [SameObject] readonly attribute SVGAnimatedString href;
};

The href IDL attribute represents the value of the ‘href’ attribute, and, on elements that are defined to support it, the deprecated ‘xlink:href’ attribute. On getting href, an SVGAnimatedString object is returned that:

• reflects the ‘href’ attribute, and
• if the element is defined to support the deprecated ‘xlink:href’ attribute, additionally reflects that deprecated attribute.

The SVGAnimatedString interface is defined to reflect, through its baseVal and animVal members, the deprecated ‘xlink:href’ attribute, if that attribute is present and the ‘href’ is not, and to reflect the ‘href’ attribute in all other circumstances. Animation elements treat attributeName='xlink:href' as being an alias for targetting the ‘href’ attribute.