LibWeb: Import WPT test for checking all the basic SVG interfaces exist

Author: https://github.com/awesomekling
Commit: e6f75801b1
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/4775

Tests/LibWeb/Text/input/wpt-import/interfaces/SVG.idl

@@ -0,0 +1,689 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Scalable Vector Graphics (SVG) 2 (https://svgwg.org/svg2-draft/)
+
+[Exposed=Window]
+interface SVGElement : Element {
+
+  [SameObject] readonly attribute SVGAnimatedString className;
+
+  readonly attribute SVGSVGElement? ownerSVGElement;
+  readonly attribute SVGElement? viewportElement;
+};
+
+SVGElement includes GlobalEventHandlers;
+SVGElement includes SVGElementInstance;
+SVGElement includes HTMLOrSVGElement;
+
+dictionary SVGBoundingBoxOptions {
+  boolean fill = true;
+  boolean stroke = false;
+  boolean markers = false;
+  boolean clipped = false;
+};
+
+[Exposed=Window]
+interface SVGGraphicsElement : SVGElement {
+  [SameObject] readonly attribute SVGAnimatedTransformList transform;
+
+  DOMRect getBBox(optional SVGBoundingBoxOptions options = {});
+  DOMMatrix? getCTM();
+  DOMMatrix? getScreenCTM();
+};
+
+SVGGraphicsElement includes SVGTests;
+
+[Exposed=Window]
+interface SVGGeometryElement : SVGGraphicsElement {
+  [SameObject] readonly attribute SVGAnimatedNumber pathLength;
+
+  boolean isPointInFill(optional DOMPointInit point = {});
+  boolean isPointInStroke(optional DOMPointInit point = {});
+  float getTotalLength();
+  DOMPoint getPointAtLength(float distance);
+};
+
+[Exposed=Window]
+interface SVGNumber {
+  attribute float 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;
+
+  undefined newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
+  undefined convertToSpecifiedUnits(unsigned short unitType);
+};
+
+[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;
+
+  undefined newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
+  undefined convertToSpecifiedUnits(unsigned short unitType);
+};
+
+[Exposed=Window]
+interface SVGNumberList {
+
+  readonly attribute unsigned long length;
+  readonly attribute unsigned long numberOfItems;
+
+  undefined 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 undefined (unsigned long index, SVGNumber newItem);
+};
+
+[Exposed=Window]
+interface SVGLengthList {
+
+  readonly attribute unsigned long length;
+  readonly attribute unsigned long numberOfItems;
+
+  undefined 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 undefined (unsigned long index, SVGLength newItem);
+};
+
+[Exposed=Window]
+interface SVGStringList {
+
+  readonly attribute unsigned long length;
+  readonly attribute unsigned long numberOfItems;
+
+  undefined 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 undefined (unsigned long index, DOMString newItem);
+};
+
+[Exposed=Window]
+interface SVGAnimatedBoolean {
+           attribute boolean baseVal;
+  readonly attribute boolean animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedEnumeration {
+           attribute unsigned short baseVal;
+  readonly attribute unsigned short animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedInteger {
+           attribute long baseVal;
+  readonly attribute long animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedNumber {
+           attribute float baseVal;
+  readonly attribute float animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedLength {
+  [SameObject] readonly attribute SVGLength baseVal;
+  [SameObject] readonly attribute SVGLength animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedAngle {
+  [SameObject] readonly attribute SVGAngle baseVal;
+  [SameObject] readonly attribute SVGAngle animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedString {
+           attribute DOMString baseVal;
+  readonly attribute DOMString animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedRect {
+  [SameObject] readonly attribute DOMRect baseVal;
+  [SameObject] readonly attribute DOMRectReadOnly animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedNumberList {
+  [SameObject] readonly attribute SVGNumberList baseVal;
+  [SameObject] readonly attribute SVGNumberList animVal;
+};
+
+[Exposed=Window]
+interface SVGAnimatedLengthList {
+  [SameObject] readonly attribute SVGLengthList baseVal;
+  [SameObject] readonly attribute SVGLengthList animVal;
+};
+
+[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;
+};
+
+interface mixin SVGTests {
+  [SameObject] readonly attribute SVGStringList requiredExtensions;
+  [SameObject] readonly attribute SVGStringList systemLanguage;
+};
+
+interface mixin SVGFitToViewBox {
+  [SameObject] readonly attribute SVGAnimatedRect viewBox;
+  [SameObject] readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
+};
+
+interface mixin SVGURIReference {
+  [SameObject] readonly attribute SVGAnimatedString href;
+};
+
+partial interface Document {
+  readonly attribute SVGSVGElement? rootElement;
+};
+
+[Exposed=Window]
+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);
+
+  undefined deselectAll();
+
+  SVGNumber createSVGNumber();
+  SVGLength createSVGLength();
+  SVGAngle createSVGAngle();
+  DOMPoint createSVGPoint();
+  DOMMatrix createSVGMatrix();
+  DOMRect createSVGRect();
+  SVGTransform createSVGTransform();
+  SVGTransform createSVGTransformFromMatrix(optional DOMMatrix2DInit matrix = {});
+
+  Element getElementById(DOMString elementId);
+
+  // Deprecated methods that have no effect when called,
+  // but which are kept for compatibility reasons.
+  unsigned long suspendRedraw(unsigned long maxWaitMilliseconds);
+  undefined unsuspendRedraw(unsigned long suspendHandleID);
+  undefined unsuspendRedrawAll();
+  undefined forceRedraw();
+};
+
+SVGSVGElement includes SVGFitToViewBox;
+SVGSVGElement includes WindowEventHandlers;
+
+[Exposed=Window]
+interface SVGGElement : SVGGraphicsElement {
+};
+
+[Exposed=Window]
+interface SVGDefsElement : SVGGraphicsElement {
+};
+
+[Exposed=Window]
+interface SVGDescElement : SVGElement {
+};
+
+[Exposed=Window]
+interface SVGMetadataElement : SVGElement {
+};
+
+[Exposed=Window]
+interface SVGTitleElement : SVGElement {
+};
+
+[Exposed=Window]
+interface SVGSymbolElement : SVGGraphicsElement {
+};
+
+SVGSymbolElement includes SVGFitToViewBox;
+
+[Exposed=Window]
+interface SVGUseElement : SVGGraphicsElement {
+  [SameObject] readonly attribute SVGAnimatedLength x;
+  [SameObject] readonly attribute SVGAnimatedLength y;
+  [SameObject] readonly attribute SVGAnimatedLength width;
+  [SameObject] readonly attribute SVGAnimatedLength height;
+  [SameObject] readonly attribute SVGElement? instanceRoot;
+  [SameObject] readonly attribute SVGElement? animatedInstanceRoot;
+};
+
+SVGUseElement includes SVGURIReference;
+
+[Exposed=Window]
+interface SVGUseElementShadowRoot : ShadowRoot {
+};
+
+interface mixin SVGElementInstance {
+  [SameObject] readonly attribute SVGElement? correspondingElement;
+  [SameObject] readonly attribute SVGUseElement? correspondingUseElement;
+};
+
+[Exposed=Window]
+interface ShadowAnimation : Animation {
+  constructor(Animation source, (Element or CSSPseudoElement) newTarget);
+  [SameObject] readonly attribute Animation sourceAnimation;
+};
+
+[Exposed=Window]
+interface SVGSwitchElement : SVGGraphicsElement {
+};
+
+interface mixin GetSVGDocument {
+  Document getSVGDocument();
+};
+
+[Exposed=Window]
+interface SVGStyleElement : SVGElement {
+  attribute DOMString type;
+  attribute DOMString media;
+  attribute DOMString title;
+};
+
+SVGStyleElement includes LinkStyle;
+
+[Exposed=Window]
+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;
+
+  undefined setMatrix(optional DOMMatrix2DInit matrix = {});
+  undefined setTranslate(float tx, float ty);
+  undefined setScale(float sx, float sy);
+  undefined setRotate(float angle, float cx, float cy);
+  undefined setSkewX(float angle);
+  undefined setSkewY(float angle);
+};
+
+[Exposed=Window]
+interface SVGTransformList {
+
+  readonly attribute unsigned long length;
+  readonly attribute unsigned long numberOfItems;
+
+  undefined 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 undefined (unsigned long index, SVGTransform newItem);
+
+  // Additional methods not common to other list interfaces.
+  SVGTransform createSVGTransformFromMatrix(optional DOMMatrix2DInit matrix = {});
+  SVGTransform? consolidate();
+};
+
+[Exposed=Window]
+interface SVGAnimatedTransformList {
+  [SameObject] readonly attribute SVGTransformList baseVal;
+  [SameObject] readonly attribute SVGTransformList animVal;
+};
+
+[Exposed=Window]
+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;
+};
+
+[Exposed=Window]
+interface SVGAnimatedPreserveAspectRatio {
+  [SameObject] readonly attribute SVGPreserveAspectRatio baseVal;
+  [SameObject] readonly attribute SVGPreserveAspectRatio animVal;
+};
+
+[Exposed=Window]
+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;
+};
+
+[Exposed=Window]
+interface SVGCircleElement : SVGGeometryElement {
+  [SameObject] readonly attribute SVGAnimatedLength cx;
+  [SameObject] readonly attribute SVGAnimatedLength cy;
+  [SameObject] readonly attribute SVGAnimatedLength r;
+};
+
+[Exposed=Window]
+interface SVGEllipseElement : SVGGeometryElement {
+  [SameObject] readonly attribute SVGAnimatedLength cx;
+  [SameObject] readonly attribute SVGAnimatedLength cy;
+  [SameObject] readonly attribute SVGAnimatedLength rx;
+  [SameObject] readonly attribute SVGAnimatedLength ry;
+};
+
+[Exposed=Window]
+interface SVGLineElement : SVGGeometryElement {
+  [SameObject] readonly attribute SVGAnimatedLength x1;
+  [SameObject] readonly attribute SVGAnimatedLength y1;
+  [SameObject] readonly attribute SVGAnimatedLength x2;
+  [SameObject] readonly attribute SVGAnimatedLength y2;
+};
+
+interface mixin SVGAnimatedPoints {
+  [SameObject] readonly attribute SVGPointList points;
+  [SameObject] readonly attribute SVGPointList animatedPoints;
+};
+
+[Exposed=Window]
+interface SVGPointList {
+
+  readonly attribute unsigned long length;
+  readonly attribute unsigned long numberOfItems;
+
+  undefined 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 undefined (unsigned long index, DOMPoint newItem);
+};
+
+[Exposed=Window]
+interface SVGPolylineElement : SVGGeometryElement {
+};
+
+SVGPolylineElement includes SVGAnimatedPoints;
+
+[Exposed=Window]
+interface SVGPolygonElement : SVGGeometryElement {
+};
+
+SVGPolygonElement includes SVGAnimatedPoints;
+
+[Exposed=Window]
+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(optional DOMPointInit point = {});
+  undefined selectSubString(unsigned long charnum, unsigned long nchars);
+};
+
+[Exposed=Window]
+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;
+};
+
+[Exposed=Window]
+interface SVGTextElement : SVGTextPositioningElement {
+};
+
+[Exposed=Window]
+interface SVGTSpanElement : SVGTextPositioningElement {
+};
+
+[Exposed=Window]
+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 includes SVGURIReference;
+
+[Exposed=Window]
+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 includes SVGURIReference;
+
+[Exposed=Window]
+interface SVGForeignObjectElement : SVGGraphicsElement {
+  [SameObject] readonly attribute SVGAnimatedLength x;
+  [SameObject] readonly attribute SVGAnimatedLength y;
+  [SameObject] readonly attribute SVGAnimatedLength width;
+  [SameObject] readonly attribute SVGAnimatedLength height;
+};
+
+[Exposed=Window]
+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;
+
+  undefined setOrientToAuto();
+  undefined setOrientToAngle(SVGAngle angle);
+};
+
+SVGMarkerElement includes SVGFitToViewBox;
+
+[Exposed=Window]
+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 includes SVGURIReference;
+
+[Exposed=Window]
+interface SVGLinearGradientElement : SVGGradientElement {
+  [SameObject] readonly attribute SVGAnimatedLength x1;
+  [SameObject] readonly attribute SVGAnimatedLength y1;
+  [SameObject] readonly attribute SVGAnimatedLength x2;
+  [SameObject] readonly attribute SVGAnimatedLength y2;
+};
+
+[Exposed=Window]
+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;
+};
+
+[Exposed=Window]
+interface SVGStopElement : SVGElement {
+  [SameObject] readonly attribute SVGAnimatedNumber offset;
+};
+
+[Exposed=Window]
+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 includes SVGFitToViewBox;
+SVGPatternElement includes SVGURIReference;
+
+[Exposed=Window]
+interface SVGScriptElement : SVGElement {
+  attribute DOMString type;
+  attribute DOMString? crossOrigin;
+};
+
+SVGScriptElement includes SVGURIReference;
+
+[Exposed=Window]
+interface SVGAElement : SVGGraphicsElement {
+  [SameObject] readonly attribute SVGAnimatedString target;
+  attribute DOMString download;
+  attribute USVString ping;
+  attribute DOMString rel;
+  [SameObject, PutForwards=value] readonly attribute DOMTokenList relList;
+  attribute DOMString hreflang;
+  attribute DOMString type;
+
+  attribute DOMString text;
+
+  attribute DOMString referrerPolicy;
+};
+
+SVGAElement includes SVGURIReference;
+
+// Inline HTMLHyperlinkElementUtils except href, which conflicts.
+partial interface SVGAElement {
+  readonly attribute USVString origin;
+  [CEReactions] attribute USVString protocol;
+  [CEReactions] attribute USVString username;
+  [CEReactions] attribute USVString password;
+  [CEReactions] attribute USVString host;
+  [CEReactions] attribute USVString hostname;
+  [CEReactions] attribute USVString port;
+  [CEReactions] attribute USVString pathname;
+  [CEReactions] attribute USVString search;
+  [CEReactions] attribute USVString hash;
+};
+
+[Exposed=Window]
+interface SVGViewElement : SVGElement {};
+
+SVGViewElement includes SVGFitToViewBox;

Tests/LibWeb/Text/input/wpt-import/interfaces/cssom.idl

@@ -0,0 +1,191 @@
+// GENERATED PREAMBLE - DO NOT EDIT
+// CSSOMString is an implementation-defined type of either DOMString or
+// USVString in CSSOM: https://drafts.csswg.org/cssom/#cssomstring-type
+// For web-platform-tests, use DOMString because USVString has additional
+// requirements in type conversion and could result in spurious failures for
+// implementations that use DOMString.
+typedef DOMString CSSOMString;
+
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Object Model (CSSOM) (https://drafts.csswg.org/cssom-1/)
+
+[Exposed=Window]
+interface MediaList {
+  stringifier attribute [LegacyNullToEmptyString] CSSOMString mediaText;
+  readonly attribute unsigned long length;
+  getter CSSOMString? item(unsigned long index);
+  undefined appendMedium(CSSOMString medium);
+  undefined deleteMedium(CSSOMString medium);
+};
+
+[Exposed=Window]
+interface StyleSheet {
+  readonly attribute CSSOMString type;
+  readonly attribute USVString? href;
+  readonly attribute (Element or ProcessingInstruction)? ownerNode;
+  readonly attribute CSSStyleSheet? parentStyleSheet;
+  readonly attribute DOMString? title;
+  [SameObject, PutForwards=mediaText] readonly attribute MediaList media;
+  attribute boolean disabled;
+};
+
+[Exposed=Window]
+interface CSSStyleSheet : StyleSheet {
+  constructor(optional CSSStyleSheetInit options = {});
+
+  readonly attribute CSSRule? ownerRule;
+  [SameObject] readonly attribute CSSRuleList cssRules;
+  unsigned long insertRule(CSSOMString rule, optional unsigned long index = 0);
+  undefined deleteRule(unsigned long index);
+
+  Promise<CSSStyleSheet> replace(USVString text);
+  undefined replaceSync(USVString text);
+};
+
+dictionary CSSStyleSheetInit {
+  DOMString baseURL = null;
+  (MediaList or DOMString) media = "";
+  boolean disabled = false;
+};
+
+partial interface CSSStyleSheet {
+  [SameObject] readonly attribute CSSRuleList rules;
+  long addRule(optional DOMString selector = "undefined", optional DOMString style = "undefined", optional unsigned long index);
+  undefined removeRule(optional unsigned long index = 0);
+};
+
+[Exposed=Window]
+interface StyleSheetList {
+  getter CSSStyleSheet? item(unsigned long index);
+  readonly attribute unsigned long length;
+};
+
+partial interface mixin DocumentOrShadowRoot {
+  [SameObject] readonly attribute StyleSheetList styleSheets;
+  attribute ObservableArray<CSSStyleSheet> adoptedStyleSheets;
+};
+
+interface mixin LinkStyle {
+  readonly attribute CSSStyleSheet? sheet;
+};
+
+ProcessingInstruction includes LinkStyle;
+[Exposed=Window]
+interface CSSRuleList {
+  getter CSSRule? item(unsigned long index);
+  readonly attribute unsigned long length;
+};
+
+[Exposed=Window]
+interface CSSRule {
+  attribute CSSOMString cssText;
+  readonly attribute CSSRule? parentRule;
+  readonly attribute CSSStyleSheet? parentStyleSheet;
+
+  // the following attribute and constants are historical
+  readonly attribute unsigned short type;
+  const unsigned short STYLE_RULE = 1;
+  const unsigned short CHARSET_RULE = 2;
+  const unsigned short IMPORT_RULE = 3;
+  const unsigned short MEDIA_RULE = 4;
+  const unsigned short FONT_FACE_RULE = 5;
+  const unsigned short PAGE_RULE = 6;
+  const unsigned short MARGIN_RULE = 9;
+  const unsigned short NAMESPACE_RULE = 10;
+};
+
+[Exposed=Window]
+interface CSSStyleRule : CSSGroupingRule {
+  attribute CSSOMString selectorText;
+  [SameObject, PutForwards=cssText] readonly attribute CSSStyleProperties style;
+};
+
+[Exposed=Window]
+interface CSSImportRule : CSSRule {
+  readonly attribute USVString href;
+  [SameObject, PutForwards=mediaText] readonly attribute MediaList media;
+  [SameObject] readonly attribute CSSStyleSheet? styleSheet;
+  readonly attribute CSSOMString? layerName;
+  readonly attribute CSSOMString? supportsText;
+};
+
+[Exposed=Window]
+interface CSSGroupingRule : CSSRule {
+  [SameObject] readonly attribute CSSRuleList cssRules;
+  unsigned long insertRule(CSSOMString rule, optional unsigned long index = 0);
+  undefined deleteRule(unsigned long index);
+};
+
+[Exposed=Window]
+interface CSSPageDescriptors : CSSStyleDeclaration {
+  attribute [LegacyNullToEmptyString] CSSOMString margin;
+  attribute [LegacyNullToEmptyString] CSSOMString marginTop;
+  attribute [LegacyNullToEmptyString] CSSOMString marginRight;
+  attribute [LegacyNullToEmptyString] CSSOMString marginBottom;
+  attribute [LegacyNullToEmptyString] CSSOMString marginLeft;
+  attribute [LegacyNullToEmptyString] CSSOMString margin-top;
+  attribute [LegacyNullToEmptyString] CSSOMString margin-right;
+  attribute [LegacyNullToEmptyString] CSSOMString margin-bottom;
+  attribute [LegacyNullToEmptyString] CSSOMString margin-left;
+  attribute [LegacyNullToEmptyString] CSSOMString size;
+  attribute [LegacyNullToEmptyString] CSSOMString pageOrientation;
+  attribute [LegacyNullToEmptyString] CSSOMString page-orientation;
+  attribute [LegacyNullToEmptyString] CSSOMString marks;
+  attribute [LegacyNullToEmptyString] CSSOMString bleed;
+};
+
+[Exposed=Window]
+interface CSSPageRule : CSSGroupingRule {
+           attribute CSSOMString selectorText;
+  [SameObject, PutForwards=cssText] readonly attribute CSSPageDescriptors style;
+};
+
+[Exposed=Window]
+interface CSSMarginRule : CSSRule {
+  readonly attribute CSSOMString name;
+  [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style;
+};
+
+[Exposed=Window]
+interface CSSNamespaceRule : CSSRule {
+  readonly attribute CSSOMString namespaceURI;
+  readonly attribute CSSOMString prefix;
+};
+
+[Exposed=Window]
+interface CSSStyleDeclaration {
+  [CEReactions] attribute CSSOMString cssText;
+  readonly attribute unsigned long length;
+  getter CSSOMString item(unsigned long index);
+  CSSOMString getPropertyValue(CSSOMString property);
+  CSSOMString getPropertyPriority(CSSOMString property);
+  [CEReactions] undefined setProperty(CSSOMString property, [LegacyNullToEmptyString] CSSOMString value, optional [LegacyNullToEmptyString] CSSOMString priority = "");
+  [CEReactions] CSSOMString removeProperty(CSSOMString property);
+  readonly attribute CSSRule? parentRule;
+};
+
+[Exposed=Window]
+interface CSSStyleProperties : CSSStyleDeclaration {
+  [CEReactions] attribute [LegacyNullToEmptyString] CSSOMString cssFloat;
+};
+
+interface mixin ElementCSSInlineStyle {
+  [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style;
+};
+
+HTMLElement includes ElementCSSInlineStyle;
+
+SVGElement includes ElementCSSInlineStyle;
+
+MathMLElement includes ElementCSSInlineStyle;
+
+partial interface Window {
+  [NewObject] CSSStyleDeclaration getComputedStyle(Element elt, optional CSSOMString? pseudoElt);
+};
+
+[Exposed=Window]
+namespace CSS {
+  CSSOMString escape(CSSOMString ident);
+};

Tests/LibWeb/Text/input/wpt-import/interfaces/svg-animations.idl

@@ -0,0 +1,68 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: SVG Animations (https://svgwg.org/specs/animations/)
+
+[Exposed=Window]
+interface TimeEvent : Event {
+
+  readonly attribute WindowProxy? view;
+  readonly attribute long detail;
+
+  undefined initTimeEvent(DOMString typeArg, Window? viewArg, long detailArg);
+};
+
+[Exposed=Window]
+interface SVGAnimationElement : SVGElement {
+
+  readonly attribute SVGElement? targetElement;
+
+  attribute EventHandler onbegin;
+  attribute EventHandler onend;
+  attribute EventHandler onrepeat;
+
+  float getStartTime();
+  float getCurrentTime();
+  float getSimpleDuration();
+
+  undefined beginElement();
+  undefined beginElementAt(float offset);
+  undefined endElement();
+  undefined endElementAt(float offset);
+};
+
+SVGAnimationElement includes SVGTests;
+
+[Exposed=Window]
+interface SVGAnimateElement : SVGAnimationElement {
+};
+
+[Exposed=Window]
+interface SVGSetElement : SVGAnimationElement {
+};
+
+[Exposed=Window]
+interface SVGAnimateMotionElement : SVGAnimationElement {
+};
+
+[Exposed=Window]
+interface SVGMPathElement : SVGElement {
+};
+
+SVGMPathElement includes SVGURIReference;
+
+[Exposed=Window]
+interface SVGAnimateTransformElement : SVGAnimationElement {
+};
+
+[Exposed=Window]
+interface SVGDiscardElement : SVGAnimationElement {
+};
+
+partial interface SVGSVGElement {
+  undefined pauseAnimations();
+  undefined unpauseAnimations();
+  boolean animationsPaused();
+  float getCurrentTime();
+  undefined setCurrentTime(float seconds);
+};

Tests/LibWeb/Text/input/wpt-import/interfaces/web-animations.idl

@@ -0,0 +1,150 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Web Animations (https://drafts.csswg.org/web-animations-1/)
+
+[Exposed=Window]
+interface AnimationTimeline {
+};
+
+dictionary DocumentTimelineOptions {
+  DOMHighResTimeStamp originTime = 0;
+};
+
+[Exposed=Window]
+interface DocumentTimeline : AnimationTimeline {
+  constructor(optional DocumentTimelineOptions options = {});
+};
+
+[Exposed=Window]
+interface Animation : EventTarget {
+  constructor(optional AnimationEffect? effect = null,
+              optional AnimationTimeline? timeline);
+           attribute DOMString                id;
+           attribute AnimationEffect?         effect;
+           attribute AnimationTimeline?       timeline;
+           attribute double                   playbackRate;
+  readonly attribute AnimationPlayState       playState;
+  readonly attribute AnimationReplaceState    replaceState;
+  readonly attribute boolean                  pending;
+  readonly attribute Promise<Animation>       ready;
+  readonly attribute Promise<Animation>       finished;
+           attribute EventHandler             onfinish;
+           attribute EventHandler             oncancel;
+           attribute EventHandler             onremove;
+  undefined cancel();
+  undefined finish();
+  undefined play();
+  undefined pause();
+  undefined updatePlaybackRate(double playbackRate);
+  undefined reverse();
+  undefined persist();
+  [CEReactions]
+  undefined commitStyles();
+};
+
+enum AnimationPlayState { "idle", "running", "paused", "finished" };
+
+enum AnimationReplaceState { "active", "removed", "persisted" };
+
+[Exposed=Window]
+interface AnimationEffect {
+    EffectTiming         getTiming();
+    ComputedEffectTiming getComputedTiming();
+    undefined            updateTiming(optional OptionalEffectTiming timing = {});
+};
+
+dictionary EffectTiming {
+  FillMode                           fill = "auto";
+  double                             iterationStart = 0.0;
+  unrestricted double                iterations = 1.0;
+  PlaybackDirection                  direction = "normal";
+  DOMString                          easing = "linear";
+};
+
+dictionary OptionalEffectTiming {
+  double                             delay;
+  double                             endDelay;
+  FillMode                           fill;
+  double                             iterationStart;
+  unrestricted double                iterations;
+  (unrestricted double or DOMString) duration;
+  PlaybackDirection                  direction;
+  DOMString                          easing;
+};
+
+enum FillMode { "none", "forwards", "backwards", "both", "auto" };
+
+enum PlaybackDirection { "normal", "reverse", "alternate", "alternate-reverse" };
+
+dictionary ComputedEffectTiming : EffectTiming {
+  double?              progress;
+  unrestricted double? currentIteration;
+};
+
+[Exposed=Window]
+interface KeyframeEffect : AnimationEffect {
+  constructor(Element?       target,
+              object?        keyframes,
+              optional (unrestricted double or KeyframeEffectOptions) options = {});
+  constructor(KeyframeEffect source);
+  attribute Element?           target;
+  attribute CSSOMString?       pseudoElement;
+  attribute CompositeOperation composite;
+  sequence<object> getKeyframes();
+  undefined        setKeyframes(object? keyframes);
+};
+
+dictionary BaseComputedKeyframe {
+     double?                  offset = null;
+     double                   computedOffset;
+     DOMString                easing = "linear";
+     CompositeOperationOrAuto composite = "auto";
+};
+
+dictionary BasePropertyIndexedKeyframe {
+  (double? or sequence<double?>)                         offset = [];
+  (DOMString or sequence<DOMString>)                     easing = [];
+  (CompositeOperationOrAuto or sequence<CompositeOperationOrAuto>) composite = [];
+};
+
+dictionary BaseKeyframe {
+  double?                  offset = null;
+  DOMString                easing = "linear";
+  CompositeOperationOrAuto composite = "auto";
+};
+
+dictionary KeyframeEffectOptions : EffectTiming {
+    CompositeOperation composite = "replace";
+    CSSOMString?       pseudoElement = null;
+};
+
+enum CompositeOperation { "replace", "add", "accumulate" };
+
+enum CompositeOperationOrAuto { "replace", "add", "accumulate", "auto" };
+
+interface mixin Animatable {
+    Animation           animate(object? keyframes,
+                                optional (unrestricted double or KeyframeAnimationOptions) options = {});
+    sequence<Animation> getAnimations(optional GetAnimationsOptions options = {});
+};
+
+dictionary KeyframeAnimationOptions : KeyframeEffectOptions {
+    DOMString id = "";
+    AnimationTimeline? timeline;
+};
+
+dictionary GetAnimationsOptions {
+    boolean subtree = false;
+    CSSOMString? pseudoElement = null;
+};
+
+partial interface Document {
+    readonly attribute DocumentTimeline timeline;
+};
+
+partial interface mixin DocumentOrShadowRoot {
+    sequence<Animation> getAnimations();
+};
+
+Element includes Animatable;

Tests/LibWeb/Text/input/wpt-import/svg/idlharness.window.html

@@ -0,0 +1,9 @@
+<!doctype html>
+<meta charset=utf-8>
+<meta name="timeout" content="long">
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../resources/WebIDLParser.js"></script>
+<script src="../resources/idlharness.js"></script>
+<div id=log></div>
+<script src="../svg/idlharness.window.js"></script>

Tests/LibWeb/Text/input/wpt-import/svg/idlharness.window.js

@@ -0,0 +1,201 @@
+// META: timeout=long
+// META: script=/resources/WebIDLParser.js
+// META: script=/resources/idlharness.js
+
+// https://svgwg.org/svg2-draft/
+
+'use strict';
+
+let objects = {};
+
+const elements = [
+  'svg',
+  'g',
+  'defs',
+  'desc',
+  'title',
+  'symbol',
+  'use',
+  'image',
+  'switch',
+  'style',
+  'path',
+  'rect',
+  'circle',
+  'ellipse',
+  'line',
+  'polyline',
+  'polygon',
+  'text',
+  'tspan',
+  'textPath',
+  'marker',
+  'linearGradient',
+  'radialGradient',
+  'meshGradient',
+  'stop',
+  'pattern',
+  'clipPath',
+  'mask',
+  'a',
+  'view',
+  'script',
+  'animate',
+  'set',
+  'animateMotion',
+  'mpath',
+  'animateTransform',
+  'metadata',
+  'foreignObject',
+  'filter',
+  'feBlend',
+  'feColorMatrix',
+  'feComponentTransfer',
+  'feFuncR',
+  'feFuncG',
+  'feFuncB',
+  'feFuncA',
+  'feComposite',
+  'feConvolveMatrix',
+  'feDiffuseLighting',
+  'fePointLight',
+  'feSpotLight',
+  'feDisplacementMap',
+  'feDropShadow',
+  'feFlood',
+  'feGaussianBlur',
+  'feDisplacementMap',
+  'feDropShadow',
+  'feImage',
+  'feMerge',
+  'feMergeNode',
+  'feMorphology',
+  'feSpecularLighting',
+  'feTile',
+  'feTurbulence',
+];
+
+idl_test(
+  ['SVG', 'svg-animations'],
+  ['cssom', 'web-animations', 'html', 'dom'],
+  idlArray => {
+    const svgUrl = 'http://www.w3.org/2000/svg';
+    for (const element of elements) {
+      try {
+        objects[element] = document.createElementNS(svgUrl, element);
+      } catch (e) {
+        // Will be surfaced by idlharess.js's test_object below.
+      }
+    }
+
+    idlArray.add_untested_idls('interface CSSPseudoElement {};')
+    idlArray.add_objects({
+      SVGAnimatedBoolean: ['objects.feConvolveMatrix.preserveAlpha'],
+      SVGAnimatedString: ['objects.a.target'],
+      SVGStringList: ['objects.a.requiredExtensions'],
+      SVGAnimatedEnumeration: ['objects.text.lengthAdjust'],
+      SVGAnimatedInteger: ['objects.feConvolveMatrix.orderX'],
+      SVGNumber: ['objects.svg.createSVGNumber()'],
+      SVGAnimatedNumber: ['objects.stop.offset'],
+      SVGNumberList: ['objects.text.rotate.baseVal'],
+      SVGAnimatedNumberList: ['objects.text.rotate'],
+      SVGLength: ['objects.svg.createSVGLength()'],
+      SVGAnimatedLength: ['objects.svg.x'],
+      SVGAnimatedLengthList: ['objects.text.x'],
+      SVGAngle: ['objects.svg.createSVGAngle()'],
+      SVGAnimatedAngle: ['objects.marker.orientAngle'],
+      SVGRect: ['objects.svg.createSVGRect()'],
+      SVGAnimatedRect: ['objects.svg.viewBox'],
+      SVGSVGElement: ['objects.svg'],
+      SVGGElement: ['objects.g'],
+      SVGDefsElement: ['objects.defs'],
+      SVGDescElement: ['objects.desc'],
+      SVGTitleElement: ['objects.title'],
+      SVGSymbolElement: ['objects.symbol'],
+      SVGUseElement: ['objects.use'],
+      SVGImageElement: ['objects.image'],
+      SVGSwitchElement: ['objects.switch'],
+      SVGStyleElement: ['objects.style'],
+      SVGPoint: ['objects.svg.createSVGPoint()'],
+      SVGPointList: ['objects.polygon.points'],
+      SVGMatrix: ['objects.svg.createSVGMatrix()'],
+      SVGTransform: ['objects.svg.createSVGTransform()'],
+      SVGTransformList: ['objects.pattern.patternTransform.baseVal'],
+      SVGAnimatedTransformList: ['objects.pattern.patternTransform'],
+      SVGPreserveAspectRatio: ['objects.image.preserveAspectRatio.baseVal'],
+      SVGAnimatedPreserveAspectRatio: ['objects.image.preserveAspectRatio'],
+      SVGPathSegClosePath: ['objects.path.createSVGPathSegClosePath()'],
+      SVGPathSegMovetoAbs: ['objects.path.createSVGPathSegMovetoAbs(0,0)'],
+      SVGPathSegMovetoRel: ['objects.path.createSVGPathSegMovetoRel(0,0)'],
+      SVGPathSegLinetoAbs: ['objects.path.createSVGPathSegLinetoAbs(0,0)'],
+      SVGPathSegLinetoRel: ['objects.path.createSVGPathSegLinetoRel(0,0)'],
+      SVGPathSegCurvetoCubicAbs: ['objects.path.createSVGPathSegCurvetoCubicAbs(0,0,0,0,0,0)'],
+      SVGPathSegCurvetoCubicRel: ['objects.path.createSVGPathSegCurvetoCubicRel(0,0,0,0,0,0)'],
+      SVGPathSegCurvetoQuadraticAbs: ['objects.path.createSVGPathSegCurvetoQuadraticAbs(0,0,0,0)'],
+      SVGPathSegCurvetoQuadraticRel: ['objects.path.createSVGPathSegCurvetoQuadraticRel(0,0,0,0)'],
+      SVGPathSegArcAbs: ['objects.path.createSVGPathSegArcAbs(0,0,0,0,0,true,true)'],
+      SVGPathSegArcRel: ['objects.path.createSVGPathSegArcRel(0,0,0,0,0,true,true)'],
+      SVGPathSegLinetoHorizontalAbs: ['objects.path.createSVGPathSegLinetoHorizontalAbs(0)'],
+      SVGPathSegLinetoHorizontalRel: ['objects.path.createSVGPathSegLinetoHorizontalRel(0)'],
+      SVGPathSegLinetoVerticalAbs: ['objects.path.createSVGPathSegLinetoVerticalAbs(0)'],
+      SVGPathSegLinetoVerticalRel: ['objects.path.createSVGPathSegLinetoVerticalRel(0)'],
+      SVGPathSegCurvetoCubicSmoothAbs: ['objects.path.createSVGPathSegCurvetoCubicSmoothAbs(0,0,0,0)'],
+      SVGPathSegCurvetoCubicSmoothRel: ['objects.path.createSVGPathSegCurvetoCubicSmoothRel(0,0,0,0)'],
+      SVGPathSegCurvetoQuadraticSmoothAbs: ['objects.path.createSVGPathSegCurvetoQuadraticSmoothAbs(0,0)'],
+      SVGPathSegCurvetoQuadraticSmoothRel: ['objects.path.createSVGPathSegCurvetoQuadraticSmoothRel(0,0)'],
+      SVGPathSegList: ['objects.path.pathSegList'],
+      SVGPathElement: ['objects.path'],
+      SVGRectElement: ['objects.rect'],
+      SVGCircleElement: ['objects.circle'],
+      SVGEllipseElement: ['objects.ellipse'],
+      SVGLineElement: ['objects.line'],
+      SVGPolylineElement: ['objects.polyline'],
+      SVGPolygonElement: ['objects.polygon'],
+      SVGTextElement: ['objects.text'],
+      SVGTSpanElement: ['objects.tspan'],
+      SVGTextPathElement: ['objects.textPath'],
+      SVGMarkerElement: ['objects.marker'],
+      SVGLinearGradientElement: ['objects.linearGradient'],
+      SVGRadialGradientElement: ['objects.radialGradient'],
+      SVGMeshGradientElement: ['objects.meshGradient'],
+      SVGStopElement: ['objects.stop'],
+      SVGPatternElement: ['objects.pattern'],
+      SVGClipPathElement: ['objects.clipPath'],
+      SVGMaskElement: ['objects.mask'],
+      SVGAElement: ['objects.a'],
+      SVGViewElement: ['objects.view'],
+      SVGScriptElement: ['objects.script'],
+      SVGAnimateElement: ['objects.animate'],
+      SVGSetElement: ['objects.set'],
+      SVGAnimateMotionElement: ['objects.animateMotion'],
+      SVGMPathElement: ['objects.mpath'],
+      SVGAnimateTransformElement: ['objects.animateTransform'],
+      SVGMetadataElement: ['objects.metadata'],
+      SVGForeignObjectElement: ['objects.foreignObject'],
+      SVGFilterElement: ['objects.filter'],
+      SVGFEBlendElement: ['objects.feBlend'],
+      SVGFEColorMatrixElement: ['objects.feColorMatrix'],
+      SVGFEComponentTransferElement: ['objects.feComponentTransfer'],
+      SVGFEFuncRElement: ['objects.feFuncR'],
+      SVGFEFuncGElement: ['objects.feFuncG'],
+      SVGFEFuncBElement: ['objects.feFuncB'],
+      SVGFEFuncAElement: ['objects.feFuncA'],
+      SVGFECompositeElement: ['objects.feComposite'],
+      SVGFEConvolveMatrixElement: ['objects.feConvolveMatrix'],
+      SVGFEDiffuseLightingElement: ['objects.feDiffuseLighting'],
+      SVGFEPointLightElement: ['objects.fePointLight'],
+      SVGFESpotLightElement: ['objects.feSpotLight'],
+      SVGFEDisplacementMapElement: ['objects.feDisplacementMap'],
+      SVGFEDropShadowElement: ['objects.feDropShadow'],
+      SVGFEFloodElement: ['objects.feFlood'],
+      SVGFEGaussianBlurElement: ['objects.feGaussianBlur'],
+      SVGFEImageElement: ['objects.feImage'],
+      SVGFEMergeElement: ['objects.feMerge'],
+      SVGFEMergeNodeElement: ['objects.feMergeNode'],
+      SVGFEMorphologyElement: ['objects.feMorphology'],
+      SVGFESpecularLightingElement: ['objects.feSpecularLighting'],
+      SVGFETileElement: ['objects.feTile'],
+      SVGFETurbulenceElement: ['objects.feTurbulence']
+    });
+  }
+);