Skip to main content

Browse the archive

https://github.com/web-platform-tests/wpt
26 December 2018, 22:31:15 UTC
Raw File
Tip revision: 1ea1164abf90d96f40b93221795734fd97acc605 authored by Chandan Padhi on 26 March 2018, 10:09:55 UTC
Add support for autoGainControl and noiseSuppression to getCapabilities()
Tip revision: 1ea1164
interfaces.html 
<!doctype html>
<title>SVG interface tests</title>
<meta name=timeout content=long>
<div id=log></div>
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=/resources/WebIDLParser.js></script>
<script src=/resources/idlharness.js></script>
<script type=text/plain id=untested_idl>
interface EventTarget {};
interface Node : EventTarget {};
interface Document : Node {};
interface ProcessingInstruction : Node {};
interface Element : Node {};
interface HTMLElement : Element {};
[Global=Window, Exposed=Window] interface Window {};

// Just need to know that DOMStringMap exists; its details are tested elsewhere.
interface DOMStringMap { };

[TreatNonObjectAsNull]
callback EventHandlerNonNull = any (Event event);
typedef EventHandlerNonNull? EventHandler;

[TreatNonObjectAsNull]
callback OnErrorEventHandlerNonNull = any ((Event or DOMString) event, optional DOMString source, optional unsigned long lineno, optional unsigned long column, optional any error);
typedef OnErrorEventHandlerNonNull? OnErrorEventHandler;

[TreatNonObjectAsNull]
callback OnBeforeUnloadEventHandlerNonNull = DOMString? (Event event);
typedef OnBeforeUnloadEventHandlerNonNull? OnBeforeUnloadEventHandler;

[NoInterfaceObject]
interface GlobalEventHandlers {
  attribute EventHandler onabort;
  attribute EventHandler onautocomplete;
  attribute EventHandler onautocompleteerror;
  attribute EventHandler onblur;
  attribute EventHandler oncancel;
  attribute EventHandler oncanplay;
  attribute EventHandler oncanplaythrough;
  attribute EventHandler onchange;
  attribute EventHandler onclick;
  attribute EventHandler onclose;
  attribute EventHandler oncontextmenu;
  attribute EventHandler oncuechange;
  attribute EventHandler ondblclick;
  attribute EventHandler ondrag;
  attribute EventHandler ondragend;
  attribute EventHandler ondragenter;
  attribute EventHandler ondragexit;
  attribute EventHandler ondragleave;
  attribute EventHandler ondragover;
  attribute EventHandler ondragstart;
  attribute EventHandler ondrop;
  attribute EventHandler ondurationchange;
  attribute EventHandler onemptied;
  attribute EventHandler onended;
  attribute OnErrorEventHandler onerror;
  attribute EventHandler onfocus;
  attribute EventHandler oninput;
  attribute EventHandler oninvalid;
  attribute EventHandler onkeydown;
  attribute EventHandler onkeypress;
  attribute EventHandler onkeyup;
  attribute EventHandler onload;
  attribute EventHandler onloadeddata;
  attribute EventHandler onloadedmetadata;
  attribute EventHandler onloadstart;
  attribute EventHandler onmousedown;
  [LenientThis] attribute EventHandler onmouseenter;
  [LenientThis] attribute EventHandler onmouseleave;
  attribute EventHandler onmousemove;
  attribute EventHandler onmouseout;
  attribute EventHandler onmouseover;
  attribute EventHandler onmouseup;
  attribute EventHandler onwheel;
  attribute EventHandler onpause;
  attribute EventHandler onplay;
  attribute EventHandler onplaying;
  attribute EventHandler onprogress;
  attribute EventHandler onratechange;
  attribute EventHandler onreset;
  attribute EventHandler onresize;
  attribute EventHandler onscroll;
  attribute EventHandler onseeked;
  attribute EventHandler onseeking;
  attribute EventHandler onselect;
  attribute EventHandler onshow;
  attribute EventHandler onsort;
  attribute EventHandler onstalled;
  attribute EventHandler onsubmit;
  attribute EventHandler onsuspend;
  attribute EventHandler ontimeupdate;
  attribute EventHandler ontoggle;
  attribute EventHandler onvolumechange;
  attribute EventHandler onwaiting;
};

[NoInterfaceObject]
interface WindowEventHandlers {
  attribute EventHandler onafterprint;
  attribute EventHandler onbeforeprint;
  attribute OnBeforeUnloadEventHandler onbeforeunload;
  attribute EventHandler onhashchange;
  attribute EventHandler onlanguagechange;
  attribute EventHandler onmessage;
  attribute EventHandler onoffline;
  attribute EventHandler ononline;
  attribute EventHandler onpagehide;
  attribute EventHandler onpageshow;
  attribute EventHandler onpopstate;
  attribute EventHandler onrejectionhandled;
  attribute EventHandler onstorage;
  attribute EventHandler onunhandledrejection;
  attribute EventHandler onunload;
};

[NoInterfaceObject]interface LinkStyle {
  readonly attribute StyleSheet? sheet;
};


[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
             optional unrestricted double z = 0, optional unrestricted double w = 1),
 Exposed=(Window,Worker)]
interface DOMPointReadOnly {
    [NewObject] static DOMPointReadOnly fromPoint(optional DOMPointInit point);

    readonly attribute unrestricted double x;
    readonly attribute unrestricted double y;
    readonly attribute unrestricted double z;
    readonly attribute unrestricted double w;

    DOMPoint matrixTransform(optional DOMMatrixInit matrix);
};

[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
             optional unrestricted double z = 0, optional unrestricted double w = 1),
 Exposed=(Window,Worker)]
interface DOMPoint : DOMPointReadOnly {
    [NewObject] static DOMPoint fromPoint(optional DOMPointInit other);

    inherit attribute unrestricted double x;
    inherit attribute unrestricted double y;
    inherit attribute unrestricted double z;
    inherit attribute unrestricted double w;
};

dictionary DOMPointInit {
    unrestricted double x = 0;
    unrestricted double y = 0;
    unrestricted double z = 0;
    unrestricted double w = 1;
};

[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
             optional unrestricted double width = 0, optional unrestricted double height = 0),
 Exposed=(Window,Worker)]
interface DOMRectReadOnly {
    [NewObject] static DOMRectReadOnly fromRect(optional DOMRectInit other);

    readonly attribute unrestricted double x;
    readonly attribute unrestricted double y;
    readonly attribute unrestricted double width;
    readonly attribute unrestricted double height;
    readonly attribute unrestricted double top;
    readonly attribute unrestricted double right;
    readonly attribute unrestricted double bottom;
    readonly attribute unrestricted double left;
};

[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
             optional unrestricted double width = 0, optional unrestricted double height = 0),
 Exposed=(Window,Worker)]
interface DOMRect : DOMRectReadOnly {
    [NewObject] static DOMRect fromRect(optional DOMRectInit other);

    inherit attribute unrestricted double x;
    inherit attribute unrestricted double y;
    inherit attribute unrestricted double width;
    inherit attribute unrestricted double height;
};

dictionary DOMRectInit {
    unrestricted double x = 0;
    unrestricted double y = 0;
    unrestricted double width = 0;
    unrestricted double height = 0;
};

[Constructor(sequence<unrestricted double> numberSequence),
 Exposed=(Window,Worker)]
interface DOMMatrixReadOnly {
    [NewObject] static DOMMatrixReadOnly fromMatrix(optional DOMMatrixInit other);
    [NewObject] static DOMMatrixReadOnly fromString(DOMString transformList);
    [NewObject] static DOMMatrixReadOnly fromFloat32Array(Float32Array array32);
    [NewObject] static DOMMatrixReadOnly fromFloat64Array(Float64Array array64);

    // These attributes are simple aliases for certain elements of the 4x4 matrix
    readonly attribute unrestricted double a;
    readonly attribute unrestricted double b;
    readonly attribute unrestricted double c;
    readonly attribute unrestricted double d;
    readonly attribute unrestricted double e;
    readonly attribute unrestricted double f;

    readonly attribute unrestricted double m11;
    readonly attribute unrestricted double m12;
    readonly attribute unrestricted double m13;
    readonly attribute unrestricted double m14;
    readonly attribute unrestricted double m21;
    readonly attribute unrestricted double m22;
    readonly attribute unrestricted double m23;
    readonly attribute unrestricted double m24;
    readonly attribute unrestricted double m31;
    readonly attribute unrestricted double m32;
    readonly attribute unrestricted double m33;
    readonly attribute unrestricted double m34;
    readonly attribute unrestricted double m41;
    readonly attribute unrestricted double m42;
    readonly attribute unrestricted double m43;
    readonly attribute unrestricted double m44;

    readonly attribute boolean is2D;
    readonly attribute boolean isIdentity;

    // Immutable transform methods
    DOMMatrix translate(unrestricted double tx,
                        unrestricted double ty,
                        optional unrestricted double tz = 0);
    DOMMatrix scale(unrestricted double scale,
                    optional unrestricted double originX = 0,
                    optional unrestricted double originY = 0);
    DOMMatrix scale3d(unrestricted double scale,
                      optional unrestricted double originX = 0,
                      optional unrestricted double originY = 0,
                      optional unrestricted double originZ = 0);
    DOMMatrix scaleNonUniform(unrestricted double scaleX,
                              optional unrestricted double scaleY = 1,
                              optional unrestricted double scaleZ = 1,
                              optional unrestricted double originX = 0,
                              optional unrestricted double originY = 0,
                              optional unrestricted double originZ = 0);
    DOMMatrix rotate(unrestricted double angle,
                     optional unrestricted double originX = 0,
                     optional unrestricted double originY = 0);
    DOMMatrix rotateFromVector(unrestricted double x,
                               unrestricted double y);
    DOMMatrix rotateAxisAngle(unrestricted double x,
                              unrestricted double y,
                              unrestricted double z,
                              unrestricted double angle);
    DOMMatrix skewX(unrestricted double sx);
    DOMMatrix skewY(unrestricted double sy);
    DOMMatrix multiply(optional DOMMatrixInit other);
    DOMMatrix flipX();
    DOMMatrix flipY();
    DOMMatrix inverse();

    DOMPoint            transformPoint(optional DOMPointInit point);
    Float32Array        toFloat32Array();
    Float64Array        toFloat64Array();
                        stringifier;
};

[Constructor(sequence<unrestricted double> numberSequence),
 Exposed=(Window,Worker)]
interface DOMMatrix : DOMMatrixReadOnly {
    [NewObject] static DOMMatrix fromMatrix(optional DOMMatrixInit other);
    [NewObject] static DOMMatrix fromString(DOMString transformList);
    [NewObject] static DOMMatrix fromFloat32Array(Float32Array array32);
    [NewObject] static DOMMatrix fromFloat64Array(Float64Array array64);

    // These attributes are simple aliases for certain elements of the 4x4 matrix
    inherit attribute unrestricted double a;
    inherit attribute unrestricted double b;
    inherit attribute unrestricted double c;
    inherit attribute unrestricted double d;
    inherit attribute unrestricted double e;
    inherit attribute unrestricted double f;

    inherit attribute unrestricted double m11;
    inherit attribute unrestricted double m12;
    inherit attribute unrestricted double m13;
    inherit attribute unrestricted double m14;
    inherit attribute unrestricted double m21;
    inherit attribute unrestricted double m22;
    inherit attribute unrestricted double m23;
    inherit attribute unrestricted double m24;
    inherit attribute unrestricted double m31;
    inherit attribute unrestricted double m32;
    inherit attribute unrestricted double m33;
    inherit attribute unrestricted double m34;
    inherit attribute unrestricted double m41;
    inherit attribute unrestricted double m42;
    inherit attribute unrestricted double m43;
    inherit attribute unrestricted double m44;

    // Mutable transform methods
    DOMMatrix multiplySelf(optional DOMMatrixInit other);
    DOMMatrix preMultiplySelf(optional DOMMatrixInit other);
    DOMMatrix translateSelf(unrestricted double tx,
                     unrestricted double ty,
                     optional unrestricted double tz = 0);
    DOMMatrix scaleSelf(unrestricted double scale,
                 optional unrestricted double originX = 0,
                 optional unrestricted double originY = 0);
    DOMMatrix scale3dSelf(unrestricted double scale,
                   optional unrestricted double originX = 0,
                   optional unrestricted double originY = 0,
                   optional unrestricted double originZ = 0);
    DOMMatrix scaleNonUniformSelf(unrestricted double scaleX,
                           optional unrestricted double scaleY = 1,
                           optional unrestricted double scaleZ = 1,
                           optional unrestricted double originX = 0,
                           optional unrestricted double originY = 0,
                           optional unrestricted double originZ = 0);
    DOMMatrix rotateSelf(unrestricted double angle,
                  optional unrestricted double originX = 0,
                  optional unrestricted double originY = 0);
    DOMMatrix rotateFromVectorSelf(unrestricted double x,
                            unrestricted double y);
    DOMMatrix rotateAxisAngleSelf(unrestricted double x,
                           unrestricted double y,
                           unrestricted double z,
                           unrestricted double angle);
    DOMMatrix skewXSelf(unrestricted double sx);
    DOMMatrix skewYSelf(unrestricted double sy);
    DOMMatrix invertSelf();

    DOMMatrix setMatrixValue(DOMString transformList);
};

dictionary DOMMatrixInit {
    unrestricted double a;
    unrestricted double b;
    unrestricted double c;
    unrestricted double d;
    unrestricted double e;
    unrestricted double f;
    unrestricted double m11;
    unrestricted double m12;
    unrestricted double m13 = 0;
    unrestricted double m14 = 0;
    unrestricted double m21;
    unrestricted double m22;
    unrestricted double m23 = 0;
    unrestricted double m24 = 0;
    unrestricted double m31 = 0;
    unrestricted double m32 = 0;
    unrestricted double m33 = 1;
    unrestricted double m34 = 0;
    unrestricted double m41;
    unrestricted double m42;
    unrestricted double m43 = 0;
    unrestricted double m44 = 1;
    boolean is2D;
};
</script>
<script type=text/plain id=idl>
interface SVGElement : Element {

  [SameObject] readonly attribute SVGAnimatedString className;
  [SameObject] readonly attribute DOMStringMap dataset;

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

  attribute long tabIndex;
  void focus();
  void blur();
};

SVGElement implements GlobalEventHandlers;

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 implements SVGTests;

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

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

interface SVGNumber {
  attribute float value;
};

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);
};

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);
};

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);
};

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);
};

interface SVGAnimatedBoolean {
           attribute boolean baseVal;
  readonly attribute boolean animVal;
};

interface SVGAnimatedEnumeration {
           attribute unsigned short baseVal;
  readonly attribute unsigned short animVal;
};

interface SVGAnimatedInteger {
           attribute long baseVal;
  readonly attribute long animVal;
};

interface SVGAnimatedNumber {
           attribute float baseVal;
  readonly attribute float animVal;
};

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

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

interface SVGAnimatedString {
           attribute DOMString baseVal;
  readonly attribute DOMString animVal;
};

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

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

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

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);
};

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;
};

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

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

[NoInterfaceObject]
interface 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;
};

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

partial interface Document {
  readonly attribute SVGSVGElement? rootElement;
};

interface SVGSVGElement : SVGGraphicsElement {

  [SameObject] readonly attribute SVGAnimatedLength x;
  [SameObject] readonly attribute SVGAnimatedLength y;
  [SameObject] readonly attribute SVGAnimatedLength width;
  [SameObject] readonly attribute SVGAnimatedLength height;

  attribute float currentScale;
  [SameObject] readonly attribute DOMPointReadOnly currentTranslate;

  NodeList getIntersectionList(DOMRectReadOnly rect, SVGElement? referenceElement);
  NodeList getEnclosureList(DOMRectReadOnly rect, SVGElement? referenceElement);
  boolean checkIntersection(SVGElement element, DOMRectReadOnly rect);
  boolean checkEnclosure(SVGElement element, DOMRectReadOnly rect);

  void deselectAll();

  SVGNumber createSVGNumber();
  SVGLength createSVGLength();
  SVGAngle createSVGAngle();
  DOMPoint createSVGPoint();
  DOMMatrix createSVGMatrix();
  DOMRect createSVGRect();
  SVGTransform createSVGTransform();
  SVGTransform createSVGTransformFromMatrix(DOMMatrixReadOnly matrix);

  // Deprecated methods that have no effect when called,
  // but which are kept for compatibility reasons.
  unsigned long suspendRedraw(unsigned long maxWaitMilliseconds);
  void unsuspendRedraw(unsigned long suspendHandleID);
  void unsuspendRedrawAll();
  void forceRedraw();
};

SVGSVGElement implements SVGFitToViewBox;
SVGSVGElement implements SVGZoomAndPan;
SVGSVGElement implements WindowEventHandlers;

interface SVGGElement : SVGGraphicsElement {
};

interface SVGUnknownElement : SVGGraphicsElement {
};

interface SVGDefsElement : SVGGraphicsElement {
};

interface SVGDescElement : SVGElement {
};

interface SVGMetadataElement : SVGElement {
};

interface SVGTitleElement : SVGElement {
};

interface SVGSymbolElement : SVGElement {
};

SVGSymbolElement implements SVGFitToViewBox;

interface SVGUseElement : SVGGraphicsElement {
  [SameObject] readonly attribute SVGAnimatedLength x;
  [SameObject] readonly attribute SVGAnimatedLength y;
  [SameObject] readonly attribute SVGAnimatedLength width;
  [SameObject] readonly attribute SVGAnimatedLength height;
};

SVGUseElement implements SVGURIReference;

interface SVGSwitchElement : SVGGraphicsElement {
};

[NoInterfaceObject]
interface GetSVGDocument {
  Document getSVGDocument();
};

interface SVGStyleElement : SVGElement {
  attribute DOMString type;
  attribute DOMString media;
  attribute DOMString title;
};

SVGStyleElement implements LinkStyle;

interface SVGTransform {

  // Transform Types
  const unsigned short SVG_TRANSFORM_UNKNOWN = 0;
  const unsigned short SVG_TRANSFORM_MATRIX = 1;
  const unsigned short SVG_TRANSFORM_TRANSLATE = 2;
  const unsigned short SVG_TRANSFORM_SCALE = 3;
  const unsigned short SVG_TRANSFORM_ROTATE = 4;
  const unsigned short SVG_TRANSFORM_SKEWX = 5;
  const unsigned short SVG_TRANSFORM_SKEWY = 6;

  readonly attribute unsigned short type;
  [SameObject] readonly attribute DOMMatrix matrix;
  readonly attribute float angle;

  void setMatrix(DOMMatrixReadOnly matrix);
  void setTranslate(float tx, float ty);
  void setScale(float sx, float sy);
  void setRotate(float angle, float cx, float cy);
  void setSkewX(float angle);
  void setSkewY(float angle);
};

interface SVGTransformList {

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

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

  // Additional methods not common to other list interfaces.
  SVGTransform createSVGTransformFromMatrix(DOMMatrixReadOnly matrix);
  SVGTransform? consolidate();
};

interface SVGAnimatedTransformList {
  [SameObject] readonly attribute SVGTransformList baseVal;
  [SameObject] readonly attribute SVGTransformList animVal;
};

interface SVGPreserveAspectRatio {

  // Alignment Types
  const unsigned short SVG_PRESERVEASPECTRATIO_UNKNOWN = 0;
  const unsigned short SVG_PRESERVEASPECTRATIO_NONE = 1;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMINYMIN = 2;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMIDYMIN = 3;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMAXYMIN = 4;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMINYMID = 5;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMIDYMID = 6;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMAXYMID = 7;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMINYMAX = 8;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMIDYMAX = 9;
  const unsigned short SVG_PRESERVEASPECTRATIO_XMAXYMAX = 10;

  // Meet-or-slice Types
  const unsigned short SVG_MEETORSLICE_UNKNOWN = 0;
  const unsigned short SVG_MEETORSLICE_MEET = 1;
  const unsigned short SVG_MEETORSLICE_SLICE = 2;

  attribute unsigned short align;
  attribute unsigned short meetOrSlice;
};

interface SVGAnimatedPreserveAspectRatio {
  [SameObject] readonly attribute SVGPreserveAspectRatio baseVal;
  [SameObject] readonly attribute SVGPreserveAspectRatio animVal;
};

interface SVGPathElement : SVGGeometryElement {
};

interface SVGRectElement : SVGGeometryElement {
  [SameObject] readonly attribute SVGAnimatedLength x;
  [SameObject] readonly attribute SVGAnimatedLength y;
  [SameObject] readonly attribute SVGAnimatedLength width;
  [SameObject] readonly attribute SVGAnimatedLength height;
  [SameObject] readonly attribute SVGAnimatedLength rx;
  [SameObject] readonly attribute SVGAnimatedLength ry;
};

interface SVGCircleElement : SVGGeometryElement {
  [SameObject] readonly attribute SVGAnimatedLength cx;
  [SameObject] readonly attribute SVGAnimatedLength cy;
  [SameObject] readonly attribute SVGAnimatedLength r;
};

interface SVGEllipseElement : SVGGeometryElement {
  [SameObject] readonly attribute SVGAnimatedLength cx;
  [SameObject] readonly attribute SVGAnimatedLength cy;
  [SameObject] readonly attribute SVGAnimatedLength rx;
  [SameObject] readonly attribute SVGAnimatedLength ry;
};

interface SVGLineElement : SVGGeometryElement {
  [SameObject] readonly attribute SVGAnimatedLength x1;
  [SameObject] readonly attribute SVGAnimatedLength y1;
  [SameObject] readonly attribute SVGAnimatedLength x2;
  [SameObject] readonly attribute SVGAnimatedLength y2;
};

[NoInterfaceObject]
interface SVGAnimatedPoints {
  [SameObject] readonly attribute SVGPointList points;
  [SameObject] readonly attribute SVGPointList animatedPoints;
};

interface SVGPointList {

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

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

interface SVGPolylineElement : SVGGeometryElement {
};

SVGPolylineElement implements SVGAnimatedPoints;

interface SVGPolygonElement : SVGGeometryElement {
};

SVGPolygonElement implements SVGAnimatedPoints;

interface SVGTextContentElement : SVGGraphicsElement {

  // lengthAdjust Types
  const unsigned short LENGTHADJUST_UNKNOWN = 0;
  const unsigned short LENGTHADJUST_SPACING = 1;
  const unsigned short LENGTHADJUST_SPACINGANDGLYPHS = 2;

  [SameObject] readonly attribute SVGAnimatedLength textLength;
  [SameObject] readonly attribute SVGAnimatedEnumeration lengthAdjust;

  long getNumberOfChars();
  float getComputedTextLength();
  float getSubStringLength(unsigned long charnum, unsigned long nchars);
  DOMPoint getStartPositionOfChar(unsigned long charnum);
  DOMPoint getEndPositionOfChar(unsigned long charnum);
  DOMRect getExtentOfChar(unsigned long charnum);
  float getRotationOfChar(unsigned long charnum);
  long getCharNumAtPosition(DOMPoint point);
  void selectSubString(unsigned long charnum, unsigned long nchars);
};

interface SVGTextPositioningElement : SVGTextContentElement {
  [SameObject] readonly attribute SVGAnimatedLengthList x;
  [SameObject] readonly attribute SVGAnimatedLengthList y;
  [SameObject] readonly attribute SVGAnimatedLengthList dx;
  [SameObject] readonly attribute SVGAnimatedLengthList dy;
  [SameObject] readonly attribute SVGAnimatedNumberList rotate;
};

interface SVGTextElement : SVGTextPositioningElement {
};

interface SVGTSpanElement : SVGTextPositioningElement {
};

interface SVGTextPathElement : SVGTextContentElement {

  // textPath Method Types
  const unsigned short TEXTPATH_METHODTYPE_UNKNOWN = 0;
  const unsigned short TEXTPATH_METHODTYPE_ALIGN = 1;
  const unsigned short TEXTPATH_METHODTYPE_STRETCH = 2;

  // textPath Spacing Types
  const unsigned short TEXTPATH_SPACINGTYPE_UNKNOWN = 0;
  const unsigned short TEXTPATH_SPACINGTYPE_AUTO = 1;
  const unsigned short TEXTPATH_SPACINGTYPE_EXACT = 2;

  [SameObject] readonly attribute SVGAnimatedLength startOffset;
  [SameObject] readonly attribute SVGAnimatedEnumeration method;
  [SameObject] readonly attribute SVGAnimatedEnumeration spacing;
};

SVGTextPathElement implements SVGURIReference;

interface SVGImageElement : SVGGraphicsElement {
  [SameObject] readonly attribute SVGAnimatedLength x;
  [SameObject] readonly attribute SVGAnimatedLength y;
  [SameObject] readonly attribute SVGAnimatedLength width;
  [SameObject] readonly attribute SVGAnimatedLength height;
  [SameObject] readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
  attribute DOMString crossOrigin;
};

SVGImageElement implements SVGURIReference;

interface SVGForeignObjectElement : SVGGraphicsElement {
  [SameObject] readonly attribute SVGAnimatedLength x;
  [SameObject] readonly attribute SVGAnimatedLength y;
  [SameObject] readonly attribute SVGAnimatedLength width;
  [SameObject] readonly attribute SVGAnimatedLength height;
};

interface SVGMarkerElement : SVGElement {

  // Marker Unit Types
  const unsigned short SVG_MARKERUNITS_UNKNOWN = 0;
  const unsigned short SVG_MARKERUNITS_USERSPACEONUSE = 1;
  const unsigned short SVG_MARKERUNITS_STROKEWIDTH = 2;

  // Marker Orientation Types
  const unsigned short SVG_MARKER_ORIENT_UNKNOWN = 0;
  const unsigned short SVG_MARKER_ORIENT_AUTO = 1;
  const unsigned short SVG_MARKER_ORIENT_ANGLE = 2;

  [SameObject] readonly attribute SVGAnimatedLength refX;
  [SameObject] readonly attribute SVGAnimatedLength refY;
  [SameObject] readonly attribute SVGAnimatedEnumeration markerUnits;
  [SameObject] readonly attribute SVGAnimatedLength markerWidth;
  [SameObject] readonly attribute SVGAnimatedLength markerHeight;
  [SameObject] readonly attribute SVGAnimatedEnumeration orientType;
  [SameObject] readonly attribute SVGAnimatedAngle orientAngle;
  attribute DOMString orient;

  void setOrientToAuto();
  void setOrientToAngle(SVGAngle angle);
};

SVGMarkerElement implements SVGFitToViewBox;

interface SVGSolidcolorElement : SVGElement {
};

interface SVGGradientElement : SVGElement {

  // Spread Method Types
  const unsigned short SVG_SPREADMETHOD_UNKNOWN = 0;
  const unsigned short SVG_SPREADMETHOD_PAD = 1;
  const unsigned short SVG_SPREADMETHOD_REFLECT = 2;
  const unsigned short SVG_SPREADMETHOD_REPEAT = 3;

  [SameObject] readonly attribute SVGAnimatedEnumeration gradientUnits;
  [SameObject] readonly attribute SVGAnimatedTransformList gradientTransform;
  [SameObject] readonly attribute SVGAnimatedEnumeration spreadMethod;
};

SVGGradientElement implements SVGURIReference;

interface SVGLinearGradientElement : SVGGradientElement {
  [SameObject] readonly attribute SVGAnimatedLength x1;
  [SameObject] readonly attribute SVGAnimatedLength y1;
  [SameObject] readonly attribute SVGAnimatedLength x2;
  [SameObject] readonly attribute SVGAnimatedLength y2;
};

interface SVGRadialGradientElement : SVGGradientElement {
  [SameObject] readonly attribute SVGAnimatedLength cx;
  [SameObject] readonly attribute SVGAnimatedLength cy;
  [SameObject] readonly attribute SVGAnimatedLength r;
  [SameObject] readonly attribute SVGAnimatedLength fx;
  [SameObject] readonly attribute SVGAnimatedLength fy;
  [SameObject] readonly attribute SVGAnimatedLength fr;
};

interface SVGMeshElement : SVGGradientElement {
};

interface SVGMeshrowElement : SVGElement {
};

interface SVGMeshpatchElement : SVGElement {
};

interface SVGStopElement : SVGElement {
  [SameObject] readonly attribute SVGAnimatedNumber offset;
};

interface SVGPatternElement : SVGElement {
  [SameObject] readonly attribute SVGAnimatedEnumeration patternUnits;
  [SameObject] readonly attribute SVGAnimatedEnumeration patternContentUnits;
  [SameObject] readonly attribute SVGAnimatedTransformList patternTransform;
  [SameObject] readonly attribute SVGAnimatedLength x;
  [SameObject] readonly attribute SVGAnimatedLength y;
  [SameObject] readonly attribute SVGAnimatedLength width;
  [SameObject] readonly attribute SVGAnimatedLength height;
};

SVGPatternElement implements SVGFitToViewBox;
SVGPatternElement implements SVGURIReference;

interface SVGHatchElement : SVGElement {
};

interface SVGHatchpathElement : SVGElement {
};

interface SVGCursorElement : SVGElement {
  [SameObject] readonly attribute SVGAnimatedLength x;
  [SameObject] readonly attribute SVGAnimatedLength y;
};

SVGCursorElement implements SVGURIReference;

interface SVGScriptElement : SVGElement {
  attribute DOMString type;
  attribute DOMString crossOrigin;
};

SVGScriptElement implements SVGURIReference;

interface SVGAElement : SVGGraphicsElement {
  [SameObject] readonly attribute SVGAnimatedString target;
};

SVGAElement implements SVGURIReference;

interface SVGViewElement : SVGElement {};

SVGViewElement implements SVGFitToViewBox;
SVGViewElement implements SVGZoomAndPan;

interface SVGFilterElement : SVGElement {
  readonly attribute SVGAnimatedEnumeration filterUnits;
  readonly attribute SVGAnimatedEnumeration primitiveUnits;
  readonly attribute SVGAnimatedLength x;
  readonly attribute SVGAnimatedLength y;
  readonly attribute SVGAnimatedLength width;
  readonly attribute SVGAnimatedLength height;
};

SVGFilterElement implements SVGURIReference;

[NoInterfaceObject]
interface SVGFilterPrimitiveStandardAttributes {
  readonly attribute SVGAnimatedLength x;
  readonly attribute SVGAnimatedLength y;
  readonly attribute SVGAnimatedLength width;
  readonly attribute SVGAnimatedLength height;
  readonly attribute SVGAnimatedString result;
};

interface SVGFEBlendElement : SVGElement {

  // Blend Mode Types
  const unsigned short SVG_FEBLEND_MODE_UNKNOWN = 0;
  const unsigned short SVG_FEBLEND_MODE_NORMAL = 1;
  const unsigned short SVG_FEBLEND_MODE_MULTIPLY = 2;
  const unsigned short SVG_FEBLEND_MODE_SCREEN = 3;
  const unsigned short SVG_FEBLEND_MODE_DARKEN = 4;
  const unsigned short SVG_FEBLEND_MODE_LIGHTEN = 5;

  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedString in2;
  readonly attribute SVGAnimatedEnumeration mode;
};

SVGFEBlendElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEColorMatrixElement : SVGElement {

  // Color Matrix Types
  const unsigned short SVG_FECOLORMATRIX_TYPE_UNKNOWN = 0;
  const unsigned short SVG_FECOLORMATRIX_TYPE_MATRIX = 1;
  const unsigned short SVG_FECOLORMATRIX_TYPE_SATURATE = 2;
  const unsigned short SVG_FECOLORMATRIX_TYPE_HUEROTATE = 3;
  const unsigned short SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA = 4;

  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedEnumeration type;
  readonly attribute SVGAnimatedNumberList values;
};

SVGFEColorMatrixElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEComponentTransferElement : SVGElement {
  readonly attribute SVGAnimatedString in1;
};

SVGFEComponentTransferElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGComponentTransferFunctionElement : SVGElement {

  // Component Transfer Types
  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN = 0;
  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY = 1;
  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_TABLE = 2;
  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE = 3;
  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_LINEAR = 4;
  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_GAMMA = 5;

  readonly attribute SVGAnimatedEnumeration type;
  readonly attribute SVGAnimatedNumberList tableValues;
  readonly attribute SVGAnimatedNumber slope;
  readonly attribute SVGAnimatedNumber intercept;
  readonly attribute SVGAnimatedNumber amplitude;
  readonly attribute SVGAnimatedNumber exponent;
  readonly attribute SVGAnimatedNumber offset;
};

interface SVGFEFuncRElement : SVGComponentTransferFunctionElement {
};

interface SVGFEFuncGElement : SVGComponentTransferFunctionElement {
};

interface SVGFEFuncBElement : SVGComponentTransferFunctionElement {
};

interface SVGFEFuncAElement : SVGComponentTransferFunctionElement {
};

interface SVGFECompositeElement : SVGElement {

  // Composite Operators
  const unsigned short SVG_FECOMPOSITE_OPERATOR_UNKNOWN = 0;
  const unsigned short SVG_FECOMPOSITE_OPERATOR_OVER = 1;
  const unsigned short SVG_FECOMPOSITE_OPERATOR_IN = 2;
  const unsigned short SVG_FECOMPOSITE_OPERATOR_OUT = 3;
  const unsigned short SVG_FECOMPOSITE_OPERATOR_ATOP = 4;
  const unsigned short SVG_FECOMPOSITE_OPERATOR_XOR = 5;
  const unsigned short SVG_FECOMPOSITE_OPERATOR_ARITHMETIC = 6;

  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedString in2;
  readonly attribute SVGAnimatedEnumeration operator;
  readonly attribute SVGAnimatedNumber k1;
  readonly attribute SVGAnimatedNumber k2;
  readonly attribute SVGAnimatedNumber k3;
  readonly attribute SVGAnimatedNumber k4;
};

SVGFECompositeElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEConvolveMatrixElement : SVGElement {

  // Edge Mode Values
  const unsigned short SVG_EDGEMODE_UNKNOWN = 0;
  const unsigned short SVG_EDGEMODE_DUPLICATE = 1;
  const unsigned short SVG_EDGEMODE_WRAP = 2;
  const unsigned short SVG_EDGEMODE_NONE = 3;

  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedInteger orderX;
  readonly attribute SVGAnimatedInteger orderY;
  readonly attribute SVGAnimatedNumberList kernelMatrix;
  readonly attribute SVGAnimatedNumber divisor;
  readonly attribute SVGAnimatedNumber bias;
  readonly attribute SVGAnimatedInteger targetX;
  readonly attribute SVGAnimatedInteger targetY;
  readonly attribute SVGAnimatedEnumeration edgeMode;
  readonly attribute SVGAnimatedNumber kernelUnitLengthX;
  readonly attribute SVGAnimatedNumber kernelUnitLengthY;
};

SVGFEConvolveMatrixElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEDiffuseLightingElement : SVGElement {
  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedNumber surfaceScale;
  readonly attribute SVGAnimatedNumber diffuseConstant;
  readonly attribute SVGAnimatedNumber kernelUnitLengthX;
  readonly attribute SVGAnimatedNumber kernelUnitLengthY;
};

SVGFEDiffuseLightingElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEDistantLightElement : SVGElement {
  readonly attribute SVGAnimatedNumber azimuth;
  readonly attribute SVGAnimatedNumber elevation;
};

interface SVGFEPointLightElement : SVGElement {
  readonly attribute SVGAnimatedNumber x;
  readonly attribute SVGAnimatedNumber y;
  readonly attribute SVGAnimatedNumber z;
};

interface SVGFESpotLightElement : SVGElement {
  readonly attribute SVGAnimatedNumber x;
  readonly attribute SVGAnimatedNumber y;
  readonly attribute SVGAnimatedNumber z;
  readonly attribute SVGAnimatedNumber pointsAtX;
  readonly attribute SVGAnimatedNumber pointsAtY;
  readonly attribute SVGAnimatedNumber pointsAtZ;
  readonly attribute SVGAnimatedNumber specularExponent;
  readonly attribute SVGAnimatedNumber limitingConeAngle;
};

interface SVGFEDisplacementMapElement : SVGElement {

  // Channel Selectors
  const unsigned short SVG_CHANNEL_UNKNOWN = 0;
  const unsigned short SVG_CHANNEL_R = 1;
  const unsigned short SVG_CHANNEL_G = 2;
  const unsigned short SVG_CHANNEL_B = 3;
  const unsigned short SVG_CHANNEL_A = 4;

  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedString in2;
  readonly attribute SVGAnimatedNumber scale;
  readonly attribute SVGAnimatedEnumeration xChannelSelector;
  readonly attribute SVGAnimatedEnumeration yChannelSelector;
};

SVGFEDisplacementMapElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEDropShadowElement : SVGElement {
  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedNumber dx;
  readonly attribute SVGAnimatedNumber dy;
  readonly attribute SVGAnimatedNumber stdDeviationX;
  readonly attribute SVGAnimatedNumber stdDeviationY;

  void setStdDeviation(float stdDeviationX, float stdDeviationY);
};

SVGFEDropShadowElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEFloodElement : SVGElement {
};

SVGFEFloodElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEGaussianBlurElement : SVGElement {

  // Edge Mode Values
  const unsigned short SVG_EDGEMODE_UNKNOWN = 0;
  const unsigned short SVG_EDGEMODE_DUPLICATE = 1;
  const unsigned short SVG_EDGEMODE_WRAP = 2;
  const unsigned short SVG_EDGEMODE_NONE = 3;

  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedNumber stdDeviationX;
  readonly attribute SVGAnimatedNumber stdDeviationY;
  readonly attribute SVGAnimatedEnumeration edgeMode;

  void setStdDeviation(float stdDeviationX, float stdDeviationY);
};

SVGFEGaussianBlurElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEImageElement : SVGElement {
  readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
  readonly attribute SVGAnimatedString crossOrigin;
};

SVGFEImageElement implements SVGFilterPrimitiveStandardAttributes;
SVGFEImageElement implements SVGURIReference;

interface SVGFEMergeElement : SVGElement {
};

SVGFEMergeElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEMergeNodeElement : SVGElement {
  readonly attribute SVGAnimatedString in1;
};

interface SVGFEMorphologyElement : SVGElement {

  // Morphology Operators
  const unsigned short SVG_MORPHOLOGY_OPERATOR_UNKNOWN = 0;
  const unsigned short SVG_MORPHOLOGY_OPERATOR_ERODE = 1;
  const unsigned short SVG_MORPHOLOGY_OPERATOR_DILATE = 2;

  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedEnumeration operator;
  readonly attribute SVGAnimatedNumber radiusX;
  readonly attribute SVGAnimatedNumber radiusY;
};

SVGFEMorphologyElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFEOffsetElement : SVGElement {
  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedNumber dx;
  readonly attribute SVGAnimatedNumber dy;
};

SVGFEOffsetElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFESpecularLightingElement : SVGElement {
  readonly attribute SVGAnimatedString in1;
  readonly attribute SVGAnimatedNumber surfaceScale;
  readonly attribute SVGAnimatedNumber specularConstant;
  readonly attribute SVGAnimatedNumber specularExponent;
  readonly attribute SVGAnimatedNumber kernelUnitLengthX;
  readonly attribute SVGAnimatedNumber kernelUnitLengthY;
};

SVGFESpecularLightingElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFETileElement : SVGElement {
  readonly attribute SVGAnimatedString in1;
};

SVGFETileElement implements SVGFilterPrimitiveStandardAttributes;

interface SVGFETurbulenceElement : SVGElement {

  // Turbulence Types
  const unsigned short SVG_TURBULENCE_TYPE_UNKNOWN = 0;
  const unsigned short SVG_TURBULENCE_TYPE_FRACTALNOISE = 1;
  const unsigned short SVG_TURBULENCE_TYPE_TURBULENCE = 2;

  // Stitch Options
  const unsigned short SVG_STITCHTYPE_UNKNOWN = 0;
  const unsigned short SVG_STITCHTYPE_STITCH = 1;
  const unsigned short SVG_STITCHTYPE_NOSTITCH = 2;

  readonly attribute SVGAnimatedNumber baseFrequencyX;
  readonly attribute SVGAnimatedNumber baseFrequencyY;
  readonly attribute SVGAnimatedInteger numOctaves;
  readonly attribute SVGAnimatedNumber seed;
  readonly attribute SVGAnimatedEnumeration stitchTiles;
  readonly attribute SVGAnimatedEnumeration type;
};

SVGFETurbulenceElement implements SVGFilterPrimitiveStandardAttributes;
</script>
<script>
var svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
var g = document.createElementNS("http://www.w3.org/2000/svg", "g");
var defs = document.createElementNS("http://www.w3.org/2000/svg", "defs");
var Desc = document.createElementNS("http://www.w3.org/2000/svg", "desc");
var title = document.createElementNS("http://www.w3.org/2000/svg", "title");
var symbol = document.createElementNS("http://www.w3.org/2000/svg", "symbol");
var use = document.createElementNS("http://www.w3.org/2000/svg", "use");
var image = document.createElementNS("http://www.w3.org/2000/svg", "image");
var Switch = document.createElementNS("http://www.w3.org/2000/svg", "switch");
var style = document.createElementNS("http://www.w3.org/2000/svg", "style");
var path = document.createElementNS("http://www.w3.org/2000/svg", "path");
var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
var circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
var ellipse = document.createElementNS("http://www.w3.org/2000/svg", "ellipse");
var line = document.createElementNS("http://www.w3.org/2000/svg", "line");
var polyline = document.createElementNS("http://www.w3.org/2000/svg", "polyline");
var polygon = document.createElementNS("http://www.w3.org/2000/svg", "polygon");
var text = document.createElementNS("http://www.w3.org/2000/svg", "text");
var tspan = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
var tref = document.createElementNS("http://www.w3.org/2000/svg", "tref");
var textPath = document.createElementNS("http://www.w3.org/2000/svg", "textPath");
var altGlyph = document.createElementNS("http://www.w3.org/2000/svg", "altGlyph");
var altGlyphDef = document.createElementNS("http://www.w3.org/2000/svg",
                                           "altGlyphDef");
var altGlyphItem = document.createElementNS("http://www.w3.org/2000/svg",
                                            "altGlyphItem");
var glyphRef = document.createElementNS("http://www.w3.org/2000/svg",
                                        "glyphRef");
var marker = document.createElementNS("http://www.w3.org/2000/svg", "marker");
var colorProfile = document.createElementNS("http://www.w3.org/2000/svg",
                                            "color-profile");
var linearGradient = document.createElementNS("http://www.w3.org/2000/svg",
                                              "linearGradient");
var radialGradient = document.createElementNS("http://www.w3.org/2000/svg",
                                              "radialGradient");
var meshGradient = document.createElementNS("http://www.w3.org/2000/svg",
                                            "meshGradient");
var stop = document.createElementNS("http://www.w3.org/2000/svg", "stop");
var pattern = document.createElementNS("http://www.w3.org/2000/svg", "pattern");
var clipPath = document.createElementNS("http://www.w3.org/2000/svg", "clipPath");
var mask = document.createElementNS("http://www.w3.org/2000/svg", "mask");
var cursor = document.createElementNS("http://www.w3.org/2000/svg", "cursor");
var a = document.createElementNS("http://www.w3.org/2000/svg", "a");
var view = document.createElementNS("http://www.w3.org/2000/svg", "view");
var script = document.createElementNS("http://www.w3.org/2000/svg", "script");
var animate = document.createElementNS("http://www.w3.org/2000/svg", "animate");
var set = document.createElementNS("http://www.w3.org/2000/svg", "set");
var animateMotion = document.createElementNS("http://www.w3.org/2000/svg",
                                             "animateMotion");
var mPath = document.createElementNS("http://www.w3.org/2000/svg", "mPath");
var animateColor = document.createElementNS("http://www.w3.org/2000/svg",
                                            "animateColor");
var animateColor = document.createElementNS("http://www.w3.org/2000/svg",
                                            "animateColor");
var animateTransform = document.createElementNS("http://www.w3.org/2000/svg",
                                                "animateTransform");
var font = document.createElementNS("http://www.w3.org/2000/svg", "font");
var glyph = document.createElementNS("http://www.w3.org/2000/svg", "glyph");
var missingglyph = document.createElementNS("http://www.w3.org/2000/svg",
                                            "missing-glyph");
var khern = document.createElementNS("http://www.w3.org/2000/svg", "hkern");
var vkern = document.createElementNS("http://www.w3.org/2000/svg", "vkern");
var fontface = document.createElementNS("http://www.w3.org/2000/svg", "font-face");
var fontfacesrc = document.createElementNS("http://www.w3.org/2000/svg",
                                           "font-face-src");
var fontfaceuri = document.createElementNS("http://www.w3.org/2000/svg",
                                           "font-face-uri");
var fontfaceformat = document.createElementNS("http://www.w3.org/2000/svg",
                                              "font-face-format");
var fontfacename = document.createElementNS("http://www.w3.org/2000/svg",
                                            "font-face-name");
var metadata = document.createElementNS("http://www.w3.org/2000/svg",
                                        "metadata");
var foreignObject = document.createElementNS("http://www.w3.org/2000/svg",
                                             "foreignObject");
var filter = document.createElementNS("http://www.w3.org/2000/svg", "filter");
var feBlend = document.createElementNS("http://www.w3.org/2000/svg", "feBlend");
var feColorMatrix = document.createElementNS("http://www.w3.org/2000/svg",
                                             "feColorMatrix");
var feComponentTransfer = document.createElementNS("http://www.w3.org/2000/svg",
                                                   "feComponentTransfer");
var feFuncR = document.createElementNS("http://www.w3.org/2000/svg", "feFuncR");
var feFuncG = document.createElementNS("http://www.w3.org/2000/svg", "feFuncG");
var feFuncB = document.createElementNS("http://www.w3.org/2000/svg", "feFuncB");
var feFuncA = document.createElementNS("http://www.w3.org/2000/svg", "feFuncA");
var feComposite = document.createElementNS("http://www.w3.org/2000/svg",
                                           "feComposite");
var feConvolveMatrix = document.createElementNS("http://www.w3.org/2000/svg",
                                                "feConvolveMatrix");
var feDiffuseLighting = document.createElementNS("http://www.w3.org/2000/svg",
                                                 "feDiffuseLighting");
var fePointLight = document.createElementNS("http://www.w3.org/2000/svg",
                                            "fePointLight");
var feSpotLight = document.createElementNS("http://www.w3.org/2000/svg",
                                           "feSpotLight");
var feDisplacementMap = document.createElementNS("http://www.w3.org/2000/svg",
                                                 "feDisplacementMap");
var feDropShadow = document.createElementNS("http://www.w3.org/2000/svg",
                                            "feDropShadow");
var feFlood = document.createElementNS("http://www.w3.org/2000/svg", "feFlood");
var feGaussianBlur = document.createElementNS("http://www.w3.org/2000/svg",
                                              "feGaussianBlur");
var feDisplacementMap = document.createElementNS("http://www.w3.org/2000/svg",
                                                 "feDisplacementMap");
var feDropShadow = document.createElementNS("http://www.w3.org/2000/svg",
                                            "feDropShadow");
var feImage = document.createElementNS("http://www.w3.org/2000/svg", "feImage");
var feMerge = document.createElementNS("http://www.w3.org/2000/svg", "feMerge");
var feMergeNode = document.createElementNS("http://www.w3.org/2000/svg",
                                           "feMergeNode");
var feMorphology = document.createElementNS("http://www.w3.org/2000/svg",
                                            "feMorphology");
var feSpecularLighting = document.createElementNS("http://www.w3.org/2000/svg",
                                                  "feSpecularLighting");
var feTile = document.createElementNS("http://www.w3.org/2000/svg",
                                      "feTile");
var feTurbulence = document.createElementNS("http://www.w3.org/2000/svg",
                                            "feTurbulence");


var idlArray = new IdlArray();
var idls = document.getElementById("idl").textContent;
var untestedIdls = document.getElementById("untested_idl").textContent;
idlArray.add_untested_idls(untestedIdls);
idlArray.add_idls(idls);
idlArray.add_objects({
  SVGAnimatedBoolean: ['feConvolveMatrix.preserveAlpha'],
  SVGAnimatedString: ['a.target'],
  SVGStringList: ['a.requiredExtensions'],
  SVGAnimatedEnumeration: ['text.lengthAdjust'],
  SVGAnimatedInteger: ['feConvolveMatrix.orderX'],
  SVGNumber: ['svg.createSVGNumber()'],
  SVGAnimatedNumber: ['stop.offset'],
  SVGNumberList: ['text.rotate.baseVal'],
  SVGAnimatedNumberList: ['text.rotate'],
  SVGLength: ['svg.createSVGLength()'],
  SVGAnimatedLength: ['svg.x'],
  SVGAnimatedLengthList: ['text.x'],
  SVGAngle: ['svg.createSVGAngle()'],
  SVGAnimatedAngle: ['marker.orientAngle'],
  SVGRect: ['svg.createSVGRect()'],
  SVGAnimatedRect: ['svg.viewBox'],
  SVGSVGElement: ['svg'],
  SVGGElement: ['g'],
  SVGDefsElement: ['defs'],
  SVGDescElement: ['Desc'],
  SVGTitleElement: ['title'],
  SVGSymbolElement: ['symbol'],
  SVGUseElement: ['use'],
  SVGImageElement: ['image'],
  SVGSwitchElement: ['Switch'],
  SVGStyleElement: ['style'],
  SVGPoint: ['svg.createSVGPoint()'],
  SVGPointList: ['polygon.points'],
  SVGMatrix: ['svg.createSVGMatrix()'],
  SVGTransform: ['svg.createSVGTransform()'],
  SVGTransformList: ['pattern.patternTransform.baseVal'],
  SVGAnimatedTransformList: ['pattern.patternTransform'],
  SVGPreserveAspectRatio: ['image.preserveAspectRatio.baseVal'],
  SVGAnimatedPreserveAspectRatio: ['image.preserveAspectRatio'],
  SVGPathSegClosePath: ['path.createSVGPathSegClosePath()'],
  SVGPathSegMovetoAbs: ['path.createSVGPathSegMovetoAbs(0,0)'],
  SVGPathSegMovetoRel: ['path.createSVGPathSegMovetoRel(0,0)'],
  SVGPathSegLinetoAbs: ['path.createSVGPathSegLinetoAbs(0,0)'],
  SVGPathSegLinetoRel: ['path.createSVGPathSegLinetoRel(0,0)'],
  SVGPathSegCurvetoCubicAbs: ['path.createSVGPathSegCurvetoCubicAbs(0,0,0,0,0,0)'],
  SVGPathSegCurvetoCubicRel: ['path.createSVGPathSegCurvetoCubicRel(0,0,0,0,0,0)'],
  SVGPathSegCurvetoQuadraticAbs: ['path.createSVGPathSegCurvetoQuadraticAbs(0,0,0,0)'],
  SVGPathSegCurvetoQuadraticRel: ['path.createSVGPathSegCurvetoQuadraticRel(0,0,0,0)'],
  SVGPathSegArcAbs: ['path.createSVGPathSegArcAbs(0,0,0,0,0,true,true)'],
  SVGPathSegArcRel: ['path.createSVGPathSegArcRel(0,0,0,0,0,true,true)'],
  SVGPathSegLinetoHorizontalAbs: ['path.createSVGPathSegLinetoHorizontalAbs(0)'],
  SVGPathSegLinetoHorizontalRel: ['path.createSVGPathSegLinetoHorizontalRel(0)'],
  SVGPathSegLinetoVerticalAbs: ['path.createSVGPathSegLinetoVerticalAbs(0)'],
  SVGPathSegLinetoVerticalRel: ['path.createSVGPathSegLinetoVerticalRel(0)'],
  SVGPathSegCurvetoCubicSmoothAbs: ['path.createSVGPathSegCurvetoCubicSmoothAbs(0,0,0,0)'],
  SVGPathSegCurvetoCubicSmoothRel: ['path.createSVGPathSegCurvetoCubicSmoothRel(0,0,0,0)'],
  SVGPathSegCurvetoQuadraticSmoothAbs: ['path.createSVGPathSegCurvetoQuadraticSmoothAbs(0,0)'],
  SVGPathSegCurvetoQuadraticSmoothRel: ['path.createSVGPathSegCurvetoQuadraticSmoothRel(0,0)'],
  SVGPathSegList: ['path.pathSegList'],
  SVGPathElement: ['path'],
  SVGRectElement: ['rect'],
  SVGCircleElement: ['circle'],
  SVGEllipseElement: ['ellipse'],
  SVGLineElement: ['line'],
  SVGPolylineElement: ['polyline'],
  SVGPolygonElement: ['polygon'],
  SVGTextElement: ['text'],
  SVGTSpanElement: ['tspan'],
  SVGTRefElement: ['tref'],
  SVGTextPathElement: ['textPath'],
  SVGAltGlyphElement: ['altGlyph'],
  SVGAltGlyphDefElement: ['altGlyphDef'],
  SVGAltGlyphItemElement: ['altGlyphItem'],
  SVGGlyphRefElement: ['glyphRef'],
  SVGMarkerElement: ['marker'],
  SVGColorProfileElement: ['colorProfile'],
  SVGLinearGradientElement: ['linearGradient'],
  SVGRadialGradientElement: ['radialGradient'],
  SVGMeshGradientElement: ['meshGradient'],
  SVGStopElement: ['stop'],
  SVGPatternElement: ['pattern'],
  SVGClipPathElement: ['clipPath'],
  SVGMaskElement: ['mask'],
  SVGCursorElement: ['cursor'],
  SVGAElement: ['a'],
  SVGViewElement: ['view'],
  SVGScriptElement: ['script'],
  SVGAnimateElement: ['animate'],
  SVGSetElement: ['set'],
  SVGAnimateMotionElement: ['animateMotion'],
  SVGMPathElement: ['mPath'],
  SVGAnimateColorElement: ['animateColor'],
  SVGAnimateTransformElement: ['animateTransform'],
  SVGFontElement: ['font'],
  SVGGlyphElement: ['glyph'],
  SVGMissingGlyphElement: ['missingglyph'],
  SVGHKernElement: ['hkern'],
  SVGVKernElement: ['vkern'],
  SVGFontFaceElement: ['fontface'],
  SVGFontFaceSrcElement: ['fontfacesrc'],
  SVGFontFaceUriElement: ['fontfaceuri'],
  SVGFontFaceFormatElement: ['fontfaceformat'],
  SVGMetadataElement: ['metadata'],
  SVGForeignObjectElement: ['foreignObject'],
  SVGFilterElement: ['filter'],
  SVGFEBlendElement: ['feBlend'],
  SVGFEColorMatrixElement: ['feColorMatrix'],
  SVGFEComponentTransferElement: ['feComponentTransfer'],
  SVGFEFuncRElement: ['feFuncR'],
  SVGFEFuncGElement: ['feFuncG'],
  SVGFEFuncBElement: ['feFuncB'],
  SVGFEFuncAElement: ['feFuncA'],
  SVGFECompositeElement: ['feComposite'],
  SVGFEConvolveMatrixElement: ['feConvolveMatrix'],
  SVGFEDiffuseLightingElement: ['feDiffuseLighting'],
  SVGFEPointLightElement: ['fePointLight'],
  SVGFESpotLightElement: ['feSpotLight'],
  SVGFEDisplacementMapElement: ['feDisplacementMap'],
  SVGFEDropShadowElement: ['feDropShadow'],
  SVGFEFloodElement: ['feFlood'],
  SVGFEGaussianBlurElement: ['feGaussianBlur'],
  SVGFEImageElement: ['feImage'],
  SVGFEMergeElement: ['feMerge'],
  SVGFEMergeNodeElement: ['feMergeNode'],
  SVGFEMorphologyElement: ['feMorphology'],
  SVGFESpecularLightingElement: ['feSpecularLighting'],
  SVGFETileElement: ['feTile'],
  SVGFETurbulenceElement: ['feTurbulence']
});
idlArray.test();
</script>
back to top