#   Copyright 2017 Google Inc. All Rights Reserved.
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.


<root root=true> = <lines count=1000>

!lineguard try { <line> } catch(e) { }

!include common.txt
!include jshelpers.txt

!begin lines

#todo: xpath, animation
#todo: style element and attributes should have correct CSS values

#ApplicationCache
!extends ApplicationCache EventTarget
<new EventTarget> = <ApplicationCache>;
<new short> = <ApplicationCache>.status;
<ApplicationCache>.update();
<ApplicationCache>.abort();
<ApplicationCache>.swapCache();
<new EventHandler> = <ApplicationCache>.onchecking;
<ApplicationCache>.onchecking = <EventHandler>;
<new EventHandler> = <ApplicationCache>.onerror;
<ApplicationCache>.onerror = <EventHandler>;
<new EventHandler> = <ApplicationCache>.onnoupdate;
<ApplicationCache>.onnoupdate = <EventHandler>;
<new EventHandler> = <ApplicationCache>.ondownloading;
<ApplicationCache>.ondownloading = <EventHandler>;
<new EventHandler> = <ApplicationCache>.onprogress;
<ApplicationCache>.onprogress = <EventHandler>;
<new EventHandler> = <ApplicationCache>.onupdateready;
<ApplicationCache>.onupdateready = <EventHandler>;
<new EventHandler> = <ApplicationCache>.oncached;
<ApplicationCache>.oncached = <EventHandler>;
<new EventHandler> = <ApplicationCache>.onobsolete;
<ApplicationCache>.onobsolete = <EventHandler>;

#DOMParser
<new Document> = <DOMParser>.parseFromString(<DOMString>,<SupportedType>);
<new Document> = <DOMParser>.parseFromString("","text/html");
<new Document> = <DOMParser>.parseFromString(<htmlstring>,"text/html");

#XPathEvaluator
<new XPathExpression> = <XPathEvaluator>.createExpression("<xpath>");
<new XPathExpression> = <XPathEvaluator>.createExpression("<xpath>",<XPathNSResolver>);
<new XPathNSResolver> = <XPathEvaluator>.createNSResolver(<Element>);
<new XPathResult> = <XPathEvaluator>.evaluate("<xpath>",<Element>);
<new XPathResult> = <XPathEvaluator>.evaluate("<xpath>",<Element>,<XPathNSResolver>);
<new XPathResult> = <XPathEvaluator>.evaluate("<xpath>",<Element>,<XPathNSResolver>,<fuzzint>);
<new XPathResult> = <XPathEvaluator>.evaluate("<xpath>",<Element>,<XPathNSResolver>,<fuzzint>,<XPathResult>);
<new XPathResult> = <XPathEvaluator>.evaluate("<xpath>",document);
<new XPathResult> = <XPathEvaluator>.evaluate("<xpath>",document,null,XPathResult.ANY_TYPE,<XPathResult>);

#XPathResult
<new short> = <XPathResult>.resultType;
<new double> = <XPathResult>.numberValue;
<new DOMString> = <XPathResult>.stringValue;
<new boolean> = <XPathResult>.booleanValue;
<new Element> = <XPathResult>.singleNodeValue;
<new boolean> = <XPathResult>.invalidIteratorState;
<new long> = <XPathResult>.snapshotLength;
<new Element> = <XPathResult>.iterateNext();
<new Element> = <XPathResult id=1>.snapshotItem(<int min=0 max=100>%<XPathResult id=1>.snapshotLength);

#XMLSerializer
<new DOMString> = <XMLSerializer>.serializeToString(<Element>);

#XSLTProcessor
<XSLTProcessor>.importStylesheet(<Element>);
<new DocumentFragment> = <XSLTProcessor>.transformToFragment(<Element>,<Document>);
<new Document> = <XSLTProcessor>.transformToDocument(<Element>);
<XSLTProcessor>.setParameter(<DOMString>,<DOMString>,<DOMString>);
<new DOMString> = <XSLTProcessor>.getParameter(<DOMString>,<DOMString>);
<XSLTProcessor>.removeParameter(<DOMString>,<DOMString>);
<XSLTProcessor>.clearParameters();
<XSLTProcessor>.reset();

#XPathNSResolver
<new DOMString> = <XPathNSResolver>.lookupNamespaceURI();
<new DOMString> = <XPathNSResolver>.lookupNamespaceURI(<DOMString>);

#Document
<new XPathExpression> = <Document>.createExpression("<xpath>");
<new XPathExpression> = <Document>.createExpression("<xpath>",<XPathNSResolver>);
<new XPathNSResolver> = <Document>.createNSResolver(<Element>);
<new XPathResult> = <Document>.evaluate("<xpath>",<Element>);
<new XPathResult> = <Document>.evaluate("<xpath>",<Element>,<XPathNSResolver>);
<new XPathResult> = <Document>.evaluate("<xpath>",<Element>,<XPathNSResolver>,<fuzzint>);
<new XPathResult> = <Document>.evaluate("<xpath>",<Element>,<XPathNSResolver>,<fuzzint>,<XPathResult>);
<new XPathResult> = <Document>.evaluate("<xpath>",document);
<new XPathResult> = <Document>.evaluate("<xpath>",document,null,XPathResult.ANY_TYPE,<XPathResult>);

#Document
<Document>.transformDocumentToTreeView(<DOMString>);

#XPathExpression
<new XPathResult> = <XPathExpression>.evaluate(<Element>);
<new XPathResult> = <XPathExpression>.evaluate(<Element>,<fuzzint>);
<new XPathResult> = <XPathExpression>.evaluate(<Element>,<fuzzint>,<XPathResult>);
<new XPathResult> = <XPathExpression>.evaluate(<Element>,XPathResult.ANY_TYPE,<XPathResult>);

#AnimationEffectTiming
!extends AnimationEffectTiming AnimationEffectTimingReadOnly
<new AnimationEffectTimingReadOnly> = <AnimationEffectTiming>;
<new double> = <AnimationEffectTiming>.delay;
<AnimationEffectTiming>.delay = <double>;
<new double> = <AnimationEffectTiming>.endDelay;
<AnimationEffectTiming>.endDelay = <double>;
<new DOMString> = <AnimationEffectTiming>.fill;
<AnimationEffectTiming>.fill = <DOMString>;
<new double> = <AnimationEffectTiming>.iterationStart;
<AnimationEffectTiming>.iterationStart = <double>;
<new double> = <AnimationEffectTiming>.iterations;
<AnimationEffectTiming>.iterations = <double>;
<new double> = <AnimationEffectTiming>.duration;
<AnimationEffectTiming>.duration = <double>;
<new DOMString> = <AnimationEffectTiming>.duration;
<AnimationEffectTiming>.duration = <DOMString>;
<new DOMString> = <AnimationEffectTiming>.direction;
<AnimationEffectTiming>.direction = <DOMString>;
<new DOMString> = <AnimationEffectTiming>.easing;
<AnimationEffectTiming>.easing = <DOMString>;

#AnimationTimeline
<new double> = <AnimationTimeline>.currentTime;
<AnimationTimeline>.currentTime = <double>;
<new sequence_Animation_> = <AnimationTimeline>.getAnimations();

#Animation
!extends Animation EventTarget
<new EventTarget> = <Animation>;
<new AnimationEffectReadOnly> = <Animation>.effect;
<Animation>.effect = <AnimationEffectReadOnly>;
<new AnimationTimeline> = <Animation>.timeline;
<new double> = <Animation>.startTime;
<Animation>.startTime = <double>;
<new double> = <Animation>.currentTime;
<Animation>.currentTime = <double>;
<new double> = <Animation>.playbackRate;
<Animation>.playbackRate = <double>;
<new AnimationPlayState> = <Animation>.playState;
<Animation>.finish();
<Animation>.play();
<Animation>.pause();
<Animation>.reverse();
<new DOMString> = <Animation>.id;
<Animation>.id = <DOMString>;
<Animation>.cancel();
<new EventHandler> = <Animation>.onfinish;
<Animation>.onfinish = <EventHandler>;
<new EventHandler> = <Animation>.oncancel;
<Animation>.oncancel = <EventHandler>;
<new Promise_Animation_> = <Animation>.finished;
<new Promise_Animation_> = <Animation>.ready;

#AnimationEffectReadOnly
<new AnimationEffectTimingReadOnly> = <AnimationEffectReadOnly>.timing;
<new ComputedTimingProperties> = <AnimationEffectReadOnly>.getComputedTiming();

#KeyframeEffectReadOnly
!extends KeyframeEffectReadOnly AnimationEffectReadOnly
<new AnimationEffectReadOnly> = <KeyframeEffectReadOnly>;

#AnimationEffectTimingReadOnly
<new double> = <AnimationEffectTimingReadOnly>.delay;
<new double> = <AnimationEffectTimingReadOnly>.endDelay;
<new DOMString> = <AnimationEffectTimingReadOnly>.fill;
<new double> = <AnimationEffectTimingReadOnly>.iterationStart;
<new double> = <AnimationEffectTimingReadOnly>.iterations;
<new double> = <AnimationEffectTimingReadOnly>.duration;
<new DOMString> = <AnimationEffectTimingReadOnly>.duration;
<new DOMString> = <AnimationEffectTimingReadOnly>.direction;
<new DOMString> = <AnimationEffectTimingReadOnly>.easing;

#KeyframeEffect
!extends KeyframeEffect KeyframeEffectReadOnly
<new KeyframeEffectReadOnly> = <KeyframeEffect>;

#Element
<new Animation> = <Element>.animate(<sequence_Dictionary_>,<double>);
<new Animation> = <Element>.animate(<sequence_Dictionary_>,<KeyframeEffectOptions>);
<new sequence_Animation_> = <Element>.getAnimations();

#Document
<new DocumentTimeline> = <Document>.timeline;

#DocumentTimeline
!extends DocumentTimeline AnimationTimeline
<new AnimationTimeline> = <DocumentTimeline>;

#TimeRanges
<new long> = <TimeRanges>.length;
<new double> = <TimeRanges>.start(<fuzzint>);
<new double> = <TimeRanges>.end(<fuzzint>);

#HTMLStyleElement
!extends HTMLStyleElement Element
<new Element> = <HTMLStyleElement>;
<new boolean> = <HTMLStyleElement>.disabled;
<HTMLStyleElement>.disabled = <boolean>;
<new DOMString> = <HTMLStyleElement>.media;
<HTMLStyleElement>.media = "<media_value>";
<new DOMString> = <HTMLStyleElement>.type;
<HTMLStyleElement>.type = "<type_value>";
<new StyleSheet> = <HTMLStyleElement>.sheet;
<HTMLStyleElement>.appendChild(document.createTextNode("<import from=cssgrammar symbol=rule>"));

!extends HTMLAnchorElement HTMLHyperlinkElementUtils
<new HTMLHyperlinkElementUtils> = <HTMLAnchorElement>;

#HTMLAnchorElement
!extends HTMLAnchorElement Element
<new Element> = <HTMLAnchorElement>;
<new DOMString> = <HTMLAnchorElement>.target;
<HTMLAnchorElement>.target = "<target_value>";
<new DOMString> = <HTMLAnchorElement>.download;
<HTMLAnchorElement>.download = "<download_value>";
<new DOMString> = <HTMLAnchorElement>.ping;
<HTMLAnchorElement>.ping = "<ping_value>";
<new DOMString> = <HTMLAnchorElement>.rel;
<HTMLAnchorElement>.rel = "<rel_value>";
<new DOMString> = <HTMLAnchorElement>.hreflang;
<HTMLAnchorElement>.hreflang = "<hreflang_value>";
<new DOMString> = <HTMLAnchorElement>.type;
<HTMLAnchorElement>.type = "<type_value>";
<new DOMString> = <HTMLAnchorElement>.referrerPolicy;
<HTMLAnchorElement>.referrerPolicy = "<referrerpolicy_value>";
<new DOMString> = <HTMLAnchorElement>.text;
<HTMLAnchorElement>.text = "<text_value>";
<new DOMString> = <HTMLAnchorElement>.coords;
<HTMLAnchorElement>.coords = "<coords_value>";
<new DOMString> = <HTMLAnchorElement>.charset;
<HTMLAnchorElement>.charset = "<charset_value>";
<new DOMString> = <HTMLAnchorElement>.name;
<HTMLAnchorElement>.name = "<name_value>";
<new DOMString> = <HTMLAnchorElement>.rev;
<HTMLAnchorElement>.rev = "<rev_value>";
<new DOMString> = <HTMLAnchorElement>.shape;
<HTMLAnchorElement>.shape = "<shape_value>";

#HTMLIFrameElement
!extends HTMLIFrameElement Element
<new Element> = <HTMLIFrameElement>;
<new DOMString> = <HTMLIFrameElement>.src;
<HTMLIFrameElement>.src = "<framesrc>";
<new DOMString> = <HTMLIFrameElement>.srcdoc;
<HTMLIFrameElement>.srcdoc = "<framesrc>";
<new DOMString> = <HTMLIFrameElement>.name;
<HTMLIFrameElement>.name = "<name_value>";
<new DOMTokenList> = <HTMLIFrameElement>.sandbox;
<new boolean> = <HTMLIFrameElement>.allowFullscreen;
<HTMLIFrameElement>.allowFullscreen = <boolean>;
<new DOMString> = <HTMLIFrameElement>.width;
<HTMLIFrameElement>.width = "<width_value>";
<new DOMString> = <HTMLIFrameElement>.height;
<HTMLIFrameElement>.height = "<height_value>";
<new Document> = <HTMLIFrameElement>.contentDocument;
<new Window> = <HTMLIFrameElement>.contentWindow;
<new Document> = <HTMLIFrameElement>.getSVGDocument();
<new DOMString> = <HTMLIFrameElement>.referrerPolicy;
<HTMLIFrameElement>.referrerPolicy = "<referrerpolicy_value>";
<new DOMTokenList> = <HTMLIFrameElement>.permissions;
<new DOMString> = <HTMLIFrameElement>.csp;
<HTMLIFrameElement>.csp = <DOMString>;
<new DOMString> = <HTMLIFrameElement>.align;
<HTMLIFrameElement>.align = "<align_value>";
<new DOMString> = <HTMLIFrameElement>.scrolling;
<HTMLIFrameElement>.scrolling = "<scrolling_value>";
<new DOMString> = <HTMLIFrameElement>.frameBorder;
<HTMLIFrameElement>.frameBorder = "<frameborder_value>";
<new DOMString> = <HTMLIFrameElement>.longDesc;
<HTMLIFrameElement>.longDesc = "<longdesc_value>";
<new DOMString> = <HTMLIFrameElement>.marginHeight;
<HTMLIFrameElement>.marginHeight = "<marginheight_value>";
<new DOMString> = <HTMLIFrameElement>.marginWidth;
<HTMLIFrameElement>.marginWidth = "<marginheight_value>";

#HTMLTableElement
!extends HTMLTableElement Element
<new Element> = <HTMLTableElement>;
<new HTMLTableCaptionElement> = <HTMLTableElement>.caption;
<HTMLTableElement>.caption = <HTMLTableCaptionElement>;
<new HTMLTableCaptionElement> = <HTMLTableElement>.createCaption();
<HTMLTableElement>.deleteCaption();
<new HTMLTableSectionElement> = <HTMLTableElement>.tHead;
<HTMLTableElement>.tHead = <HTMLTableSectionElement>;
<new HTMLTableSectionElement> = <HTMLTableElement>.createTHead();
<HTMLTableElement>.deleteTHead();
<new HTMLTableSectionElement> = <HTMLTableElement>.tFoot;
<HTMLTableElement>.tFoot = <HTMLTableSectionElement>;
<new HTMLTableSectionElement> = <HTMLTableElement>.createTFoot();
<HTMLTableElement>.deleteTFoot();
<new HTMLCollection> = <HTMLTableElement>.tBodies;
<new HTMLTableSectionElement> = <HTMLTableElement>.createTBody();
<new HTMLCollection> = <HTMLTableElement>.rows;
<new HTMLTableRowElement> = <HTMLTableElement>.insertRow();
<new HTMLTableRowElement> = <HTMLTableElement>.insertRow(<fuzzint>);
<HTMLTableElement>.deleteRow(<fuzzint>);
<new DOMString> = <HTMLTableElement>.align;
<HTMLTableElement>.align = "<align_value>";
<new DOMString> = <HTMLTableElement>.border;
<HTMLTableElement>.border = "<border_value>";
<new DOMString> = <HTMLTableElement>.frame;
<HTMLTableElement>.frame = "<frame_value>";
<new DOMString> = <HTMLTableElement>.rules;
<HTMLTableElement>.rules = "<rules_value>";
<new DOMString> = <HTMLTableElement>.summary;
<HTMLTableElement>.summary = "<summary_value>";
<new DOMString> = <HTMLTableElement>.width;
<HTMLTableElement>.width = "<width_value>";
<new DOMString> = <HTMLTableElement>.bgColor;
<HTMLTableElement>.bgColor = "<bgcolor_value>";
<new DOMString> = <HTMLTableElement>.cellPadding;
<HTMLTableElement>.cellPadding = "<cellpadding_value>";
<new DOMString> = <HTMLTableElement>.cellSpacing;
<HTMLTableElement>.cellSpacing = "<cellspacing_value>";

#HTMLHeadElement
!extends HTMLHeadElement Element
<new Element> = <HTMLHeadElement>;

#HTMLFrameElement
!extends HTMLFrameElement Element
<new Element> = <HTMLFrameElement>;
<new DOMString> = <HTMLFrameElement>.name;
<HTMLFrameElement>.name = "<name_value>";
<new DOMString> = <HTMLFrameElement>.scrolling;
<HTMLFrameElement>.scrolling = "<scrolling_value>";
<new DOMString> = <HTMLFrameElement>.src;
<HTMLFrameElement>.src = "<framesrc>";
<new DOMString> = <HTMLFrameElement>.frameBorder;
<HTMLFrameElement>.frameBorder = "<frameborder_value>";
<new DOMString> = <HTMLFrameElement>.longDesc;
<HTMLFrameElement>.longDesc = "<longdesc_value>";
<new boolean> = <HTMLFrameElement>.noResize;
<HTMLFrameElement>.noResize = <boolean>;
<new Document> = <HTMLFrameElement>.contentDocument;
<new Window> = <HTMLFrameElement>.contentWindow;
<new DOMString> = <HTMLFrameElement>.marginHeight;
<HTMLFrameElement>.marginHeight = "<marginheight_value>";
<new DOMString> = <HTMLFrameElement>.marginWidth;
<HTMLFrameElement>.marginWidth = "<marginwidth_value>";

#HTMLTableColElement
!extends HTMLTableColElement Element
<new Element> = <HTMLTableColElement>;
<new long> = <HTMLTableColElement>.span;
<HTMLTableColElement>.span = <fuzzint>;
<new DOMString> = <HTMLTableColElement>.align;
<HTMLTableColElement>.align = "<align_value>";
<new DOMString> = <HTMLTableColElement>.ch;
<HTMLTableColElement>.ch = <DOMString>;
<new DOMString> = <HTMLTableColElement>.chOff;
<HTMLTableColElement>.chOff = <DOMString>;
<new DOMString> = <HTMLTableColElement>.vAlign;
<HTMLTableColElement>.vAlign = "<valign_value>";
<new DOMString> = <HTMLTableColElement>.width;
<HTMLTableColElement>.width = "<width_value>";

#HTMLDialogElement
!extends HTMLDialogElement Element
<new Element> = <HTMLDialogElement>;
<new boolean> = <HTMLDialogElement>.open;
<HTMLDialogElement>.open = <boolean>;
<new DOMString> = <HTMLDialogElement>.returnValue;
<HTMLDialogElement>.returnValue = <DOMString>;
<HTMLDialogElement>.show();
<HTMLDialogElement>.showModal();
<HTMLDialogElement>.close();
<HTMLDialogElement>.close(<DOMString>);

#HTMLTextAreaElement
!extends HTMLTextAreaElement Element
<new Element> = <HTMLTextAreaElement>;
<new boolean> = <HTMLTextAreaElement>.autofocus;
<HTMLTextAreaElement>.autofocus = <boolean>;
<new long> = <HTMLTextAreaElement>.cols;
<HTMLTextAreaElement>.cols = <fuzzint>;
<new DOMString> = <HTMLTextAreaElement>.dirName;
<HTMLTextAreaElement>.dirName = "<dirname_value>";
<new boolean> = <HTMLTextAreaElement>.disabled;
<HTMLTextAreaElement>.disabled = <boolean>;
<new HTMLFormElement> = <HTMLTextAreaElement>.form;
<new DOMString> = <HTMLTextAreaElement>.inputMode;
<HTMLTextAreaElement>.inputMode = "<inputmode_value>";
<new long> = <HTMLTextAreaElement>.maxLength;
<HTMLTextAreaElement>.maxLength = <fuzzint>;
<new long> = <HTMLTextAreaElement>.minLength;
<HTMLTextAreaElement>.minLength = <fuzzint>;
<new DOMString> = <HTMLTextAreaElement>.name;
<HTMLTextAreaElement>.name = "<name_value>";
<new DOMString> = <HTMLTextAreaElement>.placeholder;
<HTMLTextAreaElement>.placeholder = "<placeholder_value>";
<new boolean> = <HTMLTextAreaElement>.readOnly;
<HTMLTextAreaElement>.readOnly = <boolean>;
<new boolean> = <HTMLTextAreaElement>.required;
<HTMLTextAreaElement>.required = <boolean>;
<new long> = <HTMLTextAreaElement>.rows;
<HTMLTextAreaElement>.rows = <fuzzint>;
<new DOMString> = <HTMLTextAreaElement>.wrap;
<HTMLTextAreaElement>.wrap = "<wrap_value>";
<new DOMString> = <HTMLTextAreaElement>.type;
<new DOMString> = <HTMLTextAreaElement>.defaultValue;
<HTMLTextAreaElement>.defaultValue = <DOMString>;
<new DOMString> = <HTMLTextAreaElement>.value;
<HTMLTextAreaElement>.value = "<value_value>";
<new long> = <HTMLTextAreaElement>.textLength;
<new boolean> = <HTMLTextAreaElement>.willValidate;
<new ValidityState> = <HTMLTextAreaElement>.validity;
<new DOMString> = <HTMLTextAreaElement>.validationMessage;
<new boolean> = <HTMLTextAreaElement>.checkValidity();
<new boolean> = <HTMLTextAreaElement>.reportValidity();
<HTMLTextAreaElement>.setCustomValidity(<DOMString>);
<new NodeList> = <HTMLTextAreaElement>.labels;
<HTMLTextAreaElement>.select();
<new long> = <HTMLTextAreaElement>.selectionStart;
<HTMLTextAreaElement>.selectionStart = <fuzzint>;
<new long> = <HTMLTextAreaElement>.selectionEnd;
<HTMLTextAreaElement>.selectionEnd = <fuzzint>;
<new DOMString> = <HTMLTextAreaElement>.selectionDirection;
<HTMLTextAreaElement>.selectionDirection = <DOMString>;
<HTMLTextAreaElement>.setRangeText(<DOMString>);
<HTMLTextAreaElement>.setRangeText(<DOMString>,<fuzzint>,<fuzzint>);
<HTMLTextAreaElement>.setRangeText(<DOMString>,<fuzzint>,<fuzzint>,<SelectionMode>);
<HTMLTextAreaElement>.setSelectionRange();
<HTMLTextAreaElement>.setSelectionRange(<fuzzint>);
<HTMLTextAreaElement>.setSelectionRange(<fuzzint>,<fuzzint>);
<HTMLTextAreaElement>.setSelectionRange(<fuzzint>,<fuzzint>,<DOMString>);
<new DOMString> = <HTMLTextAreaElement>.autocapitalize;
<HTMLTextAreaElement>.autocapitalize = <DOMString>;

#HTMLButtonElement
!extends HTMLButtonElement Element
<new Element> = <HTMLButtonElement>;
<new boolean> = <HTMLButtonElement>.autofocus;
<HTMLButtonElement>.autofocus = <boolean>;
<new boolean> = <HTMLButtonElement>.disabled;
<HTMLButtonElement>.disabled = <boolean>;
<new HTMLFormElement> = <HTMLButtonElement>.form;
<new DOMString> = <HTMLButtonElement>.formAction;
<HTMLButtonElement>.formAction = "<formaction_value>";
<new DOMString> = <HTMLButtonElement>.formEnctype;
<HTMLButtonElement>.formEnctype = "<formenctype_value>";
<new DOMString> = <HTMLButtonElement>.formMethod;
<HTMLButtonElement>.formMethod = "<formmethod_value>";
<new boolean> = <HTMLButtonElement>.formNoValidate;
<HTMLButtonElement>.formNoValidate = <boolean>;
<new DOMString> = <HTMLButtonElement>.formTarget;
<HTMLButtonElement>.formTarget = "<formtarget_value>";
<new DOMString> = <HTMLButtonElement>.name;
<HTMLButtonElement>.name = "<name_value>";
<new DOMString> = <HTMLButtonElement>.type;
<HTMLButtonElement>.type = "<type_value>";
<new DOMString> = <HTMLButtonElement>.value;
<HTMLButtonElement>.value = "<value_value>";
<new boolean> = <HTMLButtonElement>.willValidate;
<new ValidityState> = <HTMLButtonElement>.validity;
<new DOMString> = <HTMLButtonElement>.validationMessage;
<new boolean> = <HTMLButtonElement>.checkValidity();
<new boolean> = <HTMLButtonElement>.reportValidity();
<HTMLButtonElement>.setCustomValidity(<DOMString>);
<new NodeList> = <HTMLButtonElement>.labels;

#HTMLOListElement
!extends HTMLOListElement Element
<new Element> = <HTMLOListElement>;
<new boolean> = <HTMLOListElement>.reversed;
<HTMLOListElement>.reversed = <boolean>;
<new long> = <HTMLOListElement>.start;
<HTMLOListElement>.start = <fuzzint>;
<new DOMString> = <HTMLOListElement>.type;
<HTMLOListElement>.type = "<type_value>";
<new boolean> = <HTMLOListElement>.compact;
<HTMLOListElement>.compact = <boolean>;

#HTMLProgressElement
!extends HTMLProgressElement Element
<new Element> = <HTMLProgressElement>;
<new double> = <HTMLProgressElement>.value;
<HTMLProgressElement>.value = <double>;
<new double> = <HTMLProgressElement>.max;
<HTMLProgressElement>.max = <double>;
<new double> = <HTMLProgressElement>.position;
<new NodeList> = <HTMLProgressElement>.labels;

#HTMLQuoteElement
!extends HTMLQuoteElement Element
<new Element> = <HTMLQuoteElement>;
<new DOMString> = <HTMLQuoteElement>.cite;
<HTMLQuoteElement>.cite = "<cite_value>";

#HTMLFormElement
!extends HTMLFormElement Element
<new Element> = <HTMLFormElement>;
<new DOMString> = <HTMLFormElement>.acceptCharset;
<HTMLFormElement>.acceptCharset = <DOMString>;
<new DOMString> = <HTMLFormElement>.action;
<HTMLFormElement>.action = <DOMString>;
<new DOMString> = <HTMLFormElement>.autocomplete;
<HTMLFormElement>.autocomplete = "<autocomplete_value>";
<new DOMString> = <HTMLFormElement>.enctype;
<HTMLFormElement>.enctype = "<enctype_value>";
<new DOMString> = <HTMLFormElement>.encoding;
<HTMLFormElement>.encoding = "<encoding_value>";
<new DOMString> = <HTMLFormElement>.method;
<HTMLFormElement>.method = "<method_value>";
<new DOMString> = <HTMLFormElement>.name;
<HTMLFormElement>.name = "<name_value>";
<new boolean> = <HTMLFormElement>.noValidate;
<HTMLFormElement>.noValidate = <boolean>;
<new DOMString> = <HTMLFormElement>.target;
<HTMLFormElement>.target = "<target_value>";
<new HTMLFormControlsCollection> = <HTMLFormElement>.elements;
<new long> = <HTMLFormElement>.length;
<new Element> = <HTMLFormElement id=1>[<int min=0 max=100>%<HTMLFormElement id=1>.length];
<HTMLFormElement>.submit();
<HTMLFormElement>.reset();
<new boolean> = <HTMLFormElement>.checkValidity();
<new boolean> = <HTMLFormElement>.reportValidity();

#ValidityState
<new boolean> = <ValidityState>.valueMissing;
<new boolean> = <ValidityState>.typeMismatch;
<new boolean> = <ValidityState>.patternMismatch;
<new boolean> = <ValidityState>.tooLong;
<new boolean> = <ValidityState>.tooShort;
<new boolean> = <ValidityState>.rangeUnderflow;
<new boolean> = <ValidityState>.rangeOverflow;
<new boolean> = <ValidityState>.stepMismatch;
<new boolean> = <ValidityState>.badInput;
<new boolean> = <ValidityState>.customError;
<new boolean> = <ValidityState>.valid;

#HTMLHeadingElement
!extends HTMLHeadingElement Element
<new Element> = <HTMLHeadingElement>;
<new DOMString> = <HTMLHeadingElement>.align;
<HTMLHeadingElement>.align = "<align_value>";

#HTMLAudioElement
!extends HTMLAudioElement HTMLMediaElement
<new HTMLMediaElement> = <HTMLAudioElement>;

#HTMLLegendElement
!extends HTMLLegendElement Element
<new Element> = <HTMLLegendElement>;
<new HTMLFormElement> = <HTMLLegendElement>.form;
<new DOMString> = <HTMLLegendElement>.align;
<HTMLLegendElement>.align = "<align_value>";

!extends Element GlobalEventHandlers
<new GlobalEventHandlers> = <Element>;

#HTMLElement
<new DOMString> = <Element>.title;
<Element>.title = "<title_value>";
<new DOMString> = <Element>.lang;
<Element>.lang = "<lang_value>";
<new boolean> = <Element>.translate;
<Element>.translate = <boolean>;
<new DOMString> = <Element>.dir;
<Element>.dir = "<dir_value>";
<new DOMStringMap> = <Element>.dataset;
<new boolean> = <Element>.hidden;
<Element>.hidden = <boolean>;
<Element>.click();
<new long> = <Element>.tabIndex;
<Element>.tabIndex = <fuzzint>;
<Element>.focus();
<Element>.blur();
<new DOMString> = <Element>.accessKey;
<Element>.accessKey = "<accesskey_value>";
<new boolean> = <Element>.draggable;
<Element>.draggable = <boolean>;
<new HTMLMenuElement> = <Element>.contextMenu;
<Element>.contextMenu = <HTMLMenuElement>;
<new boolean> = <Element>.spellcheck;
<Element>.spellcheck = <boolean>;
<new DOMString> = <Element>.contentEditable;
<Element>.contentEditable = "<contenteditable_value>";
<new boolean> = <Element>.isContentEditable;
<new Element> = <Element>.offsetParent;
<new long> = <Element>.offsetTop;
<new long> = <Element>.offsetLeft;
<new long> = <Element>.offsetWidth;
<new long> = <Element>.offsetHeight;
<new CSSStyleDeclaration> = <Element>.style;
<new DOMString> = <Element>.innerText;
<Element>.innerText = <DOMString>;
<new DOMString> = <Element>.outerText;
<Element>.outerText = <DOMString>;
<new DOMString> = <Element>.webkitdropzone;
<Element>.webkitdropzone = <DOMString>;

#HTMLSlotElement
!extends HTMLSlotElement Element
<new Element> = <HTMLSlotElement>;
<new DOMString> = <HTMLSlotElement>.name;
<HTMLSlotElement>.name = "<name_value>";
<new NodeList> = <HTMLSlotElement>.assignedNodes();
<new NodeList> = <HTMLSlotElement>.assignedNodes(<AssignedNodesOptions>);

#HTMLPreElement
!extends HTMLPreElement Element
<new Element> = <HTMLPreElement>;
<new long> = <HTMLPreElement>.width;
<HTMLPreElement>.width = <fuzzint>;

#HTMLKeygenElement
!extends HTMLKeygenElement Element
<new Element> = <HTMLKeygenElement>;
<new boolean> = <HTMLKeygenElement>.autofocus;
<HTMLKeygenElement>.autofocus = <boolean>;
<new DOMString> = <HTMLKeygenElement>.challenge;
<HTMLKeygenElement>.challenge = <DOMString>;
<new boolean> = <HTMLKeygenElement>.disabled;
<HTMLKeygenElement>.disabled = <boolean>;
<new HTMLFormElement> = <HTMLKeygenElement>.form;
<new DOMString> = <HTMLKeygenElement>.keytype;
<HTMLKeygenElement>.keytype = "<keytype_value>";
<new DOMString> = <HTMLKeygenElement>.name;
<HTMLKeygenElement>.name = "<name_value>";
<new DOMString> = <HTMLKeygenElement>.type;
<new boolean> = <HTMLKeygenElement>.willValidate;
<new ValidityState> = <HTMLKeygenElement>.validity;
<new DOMString> = <HTMLKeygenElement>.validationMessage;
<new boolean> = <HTMLKeygenElement>.checkValidity();
<new boolean> = <HTMLKeygenElement>.reportValidity();
<HTMLKeygenElement>.setCustomValidity(<DOMString>);
<new NodeList> = <HTMLKeygenElement>.labels;

#HTMLSourceElement
!extends HTMLSourceElement Element
<new Element> = <HTMLSourceElement>;
<new DOMString> = <HTMLSourceElement>.src;
<HTMLSourceElement>.src = "<src_value>";
<new DOMString> = <HTMLSourceElement>.type;
<HTMLSourceElement>.type = "<type_value>";
<new DOMString> = <HTMLSourceElement>.srcset;
<HTMLSourceElement>.srcset = "<srcset_value>";
<new DOMString> = <HTMLSourceElement>.sizes;
<HTMLSourceElement>.sizes = "<sizes_value>";
<new DOMString> = <HTMLSourceElement>.media;
<HTMLSourceElement>.media = "<media_value>";

#HTMLMetaElement
!extends HTMLMetaElement Element
<new Element> = <HTMLMetaElement>;
<new DOMString> = <HTMLMetaElement>.name;
<HTMLMetaElement>.name = "<name_value>";
<new DOMString> = <HTMLMetaElement>.httpEquiv;
<HTMLMetaElement>.httpEquiv = <DOMString>;
<new DOMString> = <HTMLMetaElement>.content;
<HTMLMetaElement>.content = "<content_value>";
<new DOMString> = <HTMLMetaElement>.scheme;
<HTMLMetaElement>.scheme = "<scheme_value>";

#HTMLBaseElement
!extends HTMLBaseElement Element
<new Element> = <HTMLBaseElement>;
<new DOMString> = <HTMLBaseElement>.href;
<HTMLBaseElement>.href = "<href_value>";
<new DOMString> = <HTMLBaseElement>.target;
<HTMLBaseElement>.target = "<target_value>";

#HTMLTableRowElement
!extends HTMLTableRowElement Element
<new Element> = <HTMLTableRowElement>;
<new long> = <HTMLTableRowElement>.rowIndex;
<new long> = <HTMLTableRowElement>.sectionRowIndex;
<new HTMLCollection> = <HTMLTableRowElement>.cells;
<new Element> = <HTMLTableRowElement>.insertCell();
<new Element> = <HTMLTableRowElement>.insertCell(<fuzzint>);
<HTMLTableRowElement>.deleteCell(<fuzzint>);
<new DOMString> = <HTMLTableRowElement>.align;
<HTMLTableRowElement>.align = "<align_value>";
<new DOMString> = <HTMLTableRowElement>.ch;
<HTMLTableRowElement>.ch = <DOMString>;
<new DOMString> = <HTMLTableRowElement>.chOff;
<HTMLTableRowElement>.chOff = <DOMString>;
<new DOMString> = <HTMLTableRowElement>.vAlign;
<HTMLTableRowElement>.vAlign = "<valign_value>";
<new DOMString> = <HTMLTableRowElement>.bgColor;
<HTMLTableRowElement>.bgColor = "<bgcolor_value>";

#HTMLTableCaptionElement
!extends HTMLTableCaptionElement Element
<new Element> = <HTMLTableCaptionElement>;
<new DOMString> = <HTMLTableCaptionElement>.align;
<HTMLTableCaptionElement>.align = "<align_value>";
!extends HTMLFrameSetElement WindowEventHandlers
<new WindowEventHandlers> = <HTMLFrameSetElement>;

#HTMLFrameSetElement
!extends HTMLFrameSetElement Element
<new Element> = <HTMLFrameSetElement>;
<new DOMString> = <HTMLFrameSetElement>.cols;
<HTMLFrameSetElement>.cols = "<cols_value>";
<new DOMString> = <HTMLFrameSetElement>.rows;
<HTMLFrameSetElement>.rows = "<rows_value>";
<new EventHandler> = <HTMLFrameSetElement>.onblur;
<HTMLFrameSetElement>.onblur = <EventHandler>;
<new EventHandler> = <HTMLFrameSetElement>.onerror;
<HTMLFrameSetElement>.onerror = <EventHandler>;
<new EventHandler> = <HTMLFrameSetElement>.onfocus;
<HTMLFrameSetElement>.onfocus = <EventHandler>;
<new EventHandler> = <HTMLFrameSetElement>.onload;
<HTMLFrameSetElement>.onload = <EventHandler>;
<new EventHandler> = <HTMLFrameSetElement>.onresize;
<HTMLFrameSetElement>.onresize = <EventHandler>;
<new EventHandler> = <HTMLFrameSetElement>.onscroll;
<HTMLFrameSetElement>.onscroll = <EventHandler>;
<new Window> = <HTMLFrameSetElement>["<elementid>"];
<new EventHandler> = <HTMLFrameSetElement>.onorientationchange;
<HTMLFrameSetElement>.onorientationchange = <EventHandler>;

#HTMLMediaElement
!extends HTMLMediaElement Element
<new Element> = <HTMLMediaElement>;
<new MediaError> = <HTMLMediaElement>.error;
<new DOMString> = <HTMLMediaElement>.src;
<HTMLMediaElement>.src = "<audiosrc>";
<HTMLMediaElement>.src = "<videosrc>";
<new DOMString> = <HTMLMediaElement>.currentSrc;
<new DOMString> = <HTMLMediaElement>.crossOrigin;
<HTMLMediaElement>.crossOrigin = "<crossorigin_value>";
<new short> = <HTMLMediaElement>.networkState;
<new DOMString> = <HTMLMediaElement>.preload;
<HTMLMediaElement>.preload = "<preload_value>";
<new TimeRanges> = <HTMLMediaElement>.buffered;
<HTMLMediaElement>.load();
<new CanPlayTypeResult> = <HTMLMediaElement>.canPlayType(<DOMString>);
<new short> = <HTMLMediaElement>.readyState;
<new boolean> = <HTMLMediaElement>.seeking;
<new double> = <HTMLMediaElement>.currentTime;
<HTMLMediaElement>.currentTime = <double>;
<new double> = <HTMLMediaElement>.duration;
<new boolean> = <HTMLMediaElement>.paused;
<new double> = <HTMLMediaElement>.defaultPlaybackRate;
<HTMLMediaElement>.defaultPlaybackRate = <double>;
<new double> = <HTMLMediaElement>.playbackRate;
<HTMLMediaElement>.playbackRate = <double>;
<new TimeRanges> = <HTMLMediaElement>.played;
<new TimeRanges> = <HTMLMediaElement>.seekable;
<new boolean> = <HTMLMediaElement>.ended;
<new boolean> = <HTMLMediaElement>.autoplay;
<HTMLMediaElement>.autoplay = <boolean>;
<new boolean> = <HTMLMediaElement>.loop;
<HTMLMediaElement>.loop = <boolean>;
<new Promise_void_> = <HTMLMediaElement>.play();
<HTMLMediaElement>.pause();
<new boolean> = <HTMLMediaElement>.controls;
<HTMLMediaElement>.controls = <boolean>;
<new double> = <HTMLMediaElement>.volume;
<HTMLMediaElement>.volume = <double>;
<new boolean> = <HTMLMediaElement>.muted;
<HTMLMediaElement>.muted = <boolean>;
<new boolean> = <HTMLMediaElement>.defaultMuted;
<HTMLMediaElement>.defaultMuted = <boolean>;
<new AudioTrackList> = <HTMLMediaElement>.audioTracks;
<new VideoTrackList> = <HTMLMediaElement>.videoTracks;
<new TextTrackList> = <HTMLMediaElement>.textTracks;
<new TextTrack> = <HTMLMediaElement>.addTextTrack(<TextTrackKind>);
<new TextTrack> = <HTMLMediaElement>.addTextTrack(<TextTrackKind>,<DOMString>);
<new TextTrack> = <HTMLMediaElement>.addTextTrack(<TextTrackKind>,<DOMString>,<DOMString>);
<new long> = <HTMLMediaElement>.webkitAudioDecodedByteCount;
<new long> = <HTMLMediaElement>.webkitVideoDecodedByteCount;

#HTMLModElement
!extends HTMLModElement Element
<new Element> = <HTMLModElement>;
<new DOMString> = <HTMLModElement>.cite;
<HTMLModElement>.cite = "<cite_value>";
<new DOMString> = <HTMLModElement>.dateTime;
<HTMLModElement>.dateTime = "<datetime_value>";

#HTMLParagraphElement
!extends HTMLParagraphElement Element
<new Element> = <HTMLParagraphElement>;
<new DOMString> = <HTMLParagraphElement>.align;
<HTMLParagraphElement>.align = "<align_value>";

#HTMLObjectElement
!extends HTMLObjectElement Element
<new Element> = <HTMLObjectElement>;
<new DOMString> = <HTMLObjectElement>.data;
<HTMLObjectElement>.data = "<data_value>";
<new DOMString> = <HTMLObjectElement>.type;
<HTMLObjectElement>.type = "<type_value>";
<new DOMString> = <HTMLObjectElement>.name;
<HTMLObjectElement>.name = "<name_value>";
<new DOMString> = <HTMLObjectElement>.useMap;
<HTMLObjectElement>.useMap = "<usemap_value>";
<new HTMLFormElement> = <HTMLObjectElement>.form;
<new DOMString> = <HTMLObjectElement>.width;
<HTMLObjectElement>.width = "<width_value>";
<new DOMString> = <HTMLObjectElement>.height;
<HTMLObjectElement>.height = "<height_value>";
<new Document> = <HTMLObjectElement>.contentDocument;
<new Window> = <HTMLObjectElement>.contentWindow;
<new Document> = <HTMLObjectElement>.getSVGDocument();
<new boolean> = <HTMLObjectElement>.willValidate;
<new ValidityState> = <HTMLObjectElement>.validity;
<new DOMString> = <HTMLObjectElement>.validationMessage;
<new boolean> = <HTMLObjectElement>.checkValidity();
<new boolean> = <HTMLObjectElement>.reportValidity();
<HTMLObjectElement>.setCustomValidity(<DOMString>);
<new DOMString> = <HTMLObjectElement>.align;
<HTMLObjectElement>.align = "<align_value>";
<new DOMString> = <HTMLObjectElement>.archive;
<HTMLObjectElement>.archive = "<archive_value>";
<new DOMString> = <HTMLObjectElement>.code;
<HTMLObjectElement>.code = "<code_value>";
<new boolean> = <HTMLObjectElement>.declare;
<HTMLObjectElement>.declare = <boolean>;
<new long> = <HTMLObjectElement>.hspace;
<HTMLObjectElement>.hspace = <fuzzint>;
<new DOMString> = <HTMLObjectElement>.standby;
<HTMLObjectElement>.standby = "<standby_value>";
<new long> = <HTMLObjectElement>.vspace;
<HTMLObjectElement>.vspace = <fuzzint>;
<new DOMString> = <HTMLObjectElement>.codeBase;
<HTMLObjectElement>.codeBase = "<codebase_value>";
<new DOMString> = <HTMLObjectElement>.codeType;
<HTMLObjectElement>.codeType = "<codetype_value>";
<new DOMString> = <HTMLObjectElement>.border;
<HTMLObjectElement>.border = "<border_value>";
<new Element> = <HTMLObjectElement>[<DOMString>];
<HTMLObjectElement>[<DOMString>] = <Element>;

#HTMLSelectElement
!extends HTMLSelectElement Element
<new Element> = <HTMLSelectElement>;
<new boolean> = <HTMLSelectElement>.autofocus;
<HTMLSelectElement>.autofocus = <boolean>;
<new boolean> = <HTMLSelectElement>.disabled;
<HTMLSelectElement>.disabled = <boolean>;
<new HTMLFormElement> = <HTMLSelectElement>.form;
<new boolean> = <HTMLSelectElement>.multiple;
<HTMLSelectElement>.multiple = <boolean>;
<new DOMString> = <HTMLSelectElement>.name;
<HTMLSelectElement>.name = "<name_value>";
<new boolean> = <HTMLSelectElement>.required;
<HTMLSelectElement>.required = <boolean>;
<new long> = <HTMLSelectElement>.size;
<HTMLSelectElement>.size = <fuzzint>;
<new DOMString> = <HTMLSelectElement>.type;
<new HTMLOptionsCollection> = <HTMLSelectElement>.options;
<new long> = <HTMLSelectElement>.length;
<HTMLSelectElement>.length = <fuzzint>;
<new HTMLOptionElement> = <HTMLSelectElement id=1>.item(<int min=0 max=100>%<HTMLSelectElement id=1>.length);
<new HTMLOptionElement> = <HTMLSelectElement id=1>[<int min=0 max=100>%<HTMLSelectElement id=1>.length];
<HTMLSelectElement>.add(<HTMLOptionElement>);
<HTMLSelectElement>.add(<HTMLOptionElement>,<Element>);
<HTMLSelectElement>.add(<HTMLOptionElement>);
<HTMLSelectElement>.add(<HTMLOptionElement>,<fuzzint>);
<HTMLSelectElement>.add(<HTMLOptGroupElement>);
<HTMLSelectElement>.add(<HTMLOptGroupElement>,<Element>);
<HTMLSelectElement>.add(<HTMLOptGroupElement>);
<HTMLSelectElement>.add(<HTMLOptGroupElement>,<fuzzint>);
<HTMLSelectElement>.remove();
<HTMLSelectElement>.remove(<fuzzint>);
<HTMLSelectElement>[<fuzzint>] = <HTMLOptionElement>;
<new HTMLCollection> = <HTMLSelectElement>.selectedOptions;
<new long> = <HTMLSelectElement>.selectedIndex;
<HTMLSelectElement>.selectedIndex = <fuzzint>;
<new DOMString> = <HTMLSelectElement>.value;
<HTMLSelectElement>.value = "<value_value>";
<new boolean> = <HTMLSelectElement>.willValidate;
<new ValidityState> = <HTMLSelectElement>.validity;
<new DOMString> = <HTMLSelectElement>.validationMessage;
<new boolean> = <HTMLSelectElement>.checkValidity();
<new boolean> = <HTMLSelectElement>.reportValidity();
<HTMLSelectElement>.setCustomValidity(<DOMString>);
<new NodeList> = <HTMLSelectElement>.labels;

#HTMLDirectoryElement
!extends HTMLDirectoryElement Element
<new Element> = <HTMLDirectoryElement>;
<new boolean> = <HTMLDirectoryElement>.compact;
<HTMLDirectoryElement>.compact = <boolean>;

#HTMLParamElement
!extends HTMLParamElement Element
<new Element> = <HTMLParamElement>;
<new DOMString> = <HTMLParamElement>.name;
<HTMLParamElement>.name = "<name_value>";
<new DOMString> = <HTMLParamElement>.value;
<HTMLParamElement>.value = "<value_value>";
<new DOMString> = <HTMLParamElement>.type;
<HTMLParamElement>.type = "<type_value>";
<new DOMString> = <HTMLParamElement>.valueType;
<HTMLParamElement>.valueType = "<valuetype_value>";

#HTMLPictureElement
!extends HTMLPictureElement Element
<new Element> = <HTMLPictureElement>;

#HTMLAllCollection
<new long> = <HTMLAllCollection>.length;
<new Element> = <HTMLAllCollection id=1>[<int min=0 max=100>%<HTMLAllCollection id=1>.length];

#HTMLDataListElement
!extends HTMLDataListElement Element
<new Element> = <HTMLDataListElement>;
<new HTMLCollection> = <HTMLDataListElement>.options;

#HTMLHRElement
!extends HTMLHRElement Element
<new Element> = <HTMLHRElement>;
<new DOMString> = <HTMLHRElement>.align;
<HTMLHRElement>.align = "<align_value>";
<new DOMString> = <HTMLHRElement>.color;
<HTMLHRElement>.color = "<color_value>";
<new boolean> = <HTMLHRElement>.noShade;
<HTMLHRElement>.noShade = <boolean>;
<new DOMString> = <HTMLHRElement>.size;
<HTMLHRElement>.size = "<size_value>";
<new DOMString> = <HTMLHRElement>.width;
<HTMLHRElement>.width = "<width_value>";
!extends HTMLBodyElement WindowEventHandlers
<new WindowEventHandlers> = <HTMLBodyElement>;

#HTMLBodyElement
!extends HTMLBodyElement Element
<new Element> = <HTMLBodyElement>;
<new DOMString> = <HTMLBodyElement>.text;
<HTMLBodyElement>.text = "<text_value>";
<new DOMString> = <HTMLBodyElement>.link;
<HTMLBodyElement>.link = "<link_value>";
<new DOMString> = <HTMLBodyElement>.vLink;
<HTMLBodyElement>.vLink = "<vlink_value>";
<new DOMString> = <HTMLBodyElement>.aLink;
<HTMLBodyElement>.aLink = "<alink_value>";
<new DOMString> = <HTMLBodyElement>.bgColor;
<HTMLBodyElement>.bgColor = "<bgcolor_value>";
<new DOMString> = <HTMLBodyElement>.background;
<HTMLBodyElement>.background = "<background_value>";
<new EventHandler> = <HTMLBodyElement>.onblur;
<HTMLBodyElement>.onblur = <EventHandler>;
<new EventHandler> = <HTMLBodyElement>.onerror;
<HTMLBodyElement>.onerror = <EventHandler>;
<new EventHandler> = <HTMLBodyElement>.onfocus;
<HTMLBodyElement>.onfocus = <EventHandler>;
<new EventHandler> = <HTMLBodyElement>.onload;
<HTMLBodyElement>.onload = <EventHandler>;
<new EventHandler> = <HTMLBodyElement>.onresize;
<HTMLBodyElement>.onresize = <EventHandler>;
<new EventHandler> = <HTMLBodyElement>.onscroll;
<HTMLBodyElement>.onscroll = <EventHandler>;
<new EventHandler> = <HTMLBodyElement>.onorientationchange;
<HTMLBodyElement>.onorientationchange = <EventHandler>;

#HTMLLinkElement
!extends HTMLLinkElement Element
<new Element> = <HTMLLinkElement>;
<new boolean> = <HTMLLinkElement>.disabled;
<HTMLLinkElement>.disabled = <boolean>;
<new DOMString> = <HTMLLinkElement>.href;
<HTMLLinkElement>.href = "<href_value>";
<new DOMString> = <HTMLLinkElement>.crossOrigin;
<HTMLLinkElement>.crossOrigin = "<crossorigin_value>";
<new DOMString> = <HTMLLinkElement>.rel;
<HTMLLinkElement>.rel = "<rel_value>";
<new DOMTokenList> = <HTMLLinkElement>.relList;
<new DOMString> = <HTMLLinkElement>.media;
<HTMLLinkElement>.media = "<media_value>";
<new DOMString> = <HTMLLinkElement>.hreflang;
<HTMLLinkElement>.hreflang = "<hreflang_value>";
<new DOMString> = <HTMLLinkElement>.type;
<HTMLLinkElement>.type = "<type_value>";
<new DOMString> = <HTMLLinkElement>.as;
<HTMLLinkElement>.as = "<as_value>";
<new DOMTokenList> = <HTMLLinkElement>.sizes;
<new DOMString> = <HTMLLinkElement>.charset;
<HTMLLinkElement>.charset = "<charset_value>";
<new DOMString> = <HTMLLinkElement>.rev;
<HTMLLinkElement>.rev = "<rev_value>";
<new DOMString> = <HTMLLinkElement>.target;
<HTMLLinkElement>.target = "<target_value>";
<new StyleSheet> = <HTMLLinkElement>.sheet;
<new Document> = <HTMLLinkElement>.import;
<new DOMString> = <HTMLLinkElement>.integrity;
<HTMLLinkElement>.integrity = <DOMString>;
<new USVString> = <HTMLLinkElement>.scope;
<HTMLLinkElement>.scope = <USVString>;

#HTMLCanvasElement
!extends HTMLCanvasElement Element
<new Element> = <HTMLCanvasElement>;
<new long> = <HTMLCanvasElement>.width;
<HTMLCanvasElement>.width = <fuzzint>;
<new long> = <HTMLCanvasElement>.height;
<HTMLCanvasElement>.height = <fuzzint>;
<new DOMString> = <HTMLCanvasElement>.toDataURL();
<new DOMString> = <HTMLCanvasElement>.toDataURL(<DOMString>);
<new DOMString> = <HTMLCanvasElement>.toDataURL(<DOMString>,<any>);
<HTMLCanvasElement>.toBlob(<BlobCallback>);
<HTMLCanvasElement>.toBlob(<BlobCallback>,<DOMString>);
<HTMLCanvasElement>.toBlob(<BlobCallback>,<DOMString>,<any>);

#HTMLDListElement
!extends HTMLDListElement Element
<new Element> = <HTMLDListElement>;
<new boolean> = <HTMLDListElement>.compact;
<HTMLDListElement>.compact = <boolean>;

#HTMLScriptElement
!extends HTMLScriptElement Element
<new Element> = <HTMLScriptElement>;
<new DOMString> = <HTMLScriptElement>.src;
<HTMLScriptElement>.src = "<src_value>";
<new DOMString> = <HTMLScriptElement>.type;
<HTMLScriptElement>.type = "<type_value>";
<new DOMString> = <HTMLScriptElement>.charset;
<HTMLScriptElement>.charset = "<charset_value>";
<new boolean> = <HTMLScriptElement>.async;
<HTMLScriptElement>.async = <boolean>;
<new boolean> = <HTMLScriptElement>.defer;
<HTMLScriptElement>.defer = <boolean>;
<new DOMString> = <HTMLScriptElement>.crossOrigin;
<HTMLScriptElement>.crossOrigin = "<crossorigin_value>";
<new DOMString> = <HTMLScriptElement>.text;
<HTMLScriptElement>.text = "<text_value>";
<new DOMString> = <HTMLScriptElement>.event;
<HTMLScriptElement>.event = <DOMString>;
<new DOMString> = <HTMLScriptElement>.htmlFor;
<HTMLScriptElement>.htmlFor = <DOMString>;
<new DOMString> = <HTMLScriptElement>.nonce;
<HTMLScriptElement>.nonce = "<nonce_value>";
<new DOMString> = <HTMLScriptElement>.integrity;
<HTMLScriptElement>.integrity = <DOMString>;

#HTMLOutputElement
!extends HTMLOutputElement Element
<new Element> = <HTMLOutputElement>;
<new DOMTokenList> = <HTMLOutputElement>.htmlFor;
<new HTMLFormElement> = <HTMLOutputElement>.form;
<new DOMString> = <HTMLOutputElement>.name;
<HTMLOutputElement>.name = "<name_value>";
<new DOMString> = <HTMLOutputElement>.type;
<new DOMString> = <HTMLOutputElement>.defaultValue;
<HTMLOutputElement>.defaultValue = <DOMString>;
<new DOMString> = <HTMLOutputElement>.value;
<HTMLOutputElement>.value = "<value_value>";
<new boolean> = <HTMLOutputElement>.willValidate;
<new ValidityState> = <HTMLOutputElement>.validity;
<new DOMString> = <HTMLOutputElement>.validationMessage;
<new boolean> = <HTMLOutputElement>.checkValidity();
<new boolean> = <HTMLOutputElement>.reportValidity();
<HTMLOutputElement>.setCustomValidity(<DOMString>);
<new NodeList> = <HTMLOutputElement>.labels;

#HTMLTrackElement
!extends HTMLTrackElement Element
<new Element> = <HTMLTrackElement>;
<new DOMString> = <HTMLTrackElement>.kind;
<HTMLTrackElement>.kind = "<kind_value>";
<new DOMString> = <HTMLTrackElement>.src;
<HTMLTrackElement>.src = "<src_value>";
<new DOMString> = <HTMLTrackElement>.srclang;
<HTMLTrackElement>.srclang = "<srclang_value>";
<new DOMString> = <HTMLTrackElement>.label;
<HTMLTrackElement>.label = "<label_value>";
<new boolean> = <HTMLTrackElement>.default;
<HTMLTrackElement>.default = <boolean>;
<new short> = <HTMLTrackElement>.readyState;
<new TextTrack> = <HTMLTrackElement>.track;

#HTMLUListElement
!extends HTMLUListElement Element
<new Element> = <HTMLUListElement>;
<new boolean> = <HTMLUListElement>.compact;
<HTMLUListElement>.compact = <boolean>;
<new DOMString> = <HTMLUListElement>.type;
<HTMLUListElement>.type = "<type_value>";

#HTMLSpanElement
!extends HTMLSpanElement Element
<new Element> = <HTMLSpanElement>;
!extends HTMLAreaElement HTMLHyperlinkElementUtils
<new HTMLHyperlinkElementUtils> = <HTMLAreaElement>;

#HTMLAreaElement
!extends HTMLAreaElement Element
<new Element> = <HTMLAreaElement>;
<new DOMString> = <HTMLAreaElement>.accessKey;
<HTMLAreaElement>.accessKey = "<char min=32 max=122>";
<new DOMString> = <HTMLAreaElement>.alt;
<HTMLAreaElement>.alt = "<alt_value>";
<new DOMString> = <HTMLAreaElement>.coords;
<HTMLAreaElement>.coords = "<coords_value>";
<new DOMString> = <HTMLAreaElement>.download;
<HTMLAreaElement>.download = "<download_value>";
<new DOMString> = <HTMLAreaElement>.shape;
<HTMLAreaElement>.shape = "<shape_value>";
<new DOMString> = <HTMLAreaElement>.target;
<HTMLAreaElement>.target = "<target_value>";
<new DOMString> = <HTMLAreaElement>.ping;
<HTMLAreaElement>.ping = "<ping_value>";
<new DOMString> = <HTMLAreaElement>.rel;
<HTMLAreaElement>.rel = "<rel_value>";
<new DOMString> = <HTMLAreaElement>.referrerPolicy;
<HTMLAreaElement>.referrerPolicy = "<referrerpolicy_value>";
<new boolean> = <HTMLAreaElement>.noHref;
<HTMLAreaElement>.noHref = <boolean>;

#HTMLOptionsCollection
!extends HTMLOptionsCollection HTMLCollection
<new HTMLCollection> = <HTMLOptionsCollection>;
<new long> = <HTMLOptionsCollection>.length;
<HTMLOptionsCollection>.length = <fuzzint>;
<HTMLOptionsCollection>[<fuzzint>] = <HTMLOptionElement>;
<HTMLOptionsCollection>.add(<HTMLOptionElement>);
<HTMLOptionsCollection>.add(<HTMLOptionElement>,<Element>);
<HTMLOptionsCollection>.add(<HTMLOptionElement>);
<HTMLOptionsCollection>.add(<HTMLOptionElement>,<fuzzint>);
<HTMLOptionsCollection>.add(<HTMLOptGroupElement>);
<HTMLOptionsCollection>.add(<HTMLOptGroupElement>,<Element>);
<HTMLOptionsCollection>.add(<HTMLOptGroupElement>);
<HTMLOptionsCollection>.add(<HTMLOptGroupElement>,<fuzzint>);
<HTMLOptionsCollection id=1>.remove(<int min=0 max=100>%<HTMLOptionsCollection id=1>.length);
<new long> = <HTMLOptionsCollection>.selectedIndex;
<HTMLOptionsCollection>.selectedIndex = <fuzzint>;
<new Element> = <HTMLOptionsCollection id=1>[<int min=0 max=100>%<HTMLOptionsCollection id=1>.length];

#HTMLBRElement
!extends HTMLBRElement Element
<new Element> = <HTMLBRElement>;
<new DOMString> = <HTMLBRElement>.clear;
<HTMLBRElement>.clear = "<clear_value>";

#HTMLDivElement
!extends HTMLDivElement Element
<new Element> = <HTMLDivElement>;
<new DOMString> = <HTMLDivElement>.align;
<HTMLDivElement>.align = "<align_value>";

#HTMLUnknownElement
!extends HTMLUnknownElement Element
<new Element> = <HTMLUnknownElement>;

#HTMLLabelElement
!extends HTMLLabelElement Element
<new Element> = <HTMLLabelElement>;
<new HTMLFormElement> = <HTMLLabelElement>.form;
<new DOMString> = <HTMLLabelElement>.htmlFor;
<HTMLLabelElement>.htmlFor = <DOMString>;
<new Element> = <HTMLLabelElement>.control;

#HTMLHyperlinkElementUtils
<new USVString> = <HTMLHyperlinkElementUtils>.href;
<HTMLHyperlinkElementUtils>.href = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.origin;
<new USVString> = <HTMLHyperlinkElementUtils>.protocol;
<HTMLHyperlinkElementUtils>.protocol = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.username;
<HTMLHyperlinkElementUtils>.username = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.password;
<HTMLHyperlinkElementUtils>.password = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.host;
<HTMLHyperlinkElementUtils>.host = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.hostname;
<HTMLHyperlinkElementUtils>.hostname = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.port;
<HTMLHyperlinkElementUtils>.port = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.pathname;
<HTMLHyperlinkElementUtils>.pathname = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.search;
<HTMLHyperlinkElementUtils>.search = <USVString>;
<new USVString> = <HTMLHyperlinkElementUtils>.hash;
<HTMLHyperlinkElementUtils>.hash = <USVString>;

#HTMLMapElement
!extends HTMLMapElement Element
<new Element> = <HTMLMapElement>;
<new DOMString> = <HTMLMapElement>.name;
<HTMLMapElement>.name = "<name_value>";
<new HTMLCollection> = <HTMLMapElement>.areas;

#FormData
<FormData>.append(<USVString>,<Blob>);
<FormData>.append(<USVString>,<Blob>,<USVString>);
<FormData>.append(<USVString>,<USVString>);
<FormData>.delete(<USVString>);
<new FormDataEntryValue> = <FormData>.get(<USVString>);
<new sequence_FormDataEntryValue_> = <FormData>.getAll(<USVString>);
<new boolean> = <FormData>.has(<USVString>);
<FormData>.set(<USVString>,<Blob>);
<FormData>.set(<USVString>,<Blob>,<USVString>);
<FormData>.set(<USVString>,<USVString>);

#MediaError
<new short> = <MediaError>.code;

#HTMLVideoElement
!extends HTMLVideoElement HTMLMediaElement
<new HTMLMediaElement> = <HTMLVideoElement>;
<new long> = <HTMLVideoElement>.width;
<HTMLVideoElement>.width = <fuzzint>;
<new long> = <HTMLVideoElement>.height;
<HTMLVideoElement>.height = <fuzzint>;
<new long> = <HTMLVideoElement>.videoWidth;
<new long> = <HTMLVideoElement>.videoHeight;
<new DOMString> = <HTMLVideoElement>.poster;
<HTMLVideoElement>.poster = "<poster_value>";
<new boolean> = <HTMLVideoElement>.webkitSupportsFullscreen;
<new boolean> = <HTMLVideoElement>.webkitDisplayingFullscreen;
<HTMLVideoElement>.webkitEnterFullscreen();
<HTMLVideoElement>.webkitExitFullscreen();
<HTMLVideoElement>.webkitEnterFullScreen();
<HTMLVideoElement>.webkitExitFullScreen();
<new long> = <HTMLVideoElement>.webkitDecodedFrameCount;
<new long> = <HTMLVideoElement>.webkitDroppedFrameCount;

#HTMLTableSectionElement
!extends HTMLTableSectionElement Element
<new Element> = <HTMLTableSectionElement>;
<new HTMLCollection> = <HTMLTableSectionElement>.rows;
<new Element> = <HTMLTableSectionElement>.insertRow();
<new Element> = <HTMLTableSectionElement>.insertRow(<fuzzint>);
<HTMLTableSectionElement id=1>.deleteRow(<int min=0 max=100>%<HTMLTableSectionElement id=1>.rows.length);
<new DOMString> = <HTMLTableSectionElement>.align;
<HTMLTableSectionElement>.align = "<align_value>";
<new DOMString> = <HTMLTableSectionElement>.ch;
<HTMLTableSectionElement>.ch = <DOMString>;
<new DOMString> = <HTMLTableSectionElement>.chOff;
<HTMLTableSectionElement>.chOff = <DOMString>;
<new DOMString> = <HTMLTableSectionElement>.vAlign;
<HTMLTableSectionElement>.vAlign = "<valign_value>";

#HTMLDetailsElement
!extends HTMLDetailsElement Element
<new Element> = <HTMLDetailsElement>;
<new boolean> = <HTMLDetailsElement>.open;
<HTMLDetailsElement>.open = <boolean>;

#HTMLFieldSetElement
!extends HTMLFieldSetElement Element
<new Element> = <HTMLFieldSetElement>;
<new boolean> = <HTMLFieldSetElement>.disabled;
<HTMLFieldSetElement>.disabled = <boolean>;
<new HTMLFormElement> = <HTMLFieldSetElement>.form;
<new DOMString> = <HTMLFieldSetElement>.name;
<HTMLFieldSetElement>.name = "<name_value>";
<new DOMString> = <HTMLFieldSetElement>.type;
<new HTMLFormControlsCollection> = <HTMLFieldSetElement>.elements;
<new boolean> = <HTMLFieldSetElement>.willValidate;
<new ValidityState> = <HTMLFieldSetElement>.validity;
<new DOMString> = <HTMLFieldSetElement>.validationMessage;
<new boolean> = <HTMLFieldSetElement>.checkValidity();
<new boolean> = <HTMLFieldSetElement>.reportValidity();
<HTMLFieldSetElement>.setCustomValidity(<DOMString>);

#HTMLTableCellElement
!extends HTMLTableCellElement Element
<new Element> = <HTMLTableCellElement>;
<new long> = <HTMLTableCellElement>.colSpan;
<HTMLTableCellElement>.colSpan = <fuzzint>;
<new long> = <HTMLTableCellElement>.rowSpan;
<HTMLTableCellElement>.rowSpan = <fuzzint>;
<new DOMString> = <HTMLTableCellElement>.headers;
<HTMLTableCellElement>.headers = "<headers_value>";
<new long> = <HTMLTableCellElement>.cellIndex;
<new DOMString> = <HTMLTableCellElement>.align;
<HTMLTableCellElement>.align = "<align_value>";
<new DOMString> = <HTMLTableCellElement>.axis;
<HTMLTableCellElement>.axis = "<axis_value>";
<new DOMString> = <HTMLTableCellElement>.height;
<HTMLTableCellElement>.height = "<height_value>";
<new DOMString> = <HTMLTableCellElement>.width;
<HTMLTableCellElement>.width = "<width_value>";
<new DOMString> = <HTMLTableCellElement>.ch;
<HTMLTableCellElement>.ch = <DOMString>;
<new DOMString> = <HTMLTableCellElement>.chOff;
<HTMLTableCellElement>.chOff = <DOMString>;
<new boolean> = <HTMLTableCellElement>.noWrap;
<HTMLTableCellElement>.noWrap = <boolean>;
<new DOMString> = <HTMLTableCellElement>.vAlign;
<HTMLTableCellElement>.vAlign = "<valign_value>";
<new DOMString> = <HTMLTableCellElement>.bgColor;
<HTMLTableCellElement>.bgColor = "<bgcolor_value>";
<new DOMString> = <HTMLTableCellElement>.abbr;
<HTMLTableCellElement>.abbr = "<abbr_value>";
<new DOMString> = <HTMLTableCellElement>.scope;
<HTMLTableCellElement>.scope = "<scope_value>";

#HTMLFontElement
!extends HTMLFontElement Element
<new Element> = <HTMLFontElement>;
<new DOMString> = <HTMLFontElement>.color;
<HTMLFontElement>.color = "<color_value>";
<new DOMString> = <HTMLFontElement>.face;
<HTMLFontElement>.face = "<face_value>";
<new DOMString> = <HTMLFontElement>.size;
<HTMLFontElement>.size = "<size_value>";

#HTMLOptionElement
!extends HTMLOptionElement Element
<new Element> = <HTMLOptionElement>;
<new boolean> = <HTMLOptionElement>.disabled;
<HTMLOptionElement>.disabled = <boolean>;
<new HTMLFormElement> = <HTMLOptionElement>.form;
<new DOMString> = <HTMLOptionElement>.label;
<HTMLOptionElement>.label = "<label_value>";
<new boolean> = <HTMLOptionElement>.defaultSelected;
<HTMLOptionElement>.defaultSelected = <boolean>;
<new boolean> = <HTMLOptionElement>.selected;
<HTMLOptionElement>.selected = <boolean>;
<new DOMString> = <HTMLOptionElement>.value;
<HTMLOptionElement>.value = "<value_value>";
<new DOMString> = <HTMLOptionElement>.text;
<HTMLOptionElement>.text = "<text_value>";
<new long> = <HTMLOptionElement>.index;

#HTMLMenuElement
!extends HTMLMenuElement Element
<new Element> = <HTMLMenuElement>;
<new DOMString> = <HTMLMenuElement>.type;
<HTMLMenuElement>.type = "<type_value>";
<new DOMString> = <HTMLMenuElement>.label;
<HTMLMenuElement>.label = "<label_value>";
<new boolean> = <HTMLMenuElement>.compact;
<HTMLMenuElement>.compact = <boolean>;

#HTMLShadowElement
!extends HTMLShadowElement Element
<new Element> = <HTMLShadowElement>;
<new NodeList> = <HTMLShadowElement>.getDistributedNodes();

#HTMLMeterElement
!extends HTMLMeterElement Element
<new Element> = <HTMLMeterElement>;
<new double> = <HTMLMeterElement>.value;
<HTMLMeterElement>.value = <double>;
<new double> = <HTMLMeterElement>.min;
<HTMLMeterElement>.min = <double>;
<new double> = <HTMLMeterElement>.max;
<HTMLMeterElement>.max = <double>;
<new double> = <HTMLMeterElement>.low;
<HTMLMeterElement>.low = <double>;
<new double> = <HTMLMeterElement>.high;
<HTMLMeterElement>.high = <double>;
<new double> = <HTMLMeterElement>.optimum;
<HTMLMeterElement>.optimum = <double>;
<new NodeList> = <HTMLMeterElement>.labels;

#HTMLEmbedElement
!extends HTMLEmbedElement Element
<new Element> = <HTMLEmbedElement>;
<new DOMString> = <HTMLEmbedElement>.src;
<HTMLEmbedElement>.src = "<src_value>";
<new DOMString> = <HTMLEmbedElement>.type;
<HTMLEmbedElement>.type = "<type_value>";
<new DOMString> = <HTMLEmbedElement>.width;
<HTMLEmbedElement>.width = "<width_value>";
<new DOMString> = <HTMLEmbedElement>.height;
<HTMLEmbedElement>.height = "<height_value>";
<new Document> = <HTMLEmbedElement>.getSVGDocument();
<new DOMString> = <HTMLEmbedElement>.align;
<HTMLEmbedElement>.align = "<align_value>";
<new DOMString> = <HTMLEmbedElement>.name;
<HTMLEmbedElement>.name = "<name_value>";
<new Element> = <HTMLEmbedElement>[<DOMString>];
<HTMLEmbedElement>[<DOMString>] = <Element>;

#HTMLFormControlsCollection
!extends HTMLFormControlsCollection HTMLCollection
<new HTMLCollection> = <HTMLFormControlsCollection>;
<new Element> = <HTMLFormControlsCollection id=1>[<int min=0 max=100>%<HTMLFormControlsCollection id=1>.length];

#HTMLTitleElement
!extends HTMLTitleElement Element
<new Element> = <HTMLTitleElement>;
<new DOMString> = <HTMLTitleElement>.text;
<HTMLTitleElement>.text = "<text_value>";

#HTMLInputElement
!extends HTMLInputElement Element
<new Element> = <HTMLInputElement>;
<new DOMString> = <HTMLInputElement>.accept;
<HTMLInputElement>.accept = "<accept_value>";
<new DOMString> = <HTMLInputElement>.alt;
<HTMLInputElement>.alt = "<alt_value>";
<new DOMString> = <HTMLInputElement>.autocomplete;
<HTMLInputElement>.autocomplete = "<autocomplete_value>";
<new boolean> = <HTMLInputElement>.autofocus;
<HTMLInputElement>.autofocus = <boolean>;
<new boolean> = <HTMLInputElement>.defaultChecked;
<HTMLInputElement>.defaultChecked = <boolean>;
<new boolean> = <HTMLInputElement>.checked;
<HTMLInputElement>.checked = <boolean>;
<new DOMString> = <HTMLInputElement>.dirName;
<HTMLInputElement>.dirName = "<dirname_value>";
<new boolean> = <HTMLInputElement>.disabled;
<HTMLInputElement>.disabled = <boolean>;
<new HTMLFormElement> = <HTMLInputElement>.form;
<new FileList> = <HTMLInputElement>.files;
<HTMLInputElement>.files = <FileList>;
<new DOMString> = <HTMLInputElement>.formAction;
<HTMLInputElement>.formAction = "<formaction_value>";
<new DOMString> = <HTMLInputElement>.formEnctype;
<HTMLInputElement>.formEnctype = "<formenctype_value>";
<new DOMString> = <HTMLInputElement>.formMethod;
<HTMLInputElement>.formMethod = "<formmethod_value>";
<new boolean> = <HTMLInputElement>.formNoValidate;
<HTMLInputElement>.formNoValidate = <boolean>;
<new DOMString> = <HTMLInputElement>.formTarget;
<HTMLInputElement>.formTarget = "<formtarget_value>";
<new long> = <HTMLInputElement>.height;
<HTMLInputElement>.height = <fuzzint>;
<new boolean> = <HTMLInputElement>.indeterminate;
<HTMLInputElement>.indeterminate = <boolean>;
<new DOMString> = <HTMLInputElement>.inputMode;
<HTMLInputElement>.inputMode = "<inputmode_value>";
<new Element> = <HTMLInputElement>.list;
<new DOMString> = <HTMLInputElement>.max;
<HTMLInputElement>.max = "<max_value>";
<new long> = <HTMLInputElement>.maxLength;
<HTMLInputElement>.maxLength = <fuzzint>;
<new DOMString> = <HTMLInputElement>.min;
<HTMLInputElement>.min = "<min_value>";
<new long> = <HTMLInputElement>.minLength;
<HTMLInputElement>.minLength = <fuzzint>;
<new boolean> = <HTMLInputElement>.multiple;
<HTMLInputElement>.multiple = <boolean>;
<new DOMString> = <HTMLInputElement>.name;
<HTMLInputElement>.name = "<name_value>";
<new DOMString> = <HTMLInputElement>.pattern;
<HTMLInputElement>.pattern = "<pattern_value>";
<new DOMString> = <HTMLInputElement>.placeholder;
<HTMLInputElement>.placeholder = "<placeholder_value>";
<new boolean> = <HTMLInputElement>.readOnly;
<HTMLInputElement>.readOnly = <boolean>;
<new boolean> = <HTMLInputElement>.required;
<HTMLInputElement>.required = <boolean>;
<new long> = <HTMLInputElement>.size;
<HTMLInputElement>.size = <fuzzint>;
<new DOMString> = <HTMLInputElement>.src;
<HTMLInputElement>.src = "<src_value>";
<new DOMString> = <HTMLInputElement>.step;
<HTMLInputElement>.step = "<step_value>";
<new DOMString> = <HTMLInputElement>.type;
<HTMLInputElement>.type = "<type_value>";
<new DOMString> = <HTMLInputElement>.defaultValue;
<HTMLInputElement>.defaultValue = <DOMString>;
<new DOMString> = <HTMLInputElement>.value;
<HTMLInputElement>.value = "<value_value>";
<new Date> = <HTMLInputElement>.valueAsDate;
<HTMLInputElement>.valueAsDate = <Date>;
<new double> = <HTMLInputElement>.valueAsNumber;
<HTMLInputElement>.valueAsNumber = <double>;
<new long> = <HTMLInputElement>.width;
<HTMLInputElement>.width = <fuzzint>;
<HTMLInputElement>.stepUp();
<HTMLInputElement>.stepUp(<fuzzint>);
<HTMLInputElement>.stepDown();
<HTMLInputElement>.stepDown(<fuzzint>);
<new boolean> = <HTMLInputElement>.willValidate;
<new ValidityState> = <HTMLInputElement>.validity;
<new DOMString> = <HTMLInputElement>.validationMessage;
<new boolean> = <HTMLInputElement>.checkValidity();
<new boolean> = <HTMLInputElement>.reportValidity();
<HTMLInputElement>.setCustomValidity(<DOMString>);
<new NodeList> = <HTMLInputElement>.labels;
<HTMLInputElement>.select();
<new long> = <HTMLInputElement>.selectionStart;
<HTMLInputElement>.selectionStart = <fuzzint>;
<new long> = <HTMLInputElement>.selectionEnd;
<HTMLInputElement>.selectionEnd = <fuzzint>;
<new DOMString> = <HTMLInputElement>.selectionDirection;
<HTMLInputElement>.selectionDirection = <DOMString>;
<HTMLInputElement>.setRangeText(<DOMString>);
<HTMLInputElement>.setRangeText(<DOMString>,<fuzzint>,<fuzzint>);
<HTMLInputElement>.setRangeText(<DOMString>,<fuzzint>,<fuzzint>,<SelectionMode>);
<HTMLInputElement>.setSelectionRange();
<HTMLInputElement>.setSelectionRange(<fuzzint>);
<HTMLInputElement>.setSelectionRange(<fuzzint>,<fuzzint>);
<HTMLInputElement>.setSelectionRange(<fuzzint>,<fuzzint>,<DOMString>);
<new DOMString> = <HTMLInputElement>.align;
<HTMLInputElement>.align = "<align_value>";
<new DOMString> = <HTMLInputElement>.useMap;
<HTMLInputElement>.useMap = "<usemap_value>";
<new DOMString> = <HTMLInputElement>.autocapitalize;
<HTMLInputElement>.autocapitalize = <DOMString>;
<new boolean> = <HTMLInputElement>.capture;
<HTMLInputElement>.capture = <boolean>;
<new boolean> = <HTMLInputElement>.webkitdirectory;
<HTMLInputElement>.webkitdirectory = <boolean>;
<new boolean> = <HTMLInputElement>.incremental;
<HTMLInputElement>.incremental = <boolean>;

#HTMLMenuItemElement
!extends HTMLMenuItemElement Element
<new Element> = <HTMLMenuItemElement>;
<new DOMString> = <HTMLMenuItemElement>.type;
<HTMLMenuItemElement>.type = "<type_value>";
<new DOMString> = <HTMLMenuItemElement>.label;
<HTMLMenuItemElement>.label = "<label_value>";
<new DOMString> = <HTMLMenuItemElement>.icon;
<HTMLMenuItemElement>.icon = "<icon_value>";
<new boolean> = <HTMLMenuItemElement>.disabled;
<HTMLMenuItemElement>.disabled = <boolean>;
<new boolean> = <HTMLMenuItemElement>.checked;
<HTMLMenuItemElement>.checked = <boolean>;
<new DOMString> = <HTMLMenuItemElement>.radiogroup;
<HTMLMenuItemElement>.radiogroup = "<radiogroup_value>";
<new boolean> = <HTMLMenuItemElement>.default;
<HTMLMenuItemElement>.default = <boolean>;

#HTMLCollection
<new long> = <HTMLCollection>.length;
<new Element> = <HTMLCollection id=1>.item(<int min=0 max=100>%<HTMLCollection id=1>.length);

#HTMLDataElement
!extends HTMLDataElement Element
<new Element> = <HTMLDataElement>;
<new DOMString> = <HTMLDataElement>.value;
<HTMLDataElement>.value = "<value_value>";

#HTMLTimeElement
!extends HTMLTimeElement Element
<new Element> = <HTMLTimeElement>;
<new DOMString> = <HTMLTimeElement>.dateTime;
<HTMLTimeElement>.dateTime = "<datetime_value>";

#HTMLMarqueeElement
!extends HTMLMarqueeElement Element
<new Element> = <HTMLMarqueeElement>;
<new DOMString> = <HTMLMarqueeElement>.behavior;
<HTMLMarqueeElement>.behavior = "<behavior_value>";
<new DOMString> = <HTMLMarqueeElement>.bgColor;
<HTMLMarqueeElement>.bgColor = "<bgcolor_value>";
<new DOMString> = <HTMLMarqueeElement>.direction;
<HTMLMarqueeElement>.direction = "<direction_value>";
<new DOMString> = <HTMLMarqueeElement>.height;
<HTMLMarqueeElement>.height = "<height_value>";
<new long> = <HTMLMarqueeElement>.hspace;
<HTMLMarqueeElement>.hspace = <fuzzint>;
<new long> = <HTMLMarqueeElement>.loop;
<HTMLMarqueeElement>.loop = <fuzzint>;
<new long> = <HTMLMarqueeElement>.scrollAmount;
<HTMLMarqueeElement>.scrollAmount = <fuzzint>;
<new long> = <HTMLMarqueeElement>.scrollDelay;
<HTMLMarqueeElement>.scrollDelay = <fuzzint>;
<new boolean> = <HTMLMarqueeElement>.trueSpeed;
<HTMLMarqueeElement>.trueSpeed = <boolean>;
<new long> = <HTMLMarqueeElement>.vspace;
<HTMLMarqueeElement>.vspace = <fuzzint>;
<new DOMString> = <HTMLMarqueeElement>.width;
<HTMLMarqueeElement>.width = "<width_value>";
<HTMLMarqueeElement>.start();
<HTMLMarqueeElement>.stop();
<HTMLMarqueeElement>.createdCallback();
<HTMLMarqueeElement>.attachedCallback();
<HTMLMarqueeElement>.detachedCallback();
<HTMLMarqueeElement>.attributeChangedCallback(<DOMString>,<DOMString>,<DOMString>);

#HTMLHtmlElement
!extends HTMLHtmlElement Element
<new Element> = <HTMLHtmlElement>;
<new DOMString> = <HTMLHtmlElement>.version;
<HTMLHtmlElement>.version = "<version_value>";

#HTMLTemplateElement
!extends HTMLTemplateElement Element
<new Element> = <HTMLTemplateElement>;
<new DocumentFragment> = <HTMLTemplateElement>.content;

#HTMLLIElement
!extends HTMLLIElement Element
<new Element> = <HTMLLIElement>;
<new long> = <HTMLLIElement>.value;
<HTMLLIElement>.value = <fuzzint>;
<new DOMString> = <HTMLLIElement>.type;
<HTMLLIElement>.type = "<type_value>";

#HTMLImageElement
!extends HTMLImageElement Element
<new Element> = <HTMLImageElement>;
<new DOMString> = <HTMLImageElement>.alt;
<HTMLImageElement>.alt = "<alt_value>";
<new DOMString> = <HTMLImageElement>.src;
<HTMLImageElement>.src = "<imgsrc>";
<new DOMString> = <HTMLImageElement>.srcset;
<HTMLImageElement>.srcset = "<srcset_value>";
<new DOMString> = <HTMLImageElement>.sizes;
<HTMLImageElement>.sizes = "<sizes_value>";
<new DOMString> = <HTMLImageElement>.crossOrigin;
<HTMLImageElement>.crossOrigin = "<crossorigin_value>";
<new DOMString> = <HTMLImageElement>.useMap;
<HTMLImageElement>.useMap = "<usemap_value>";
<new boolean> = <HTMLImageElement>.isMap;
<HTMLImageElement>.isMap = <boolean>;
<new long> = <HTMLImageElement>.width;
<HTMLImageElement>.width = <fuzzint>;
<new long> = <HTMLImageElement>.height;
<HTMLImageElement>.height = <fuzzint>;
<new long> = <HTMLImageElement>.naturalWidth;
<new long> = <HTMLImageElement>.naturalHeight;
<new boolean> = <HTMLImageElement>.complete;
<new DOMString> = <HTMLImageElement>.currentSrc;
<new DOMString> = <HTMLImageElement>.referrerPolicy;
<HTMLImageElement>.referrerPolicy = "<referrerpolicy_value>";
<new DOMString> = <HTMLImageElement>.name;
<HTMLImageElement>.name = "<name_value>";
<new DOMString> = <HTMLImageElement>.lowsrc;
<HTMLImageElement>.lowsrc = "<lowsrc_value>";
<new DOMString> = <HTMLImageElement>.align;
<HTMLImageElement>.align = "<align_value>";
<new long> = <HTMLImageElement>.hspace;
<HTMLImageElement>.hspace = <fuzzint>;
<new long> = <HTMLImageElement>.vspace;
<HTMLImageElement>.vspace = <fuzzint>;
<new DOMString> = <HTMLImageElement>.longDesc;
<HTMLImageElement>.longDesc = "<longdesc_value>";
<new DOMString> = <HTMLImageElement>.border;
<HTMLImageElement>.border = "<border_value>";
<new long> = <HTMLImageElement>.x;
<new long> = <HTMLImageElement>.y;

#HTMLOptGroupElement
!extends HTMLOptGroupElement Element
<new Element> = <HTMLOptGroupElement>;
<new boolean> = <HTMLOptGroupElement>.disabled;
<HTMLOptGroupElement>.disabled = <boolean>;
<new DOMString> = <HTMLOptGroupElement>.label;
<HTMLOptGroupElement>.label = "<label_value>";

#HTMLContentElement
!extends HTMLContentElement Element
<new Element> = <HTMLContentElement>;
<new DOMString> = <HTMLContentElement>.select;
<HTMLContentElement>.select = "<select_value>";
<new NodeList> = <HTMLContentElement>.getDistributedNodes();

#VideoTrackList
!extends VideoTrackList EventTarget
<new EventTarget> = <VideoTrackList>;
<new long> = <VideoTrackList>.length;
<new VideoTrack> = <VideoTrackList id=1>[<int min=0 max=100>%<VideoTrackList id=1>.length];
<new long> = <VideoTrackList>.selectedIndex;
<new EventHandler> = <VideoTrackList>.onchange;
<VideoTrackList>.onchange = <EventHandler>;
<new EventHandler> = <VideoTrackList>.onaddtrack;
<VideoTrackList>.onaddtrack = <EventHandler>;
<new EventHandler> = <VideoTrackList>.onremovetrack;
<VideoTrackList>.onremovetrack = <EventHandler>;

#TextTrack
!extends TextTrack EventTarget
<new EventTarget> = <TextTrack>;
<new TextTrackKind> = <TextTrack>.kind;
<new DOMString> = <TextTrack>.label;
<new DOMString> = <TextTrack>.language;
<new DOMString> = <TextTrack>.id;
<new TextTrackMode> = <TextTrack>.mode;
<TextTrack>.mode = <TextTrackMode>;
<new TextTrackCueList> = <TextTrack>.cues;
<new TextTrackCueList> = <TextTrack>.activeCues;
<TextTrack>.addCue(<TextTrackCue>);
<TextTrack>.removeCue(<TextTrackCue>);
<new EventHandler> = <TextTrack>.oncuechange;
<TextTrack>.oncuechange = <EventHandler>;
<new VTTRegionList> = <TextTrack>.regions;
<TextTrack>.addRegion(<VTTRegion>);
<TextTrack>.removeRegion(<VTTRegion>);

#TextTrackCueList
<new long> = <TextTrackCueList>.length;
<new TextTrackCue> = <TextTrackCueList id=1>[<int min=0 max=100>%<TextTrackCueList id=1>.length];

#TextTrackList
!extends TextTrackList EventTarget
<new EventTarget> = <TextTrackList>;
<new long> = <TextTrackList>.length;
<new TextTrack> = <TextTrackList id=1>[<int min=0 max=100>%<TextTrackList id=1>.length];
<new EventHandler> = <TextTrackList>.onchange;
<TextTrackList>.onchange = <EventHandler>;
<new EventHandler> = <TextTrackList>.onaddtrack;
<TextTrackList>.onaddtrack = <EventHandler>;
<new EventHandler> = <TextTrackList>.onremovetrack;
<TextTrackList>.onremovetrack = <EventHandler>;

#TextTrackCue
!extends TextTrackCue EventTarget
<new EventTarget> = <TextTrackCue>;
<new TextTrack> = <TextTrackCue>.track;
<new DOMString> = <TextTrackCue>.id;
<TextTrackCue>.id = <DOMString>;
<new double> = <TextTrackCue>.startTime;
<TextTrackCue>.startTime = <double>;
<new double> = <TextTrackCue>.endTime;
<TextTrackCue>.endTime = <double>;
<new boolean> = <TextTrackCue>.pauseOnExit;
<TextTrackCue>.pauseOnExit = <boolean>;
<new EventHandler> = <TextTrackCue>.onenter;
<TextTrackCue>.onenter = <EventHandler>;
<new EventHandler> = <TextTrackCue>.onexit;
<TextTrackCue>.onexit = <EventHandler>;

#AudioTrack
<new DOMString> = <AudioTrack>.id;
<new DOMString> = <AudioTrack>.kind;
<new DOMString> = <AudioTrack>.label;
<new DOMString> = <AudioTrack>.language;
<new boolean> = <AudioTrack>.enabled;
<AudioTrack>.enabled = <boolean>;

#AudioTrackList
!extends AudioTrackList EventTarget
<new EventTarget> = <AudioTrackList>;
<new long> = <AudioTrackList>.length;
<new AudioTrack> = <AudioTrackList id=1>[<int min=0 max=100>%<AudioTrackList id=1>.length];
<new EventHandler> = <AudioTrackList>.onchange;
<AudioTrackList>.onchange = <EventHandler>;
<new EventHandler> = <AudioTrackList>.onaddtrack;
<AudioTrackList>.onaddtrack = <EventHandler>;
<new EventHandler> = <AudioTrackList>.onremovetrack;
<AudioTrackList>.onremovetrack = <EventHandler>;

#TrackEvent
!extends TrackEvent Event
<new Event> = <TrackEvent>;
<new VideoTrack> = <TrackEvent>.track;
<new AudioTrack> = <TrackEvent>.track;
<new TextTrack> = <TrackEvent>.track;

#VideoTrack
<new DOMString> = <VideoTrack>.id;
<new DOMString> = <VideoTrack>.kind;
<new DOMString> = <VideoTrack>.label;
<new DOMString> = <VideoTrack>.language;
<new boolean> = <VideoTrack>.selected;
<VideoTrack>.selected = <boolean>;

#VTTCue
!extends VTTCue TextTrackCue
<new TextTrackCue> = <VTTCue>;
<new DOMString> = <VTTCue>.regionId;
<VTTCue>.regionId = <DOMString>;
<new DirectionSetting> = <VTTCue>.vertical;
<VTTCue>.vertical = <DirectionSetting>;
<new boolean> = <VTTCue>.snapToLines;
<VTTCue>.snapToLines = <boolean>;
<new double> = <VTTCue>.line;
<VTTCue>.line = <double>;
<new AutoKeyword> = <VTTCue>.line;
<VTTCue>.line = <AutoKeyword>;
<new double> = <VTTCue>.position;
<VTTCue>.position = <double>;
<new AutoKeyword> = <VTTCue>.position;
<VTTCue>.position = <AutoKeyword>;
<new double> = <VTTCue>.size;
<VTTCue>.size = <double>;
<new AlignSetting> = <VTTCue>.align;
<VTTCue>.align = <AlignSetting>;
<new DOMString> = <VTTCue>.text;
<VTTCue>.text = <DOMString>;
<new DocumentFragment> = <VTTCue>.getCueAsHTML();

#VTTRegionList
<new long> = <VTTRegionList>.length;
<new VTTRegion> = <VTTRegionList id=1>.item(<int min=0 max=100>%<VTTRegionList id=1>.length);

#VTTRegion
<new double> = <VTTRegion>.width;
<VTTRegion>.width = <double>;
<new long> = <VTTRegion>.height;
<VTTRegion>.height = <fuzzint>;
<new double> = <VTTRegion>.regionAnchorX;
<VTTRegion>.regionAnchorX = <double>;
<new double> = <VTTRegion>.regionAnchorY;
<VTTRegion>.regionAnchorY = <double>;
<new double> = <VTTRegion>.viewportAnchorX;
<VTTRegion>.viewportAnchorX = <double>;
<new double> = <VTTRegion>.viewportAnchorY;
<VTTRegion>.viewportAnchorY = <double>;
<new DOMString> = <VTTRegion>.scroll;
<VTTRegion>.scroll = <DOMString>;
<new TextTrack> = <VTTRegion>.track;
<new DOMString> = <VTTRegion>.id;
<VTTRegion>.id = <DOMString>;

#DataTransfer
<new DOMString> = <DataTransfer>.dropEffect;
<DataTransfer>.dropEffect = <DOMString>;
<new DOMString> = <DataTransfer>.effectAllowed;
<DataTransfer>.effectAllowed = <DOMString>;
<new DataTransferItemList> = <DataTransfer>.items;
<DataTransfer>.setDragImage(<Element>,<fuzzint>,<fuzzint>);
<new DOMString> = <DataTransfer>.types;
<new DOMString> = <DataTransfer>.getData(<DOMString>);
<DataTransfer>.setData(<DOMString>,<DOMString>);
<DataTransfer>.clearData();
<DataTransfer>.clearData(<DOMString>);
<new FileList> = <DataTransfer>.files;

#DataTransferItemList
<new long> = <DataTransferItemList>.length;
<new DataTransferItem> = <DataTransferItemList id=1>[<int min=0 max=100>%<DataTransferItemList id=1>.length];
<new DataTransferItem> = <DataTransferItemList>.add(<DOMString>,<DOMString>);
<new DataTransferItem> = <DataTransferItemList>.add(<File>);
<DataTransferItemList id=1>.remove(<int min=0 max=100>%<DataTransferItemList id=1>.length);
<DataTransferItemList>.clear();

#DataTransferItem
<new DOMString> = <DataTransferItem>.kind;
<new DOMString> = <DataTransferItem>.type;
<DataTransferItem>.getAsString(<StringCallback>);
<new Blob> = <DataTransferItem>.getAsFile();

#ResourceProgressEvent
!extends ResourceProgressEvent ProgressEvent
<new ProgressEvent> = <ResourceProgressEvent>;
<new DOMString> = <ResourceProgressEvent>.url;

#TextEvent
!extends TextEvent UIEvent
<new UIEvent> = <TextEvent>;
<new DOMString> = <TextEvent>.data;
<TextEvent>.initTextEvent();
<TextEvent>.initTextEvent(<DOMString>);
<TextEvent>.initTextEvent(<DOMString>,<boolean>);
<TextEvent>.initTextEvent(<DOMString>,<boolean>,<boolean>);
<TextEvent>.initTextEvent(<DOMString>,<boolean>,<boolean>,<Window>);
<TextEvent>.initTextEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>);

#ClipboardEvent
!extends ClipboardEvent Event
<new Event> = <ClipboardEvent>;
<new DataTransfer> = <ClipboardEvent>.clipboardData;

#ProgressEvent
!extends ProgressEvent Event
<new Event> = <ProgressEvent>;
<new boolean> = <ProgressEvent>.lengthComputable;
<new long> = <ProgressEvent>.loaded;
<new long> = <ProgressEvent>.total;

#WheelEvent
!extends WheelEvent MouseEvent
<new MouseEvent> = <WheelEvent>;
<new double> = <WheelEvent>.deltaX;
<new double> = <WheelEvent>.deltaY;
<new double> = <WheelEvent>.deltaZ;
<new long> = <WheelEvent>.deltaMode;
<new long> = <WheelEvent>.wheelDeltaX;
<new long> = <WheelEvent>.wheelDeltaY;
<new long> = <WheelEvent>.wheelDelta;

#HashChangeEvent
!extends HashChangeEvent Event
<new Event> = <HashChangeEvent>;
<new DOMString> = <HashChangeEvent>.oldURL;
<new DOMString> = <HashChangeEvent>.newURL;

#MouseEvent
!extends MouseEvent UIEvent
<new UIEvent> = <MouseEvent>;
<new long> = <MouseEvent>.screenX;
<new long> = <MouseEvent>.screenY;
<new long> = <MouseEvent>.clientX;
<new long> = <MouseEvent>.clientY;
<new boolean> = <MouseEvent>.ctrlKey;
<new boolean> = <MouseEvent>.shiftKey;
<new boolean> = <MouseEvent>.altKey;
<new boolean> = <MouseEvent>.metaKey;
<new short> = <MouseEvent>.button;
<new short> = <MouseEvent>.buttons;
<new EventTarget> = <MouseEvent>.relatedTarget;
<new boolean> = <MouseEvent>.getModifierState(<DOMString>);
<MouseEvent>.initMouseEvent();
<MouseEvent>.initMouseEvent(<DOMString>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<boolean>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<boolean>,<boolean>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<boolean>,<boolean>,<boolean>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<boolean>,<boolean>,<boolean>,<boolean>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<boolean>,<boolean>,<boolean>,<boolean>,<fuzzint>);
<MouseEvent>.initMouseEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<fuzzint>,<boolean>,<boolean>,<boolean>,<boolean>,<fuzzint>,<EventTarget>);
<new long> = <MouseEvent>.pageX;
<new long> = <MouseEvent>.pageY;
<new long> = <MouseEvent>.x;
<new long> = <MouseEvent>.y;
<new long> = <MouseEvent>.offsetX;
<new long> = <MouseEvent>.offsetY;
<new long> = <MouseEvent>.movementX;
<new long> = <MouseEvent>.movementY;
<new DOMString> = <MouseEvent>.region;
<new Element> = <MouseEvent>.fromElement;
<new Element> = <MouseEvent>.toElement;
<new long> = <MouseEvent>.which;
<new long> = <MouseEvent>.layerX;
<new long> = <MouseEvent>.layerY;

#TransitionEvent
!extends TransitionEvent Event
<new Event> = <TransitionEvent>;
<new DOMString> = <TransitionEvent>.propertyName;
<new double> = <TransitionEvent>.elapsedTime;
<new DOMString> = <TransitionEvent>.pseudoElement;

#AnimationPlaybackEvent
!extends AnimationPlaybackEvent Event
<new Event> = <AnimationPlaybackEvent>;
<new double> = <AnimationPlaybackEvent>.currentTime;
<new double> = <AnimationPlaybackEvent>.timelineTime;

#PopStateEvent
!extends PopStateEvent Event
<new Event> = <PopStateEvent>;
<new any> = <PopStateEvent>.state;

#DragEvent
!extends DragEvent MouseEvent
<new MouseEvent> = <DragEvent>;
<new DataTransfer> = <DragEvent>.dataTransfer;

#Event
<new DOMString> = <Event>.type;
<new EventTarget> = <Event>.target;
<new EventTarget> = <Event>.currentTarget;
<new sequence_EventTarget_> = <Event>.composedPath();
<new short> = <Event>.eventPhase;
<Event>.stopPropagation();
<Event>.stopImmediatePropagation();
<new boolean> = <Event>.bubbles;
<new boolean> = <Event>.cancelable;
<Event>.preventDefault();
<new boolean> = <Event>.defaultPrevented;
<new boolean> = <Event>.composed;
<new boolean> = <Event>.isTrusted;
<new DOMHighResTimeStamp> = <Event>.timeStamp;
<Event>.initEvent();
<Event>.initEvent(<DOMString>);
<Event>.initEvent(<DOMString>,<boolean>);
<Event>.initEvent(<DOMString>,<boolean>,<boolean>);
<new EventTarget> = <Event>.srcElement;
<new boolean> = <Event>.returnValue;
<Event>.returnValue = <boolean>;
<new boolean> = <Event>.cancelBubble;
<Event>.cancelBubble = <boolean>;
<new EventTarget> = <Event>.path;

#UIEvent
!extends UIEvent Event
<new Event> = <UIEvent>;
<new Window> = <UIEvent>.view;
<new long> = <UIEvent>.detail;
<new InputDeviceCapabilities> = <UIEvent>.sourceCapabilities;
<UIEvent>.initUIEvent();
<UIEvent>.initUIEvent(<DOMString>);
<UIEvent>.initUIEvent(<DOMString>,<boolean>);
<UIEvent>.initUIEvent(<DOMString>,<boolean>,<boolean>);
<UIEvent>.initUIEvent(<DOMString>,<boolean>,<boolean>,<Window>);
<UIEvent>.initUIEvent(<DOMString>,<boolean>,<boolean>,<Window>,<fuzzint>);
<new long> = <UIEvent>.which;

#PointerEvent
!extends PointerEvent MouseEvent
<new MouseEvent> = <PointerEvent>;
<new long> = <PointerEvent>.pointerId;
<new double> = <PointerEvent>.width;
<new double> = <PointerEvent>.height;
<new float> = <PointerEvent>.pressure;
<new long> = <PointerEvent>.tiltX;
<new long> = <PointerEvent>.tiltY;
<new DOMString> = <PointerEvent>.pointerType;
<new boolean> = <PointerEvent>.isPrimary;

#PromiseRejectionEvent
!extends PromiseRejectionEvent Event
<new Event> = <PromiseRejectionEvent>;
<new Promise_any_> = <PromiseRejectionEvent>.promise;
<new any> = <PromiseRejectionEvent>.reason;

#FocusEvent
!extends FocusEvent UIEvent
<new UIEvent> = <FocusEvent>;
<new EventTarget> = <FocusEvent>.relatedTarget;

#CompositionEvent
!extends CompositionEvent UIEvent
<new UIEvent> = <CompositionEvent>;
<new DOMString> = <CompositionEvent>.data;
<CompositionEvent>.initCompositionEvent();
<CompositionEvent>.initCompositionEvent(<DOMString>);
<CompositionEvent>.initCompositionEvent(<DOMString>,<boolean>);
<CompositionEvent>.initCompositionEvent(<DOMString>,<boolean>,<boolean>);
<CompositionEvent>.initCompositionEvent(<DOMString>,<boolean>,<boolean>,<Window>);
<CompositionEvent>.initCompositionEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>);

#InputEvent
!extends InputEvent UIEvent
<new UIEvent> = <InputEvent>;
<new DOMString> = <InputEvent>.inputType;
<new DOMString> = <InputEvent>.data;
<new DataTransfer> = <InputEvent>.dataTransfer;
<new boolean> = <InputEvent>.isComposing;
<new sequence_StaticRange_> = <InputEvent>.getTargetRanges();

#PageTransitionEvent
!extends PageTransitionEvent Event
<new Event> = <PageTransitionEvent>;
<new boolean> = <PageTransitionEvent>.persisted;

#SecurityPolicyViolationEvent
!extends SecurityPolicyViolationEvent Event
<new Event> = <SecurityPolicyViolationEvent>;
<new DOMString> = <SecurityPolicyViolationEvent>.documentURI;
<new DOMString> = <SecurityPolicyViolationEvent>.referrer;
<new DOMString> = <SecurityPolicyViolationEvent>.blockedURI;
<new DOMString> = <SecurityPolicyViolationEvent>.violatedDirective;
<new DOMString> = <SecurityPolicyViolationEvent>.effectiveDirective;
<new DOMString> = <SecurityPolicyViolationEvent>.originalPolicy;
<new DOMString> = <SecurityPolicyViolationEvent>.sourceFile;
<new short> = <SecurityPolicyViolationEvent>.statusCode;
<new long> = <SecurityPolicyViolationEvent>.lineNumber;
<new long> = <SecurityPolicyViolationEvent>.columnNumber;

#TouchEvent
!extends TouchEvent UIEvent
<new UIEvent> = <TouchEvent>;
<new TouchList> = <TouchEvent>.touches;
<new TouchList> = <TouchEvent>.targetTouches;
<new TouchList> = <TouchEvent>.changedTouches;
<new boolean> = <TouchEvent>.altKey;
<new boolean> = <TouchEvent>.metaKey;
<new boolean> = <TouchEvent>.ctrlKey;
<new boolean> = <TouchEvent>.shiftKey;

#Navigator
<new long> = <Navigator>.maxTouchPoints;

#MessageEvent
!extends MessageEvent Event
<new Event> = <MessageEvent>;
<new any> = <MessageEvent>.data;
<new DOMString> = <MessageEvent>.origin;
<new DOMString> = <MessageEvent>.lastEventId;
<new EventTarget> = <MessageEvent>.source;
<new MessagePort> = <MessageEvent>.ports;
<new DOMString> = <MessageEvent>.suborigin;
<MessageEvent>.initMessageEvent();
<MessageEvent>.initMessageEvent(<DOMString>);
<MessageEvent>.initMessageEvent(<DOMString>,<boolean>);
<MessageEvent>.initMessageEvent(<DOMString>,<boolean>,<boolean>);
<MessageEvent>.initMessageEvent(<DOMString>,<boolean>,<boolean>,<any>);
<MessageEvent>.initMessageEvent(<DOMString>,<boolean>,<boolean>,<any>,<DOMString>);
<MessageEvent>.initMessageEvent(<DOMString>,<boolean>,<boolean>,<any>,<DOMString>,<DOMString>);
<MessageEvent>.initMessageEvent(<DOMString>,<boolean>,<boolean>,<any>,<DOMString>,<DOMString>,<Window>);
<MessageEvent>.initMessageEvent(<DOMString>,<boolean>,<boolean>,<any>,<DOMString>,<DOMString>,<Window>,<sequence_MessagePort_>);

#MutationEvent
!extends MutationEvent Event
<new Event> = <MutationEvent>;
<new Element> = <MutationEvent>.relatedNode;
<new DOMString> = <MutationEvent>.prevValue;
<new DOMString> = <MutationEvent>.newValue;
<new DOMString> = <MutationEvent>.attrName;
<new short> = <MutationEvent>.attrChange;
<MutationEvent>.initMutationEvent();
<MutationEvent>.initMutationEvent(<DOMString>);
<MutationEvent>.initMutationEvent(<DOMString>,<boolean>);
<MutationEvent>.initMutationEvent(<DOMString>,<boolean>,<boolean>);
<MutationEvent>.initMutationEvent(<DOMString>,<boolean>,<boolean>,<Element>);
<MutationEvent>.initMutationEvent(<DOMString>,<boolean>,<boolean>,<Element>,<DOMString>);
<MutationEvent>.initMutationEvent(<DOMString>,<boolean>,<boolean>,<Element>,<DOMString>,<DOMString>);
<MutationEvent>.initMutationEvent(<DOMString>,<boolean>,<boolean>,<Element>,<DOMString>,<DOMString>,<DOMString>);
<MutationEvent>.initMutationEvent(<DOMString>,<boolean>,<boolean>,<Element>,<DOMString>,<DOMString>,<DOMString>,<fuzzint>);

#AnimationEvent
!extends AnimationEvent Event
<new Event> = <AnimationEvent>;
<new DOMString> = <AnimationEvent>.animationName;
<new double> = <AnimationEvent>.elapsedTime;

#RelatedEvent
!extends RelatedEvent Event
<new Event> = <RelatedEvent>;
<new EventTarget> = <RelatedEvent>.relatedTarget;

#ErrorEvent
!extends ErrorEvent Event
<new Event> = <ErrorEvent>;
<new DOMString> = <ErrorEvent>.message;
<new DOMString> = <ErrorEvent>.filename;
<new long> = <ErrorEvent>.lineno;
<new long> = <ErrorEvent>.colno;
<new any> = <ErrorEvent>.error;

#EventTarget
<EventTarget>.addEventListener("DOMAttrModified", <EventListener>);
<EventTarget>.addEventListener("DOMAttributeNameChanged", <EventListener>);
<EventTarget>.addEventListener("DOMCharacterDataModified", <EventListener>);
<EventTarget>.addEventListener("DOMElementNameChanged", <EventListener>);
<EventTarget>.addEventListener("DOMNodeInserted", <EventListener>);
<EventTarget>.addEventListener("DOMNodeInsertedIntoDocument", <EventListener>);
<EventTarget>.addEventListener("DOMNodeRemoved", <EventListener>);
<EventTarget>.addEventListener("DOMNodeRemovedFromDocument", <EventListener>);
<EventTarget>.addEventListener("DOMSubtreeModified", <EventListener>);
<EventTarget>.addEventListener("DOMSubtreeModified", <EventListener>);
<EventTarget>.addEventListener("DOMSubtreeModified", <EventListener>);
<EventTarget>.addEventListener(<string_event>,<EventListener>);
<EventTarget>.addEventListener(<string_event>,<EventListener>,<AddEventListenerOptions>);
<EventTarget>.addEventListener(<string_event>,<EventListener>,<boolean>);
<EventTarget>.removeEventListener(<string_event>,<EventListener>);
<EventTarget>.removeEventListener(<string_event>,<EventListener>,<EventListenerOptions>);
<EventTarget>.removeEventListener(<string_event>,<EventListener>,<boolean>);
<new boolean> = <EventTarget>.dispatchEvent(<Event>);

#KeyboardEvent
!extends KeyboardEvent UIEvent
<new UIEvent> = <KeyboardEvent>;
<new DOMString> = <KeyboardEvent>.key;
<new DOMString> = <KeyboardEvent>.code;
<new long> = <KeyboardEvent>.location;
<new boolean> = <KeyboardEvent>.ctrlKey;
<new boolean> = <KeyboardEvent>.shiftKey;
<new boolean> = <KeyboardEvent>.altKey;
<new boolean> = <KeyboardEvent>.metaKey;
<new boolean> = <KeyboardEvent>.repeat;
<new boolean> = <KeyboardEvent>.getModifierState(<DOMString>);
<KeyboardEvent>.initKeyboardEvent();
<KeyboardEvent>.initKeyboardEvent(<DOMString>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>,<Window>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>,<fuzzint>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>,<fuzzint>,<boolean>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>,<fuzzint>,<boolean>,<boolean>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>,<fuzzint>,<boolean>,<boolean>,<boolean>);
<KeyboardEvent>.initKeyboardEvent(<DOMString>,<boolean>,<boolean>,<Window>,<DOMString>,<fuzzint>,<boolean>,<boolean>,<boolean>,<boolean>);
<new long> = <KeyboardEvent>.charCode;
<new long> = <KeyboardEvent>.keyCode;
<new long> = <KeyboardEvent>.which;

#CustomEvent
!extends CustomEvent Event
<new Event> = <CustomEvent>;
<new any> = <CustomEvent>.detail;
<CustomEvent>.initCustomEvent(<DOMString>,<boolean>,<boolean>,<any>);

#ApplicationCacheErrorEvent
!extends ApplicationCacheErrorEvent Event
<new Event> = <ApplicationCacheErrorEvent>;
<new DOMString> = <ApplicationCacheErrorEvent>.reason;
<new DOMString> = <ApplicationCacheErrorEvent>.url;
<new short> = <ApplicationCacheErrorEvent>.status;
<new DOMString> = <ApplicationCacheErrorEvent>.message;

#BeforeUnloadEvent
!extends BeforeUnloadEvent Event
<new Event> = <BeforeUnloadEvent>;
<new DOMString> = <BeforeUnloadEvent>.returnValue;
<BeforeUnloadEvent>.returnValue = <DOMString>;

#InputDeviceCapabilities
<new boolean> = <InputDeviceCapabilities>.firesTouchEvents;

#Selection
<new Element> = <Selection>.anchorNode;
<new long> = <Selection>.anchorOffset;
<new Element> = <Selection>.focusNode;
<new long> = <Selection>.focusOffset;
<new boolean> = <Selection>.isCollapsed;
<new long> = <Selection>.rangeCount;
<new DOMString> = <Selection>.type;
<new Range> = <Selection>.getRangeAt(<fuzzint>);
<Selection>.addRange(<Range>);
<Selection>.removeAllRanges();
<Selection>.empty();
<Selection>.collapse(<Element>);
<Selection>.collapse(<Element>,<fuzzint>);
<Selection>.setPosition(<Element>);
<Selection>.setPosition(<Element>,<fuzzint>);
<Selection>.collapseToStart();
<Selection>.collapseToEnd();
<Selection>.extend(<Element>);
<Selection>.extend(<Element>,<fuzzint>);
<Selection>.setBaseAndExtent(<Element>,<fuzzint>,<Element>,<fuzzint>);
<Selection>.selectAllChildren(<Element>);
<Selection>.deleteFromDocument();
<new boolean> = <Selection>.containsNode(<Element>);
<new boolean> = <Selection>.containsNode(<Element>,<boolean>);
<new Element> = <Selection>.baseNode;
<new long> = <Selection>.baseOffset;
<new Element> = <Selection>.extentNode;
<new long> = <Selection>.extentOffset;
<Selection>.modify();
<Selection>.modify("<selectionalter>");
<Selection>.modify("<selectionalter>","<selectiondirection>");
<Selection>.modify("<selectionalter>","<selectiondirection>","<selectiongranularity>");

#FontFaceSet
!extends FontFaceSet EventTarget
<new EventTarget> = <FontFaceSet>;
<new long> = <FontFaceSet>.size;
<new EventHandler> = <FontFaceSet>.onloading;
<FontFaceSet>.onloading = <EventHandler>;
<new EventHandler> = <FontFaceSet>.onloadingdone;
<FontFaceSet>.onloadingdone = <EventHandler>;
<new EventHandler> = <FontFaceSet>.onloadingerror;
<FontFaceSet>.onloadingerror = <EventHandler>;
<new Promise_FontFaceSet_> = <FontFaceSet>.ready;
<new FontFaceSetLoadStatus> = <FontFaceSet>.status;
<FontFaceSet>.add(<FontFace>);
#TODO: check
<new boolean> = <FontFaceSet>.check(<DOMString>); 
<new boolean> = <FontFaceSet>.check(<DOMString>,<DOMString>);
<FontFaceSet>.clear();
<FontFaceSet>.delete(<FontFace>);
#TODO: entries, forEach, has, keys, load, values
<new Promise_sequence_FontFace__> = <FontFaceSet>.load(<DOMString>);
<new Promise_sequence_FontFace__> = <FontFaceSet>.load(<DOMString>,<DOMString>);
<new FontFaceSet> = new FontFaceSet(<FontFace>);
<new FontFaceSet> = new FontFaceSet(<sequence_FontFace_>);
<new FontFaceSet> = new FontFaceSet([<FontFace>, <FontFace>, <FontFace>]);
<new FontFaceSet> = new FontFaceSet();

#CSS
<CSS>.registerProperty(<PropertyDescriptor>);
<CSS>.unregisterProperty(<DOMString>);

#CSSSupportsRule
!extends CSSSupportsRule CSSRule
<new CSSRule> = <CSSSupportsRule>;
<new DOMString> = <CSSSupportsRule>.conditionText;
<new CSSRuleList> = <CSSSupportsRule>.cssRules;
<new long> = <CSSSupportsRule>.insertRule(<DOMString>,<fuzzint>);
<CSSSupportsRule>.deleteRule(<fuzzint>);

#CSSKeyframesRule
!extends CSSKeyframesRule CSSRule
<new CSSRule> = <CSSKeyframesRule>;
<new DOMString> = <CSSKeyframesRule>.name;
<CSSKeyframesRule>.name = <DOMString>;
<new CSSRuleList> = <CSSKeyframesRule>.cssRules;
<CSSKeyframesRule>.appendRule(<DOMString>);
<CSSKeyframesRule>.deleteRule(<DOMString>);
<new CSSKeyframeRule> = <CSSKeyframesRule>.findRule(<DOMString>);
<new CSSKeyframeRule> = <CSSKeyframesRule>[0];

#FontFace
<new DOMString> = <FontFace>.family;
<FontFace>.family = "<cssproperty_font-family>";
<new DOMString> = <FontFace>.style;
<FontFace>.style = "<import from=cssgrammar symbol=declaration5>";
<FontFace>.style = <DOMString>;
<new DOMString> = <FontFace>.weight;
<FontFace>.weight = <DOMString>;
<new DOMString> = <FontFace>.stretch;
<FontFace>.stretch = <DOMString>;
<new DOMString> = <FontFace>.display;
<FontFace>.display = <DOMString>;
<new DOMString> = <FontFace>.unicodeRange;
<FontFace>.unicodeRange = <DOMString>;
<new DOMString> = <FontFace>.variant;
<FontFace>.variant = <DOMString>;
<new DOMString> = <FontFace>.featureSettings;
<FontFace>.featureSettings = <DOMString>;
<new FontFaceLoadStatus> = <FontFace>.status;
<new Promise_FontFace_> = <FontFace>.load();
<new Promise_FontFace_> = <FontFace>.loaded;
<new sequence_FontFace_> = new Array(<FontFace>);

<new DOMString> = <FontFace>.src;
<FontFace>.src = "<cssproperty_font-src>";
<new FontFace> = new FontFace("<cssproperty_font-family>", "<cssproperty_font-src>", {});
<new FontFace> = new FontFace("<cssproperty_font-family>", "<cssproperty_font-src>", {<fontfacedescriptor>});
<new FontFace> = new FontFace("<cssproperty_font-family>", "<cssproperty_font-src>", {<fontfacedescriptor>, <fontfacedescriptor>, <fontfacedescriptor>});

#CSSViewportRule
!extends CSSViewportRule CSSRule
<new CSSRule> = <CSSViewportRule>;
<new CSSStyleDeclaration> = <CSSViewportRule>.style;

#CSSImportRule
!extends CSSImportRule CSSRule
<new CSSRule> = <CSSImportRule>;
<new DOMString> = <CSSImportRule>.href;
<new MediaList> = <CSSImportRule>.media;
<new CSSStyleSheet> = <CSSImportRule>.styleSheet;

#CSSMediaRule
!extends CSSMediaRule CSSGroupingRule
<new CSSGroupingRule> = <CSSMediaRule>;
<new MediaList> = <CSSMediaRule>.media;

#Document
<new FontFaceSet> = <Document>.fonts;

#StyleMedia
<new DOMString> = <StyleMedia>.type;
<new boolean> = <StyleMedia>.matchMedium();
<new boolean> = <StyleMedia>.matchMedium(<DOMString>);

#CSSStyleRule
!extends CSSStyleRule CSSRule
<new CSSRule> = <CSSStyleRule>;
<new DOMString> = <CSSStyleRule>.selectorText;
<CSSStyleRule>.selectorText = <DOMString>;
<new CSSStyleDeclaration> = <CSSStyleRule>.style;

#CSS
<new boolean> = <CSS>.supports(<DOMString>,<DOMString>);
<new boolean> = <CSS>.supports(<DOMString>);
<new DOMString> = <CSS>.escape(<DOMString>);

#CSSFontFaceRule
!extends CSSFontFaceRule CSSRule
<new CSSRule> = <CSSFontFaceRule>;
<new CSSStyleDeclaration> = <CSSFontFaceRule>.style;

#CSSPageRule
!extends CSSPageRule CSSRule
<new CSSRule> = <CSSPageRule>;
<new DOMString> = <CSSPageRule>.selectorText;
<CSSPageRule>.selectorText = <DOMString>;
<new CSSStyleDeclaration> = <CSSPageRule>.style;

#CSSStyleDeclaration
<new DOMString> = <CSSStyleDeclaration>.cssText;
<CSSStyleDeclaration>.cssText = "<import from=cssgrammar symbol=declaration5>";
<new long> = <CSSStyleDeclaration>.length;
<new DOMString> = <CSSStyleDeclaration>.item(<int min=0 max=100>%<CSSStyleDeclaration id=1>.length);
<new DOMString> = <CSSStyleDeclaration>.getPropertyValue(<string_cssproperty>);
<new DOMString> = <CSSStyleDeclaration>.getPropertyPriority(<string_cssproperty>);
#<CSSStyleDeclaration>.setProperty(<DOMString>,<DOMString>);
#<CSSStyleDeclaration>.setProperty(<DOMString>,<DOMString>,<DOMString>);
<new DOMString> = <CSSStyleDeclaration id=1>.removeProperty(<CSSStyleDeclaration id=1>[<int min=0 max=100>%<CSSStyleDeclaration id=1>.length]);
<new CSSRule> = <CSSStyleDeclaration>.parentRule;
<new DOMString> = <CSSStyleDeclaration>.cssFloat;
<CSSStyleDeclaration>.cssFloat = "<cssproperty_float>";
<new DOMString> = <CSSStyleDeclaration id=1>[<int min=0 max=100>%<CSSStyleDeclaration id=1>.length];
<new DOMString> = <CSSStyleDeclaration>[<string_cssproperty>];
<CSSStyleDeclaration>[<string_cssproperty>] = <string_cssvalue>;

#CSSKeyframeRule
!extends CSSKeyframeRule CSSRule
<new CSSRule> = <CSSKeyframeRule>;
<new DOMString> = <CSSKeyframeRule>.keyText;
<CSSKeyframeRule>.keyText = <DOMString>;
<new CSSStyleDeclaration> = <CSSKeyframeRule>.style;

#StyleSheetList
<new StyleSheet> = <StyleSheetList id=1>.item(<int min=0 max=100>%<StyleSheetList id=1>.length);
<new long> = <StyleSheetList>.length;

#CSSRuleList
<new CSSRule> = <CSSRuleList id=1>.item(<int min=0 max=100>%<CSSRuleList id=1>.length);
<new long> = <CSSRuleList>.length;

#MediaQueryListEvent
!extends MediaQueryListEvent Event
<new Event> = <MediaQueryListEvent>;
<new DOMString> = <MediaQueryListEvent>.media;
<new boolean> = <MediaQueryListEvent>.matches;

#CSSNamespaceRule
!extends CSSNamespaceRule CSSRule
<new CSSRule> = <CSSNamespaceRule>;
<new DOMString> = <CSSNamespaceRule>.namespaceURI;
<new DOMString> = <CSSNamespaceRule>.prefix;

#StyleSheet
<new DOMString> = <StyleSheet>.type;
<new DOMString> = <StyleSheet>.href;
<new Element> = <StyleSheet>.ownerNode;
<new StyleSheet> = <StyleSheet>.parentStyleSheet;
<new DOMString> = <StyleSheet>.title;
<new MediaList> = <StyleSheet>.media;
<new boolean> = <StyleSheet>.disabled;
<StyleSheet>.disabled = <boolean>;

#MediaList
<new DOMString> = <MediaList>.mediaText;
<MediaList>.mediaText = <DOMString>;
<new long> = <MediaList>.length;
<new DOMString> = <MediaList id=1>.item(<int min=0 max=100>%<MediaList id=1>.length);
<MediaList>.appendMedium(<DOMString>);
<MediaList>.deleteMedium(<DOMString>);

#MediaQueryList
!extends MediaQueryList EventTarget
<new EventTarget> = <MediaQueryList>;
<new DOMString> = <MediaQueryList>.media;
<new boolean> = <MediaQueryList>.matches;
<MediaQueryList>.addListener(<EventListener>);
<MediaQueryList>.removeListener(<EventListener>);
<new EventHandler> = <MediaQueryList>.onchange;
<MediaQueryList>.onchange = <EventHandler>;

#CSSRule
<new short> = <CSSRule>.type;
<new DOMString> = <CSSRule>.cssText;
<CSSRule>.cssText = "<import from=cssgrammar symbol=declaration5>";
<new CSSRule> = <CSSRule>.parentRule;
<new CSSStyleSheet> = <CSSRule>.parentStyleSheet;

#CSSStyleSheet
!extends CSSStyleSheet StyleSheet
<new StyleSheet> = <CSSStyleSheet>;
<new CSSRule> = <CSSStyleSheet>.ownerRule;
<new CSSRuleList> = <CSSStyleSheet>.cssRules;
<new long> = <CSSStyleSheet>.insertRule(<DOMString>);
<new long> = <CSSStyleSheet>.insertRule(<DOMString>,<fuzzint>);
<CSSStyleSheet id=1>.deleteRule(<int min=0 max=100>%<CSSStyleSheet id=1>.rules.length);
<new CSSRuleList> = <CSSStyleSheet>.rules;
<new long> = <CSSStyleSheet>.addRule();
<new long> = <CSSStyleSheet>.addRule(<DOMString>);
<new long> = <CSSStyleSheet>.addRule(<DOMString>,<DOMString>);
<new long> = <CSSStyleSheet>.addRule(<DOMString>,<DOMString>,<fuzzint>);
<CSSStyleSheet>.removeRule();
<CSSStyleSheet id=1>.removeRule(<int min=0 max=100>%<CSSStyleSheet id=1>.rules.length);

#CSSGroupingRule
!extends CSSGroupingRule CSSRule
<new CSSRule> = <CSSGroupingRule>;
<new CSSRuleList> = <CSSGroupingRule>.cssRules;
<new long> = <CSSGroupingRule>.insertRule(<DOMString>,<fuzzint>);
<CSSGroupingRule>.deleteRule(<fuzzint>);

#FontFaceSetLoadEvent
!extends FontFaceSetLoadEvent Event
<new Event> = <FontFaceSetLoadEvent>;
<new sequence_FontFace_> = <FontFaceSetLoadEvent>.fontfaces;

#Attr
<new DOMString> = <Attr>.namespaceURI;
<new DOMString> = <Attr>.prefix;
<new DOMString> = <Attr>.localName;
<new DOMString> = <Attr>.name;
<new DOMString> = <Attr>.value;
<Attr>.value = <string_attrvalue>;
<new DOMString> = <Attr>.nodeValue;
<Attr>.nodeValue = <string_attrvalue>;
<new DOMString> = <Attr>.textContent;
<Attr>.textContent = <string_attrvalue>;
<new Element> = <Attr>.ownerElement;
<new boolean> = <Attr>.specified;

#ClientRectList
<new long> = <ClientRectList>.length;
<new ClientRect> = <ClientRectList id=1>[<ClientRectList id=1>.length];

#StaticRange
<new Element> = <StaticRange>.startContainer;
<StaticRange>.startContainer = <Element>;
<new long> = <StaticRange>.startOffset;
<StaticRange>.startOffset = <fuzzint>;
<new Element> = <StaticRange>.endContainer;
<StaticRange>.endContainer = <Element>;
<new long> = <StaticRange>.endOffset;
<StaticRange>.endOffset = <fuzzint>;
<new boolean> = <StaticRange>.collapsed;
<StaticRange>.setStart(<Element>,<fuzzint>);
<StaticRange>.setEnd(<Element>,<fuzzint>);
<new Range> = <StaticRange>.toRange();

#DOMImplementation
<new DocumentType> = <DOMImplementation>.createDocumentType(<DOMString>,<DOMString>,<DOMString>);
<new XMLDocument> = <DOMImplementation>.createDocument(<DOMString>,<DOMString>);
<new XMLDocument> = <DOMImplementation>.createDocument(<DOMString>,<DOMString>,<DocumentType>);
<new DocumentType> = <DOMImplementation>.createDocumentType(<DOMString>);
<new Document> = <DOMImplementation>.createHTMLDocument();
<new Document> = <DOMImplementation>.createHTMLDocument(<DOMString>);
<new boolean> = <DOMImplementation>.hasFeature();

#ClientRect
<new float> = <ClientRect>.top;
<new float> = <ClientRect>.right;
<new float> = <ClientRect>.bottom;
<new float> = <ClientRect>.left;
<new float> = <ClientRect>.width;
<new float> = <ClientRect>.height;

#Comment
!extends Comment CharacterData
<new CharacterData> = <Comment>;

#Node
!extends Element EventTarget
<new EventTarget> = <Element>;
<new short> = <Element>.nodeType;
<new DOMString> = <Element>.nodeName;
<new DOMString> = <Element>.baseURI;
<new boolean> = <Element>.isConnected;
<new Document> = <Element>.ownerDocument;
<new Element> = <Element>.parentNode;
<new Element> = <Element>.parentElement;
<new boolean> = <Element>.hasChildNodes();
<new NodeList> = <Element>.childNodes;
<new Element> = <Element>.firstChild;
<new Element> = <Element>.lastChild;
<new Element> = <Element>.previousSibling;
<new Element> = <Element>.nextSibling;
<new Element> = <Element>.getRootNode();
<new Element> = <Element>.getRootNode(<GetRootNodeOptions>);
<new DOMString> = <Element>.nodeValue;
<Element>.nodeValue = <DOMString>;
<new DOMString> = <Element>.textContent;
<Element>.textContent = <DOMString>;
<Element>.normalize();
<new Element> = <Element>.cloneNode();
<new Element> = <Element>.cloneNode(<boolean>);
<new boolean> = <Element>.isEqualNode(<Element>);
<new boolean> = <Element>.isSameNode(<Element>);
<new short> = <Element>.compareDocumentPosition(<Element>);
<new boolean> = <Element>.contains(<Element>);
<new DOMString> = <Element>.lookupPrefix(<DOMString>);
<new DOMString> = <Element>.lookupNamespaceURI(<DOMString>);
<new boolean> = <Element>.isDefaultNamespace(<DOMString>);
<new Element> = <Element id=1>.insertBefore(<Element>,<Element id=1>.childNodes[<int min=0 max=100>%<Element id=1>.childNodes.length]);
<new Element> = <Element>.appendChild(<Element>);
<new Element> = <Element id=1>.replaceChild(<Element>,<Element id=1>.childNodes[<int min=0 max=100>%<Element id=1>.childNodes.length]);
<new Element> = <Element id=1>.removeChild(<Element id=1>.childNodes[<int min=0 max=100>%<Element id=1>.childNodes.length]);

#XMLDocument
!extends XMLDocument Document
<new Document> = <XMLDocument>;

#DOMTokenList
<new long> = <DOMTokenList>.length;
<new DOMString> = <DOMTokenList id=1>.item(<int min=0 max=100>%<DOMTokenList id=1>.length);
<new boolean> = <DOMTokenList>.contains(<DOMString>);
<DOMTokenList>.add(<DOMString>);
<DOMTokenList id=1>.remove(<DOMTokenList id=1>.item(<int min=0 max=100>%<DOMTokenList id=1>.length));
<new boolean> = <DOMTokenList>.toggle(<DOMString>);
<new boolean> = <DOMTokenList>.toggle(<DOMString>,<boolean>);
<new boolean> = <DOMTokenList>.supports(<DOMString>);
<new DOMString> = <DOMTokenList>.value;
<DOMTokenList>.value = <DOMString>;

#URLSearchParams
<URLSearchParams>.append(<USVString>,<USVString>);
<URLSearchParams>.delete(<USVString>);
<new USVString> = <URLSearchParams>.get(<USVString>);
<new sequence_USVString_> = <URLSearchParams>.getAll(<USVString>);
<new boolean> = <URLSearchParams>.has(<USVString>);
<URLSearchParams>.set(<USVString>,<USVString>);

#NodeFilter
<new short> = <NodeFilter>.acceptNode();
<new short> = <NodeFilter>.acceptNode(<Element>);

#ChildNode
<Element>.before(<Element>);
<Element>.before(<DOMString>);
<Element>.after(<Element>);
<Element>.after(<DOMString>);
<Element>.replaceWith(<Element>);
<Element>.replaceWith(<DOMString>);
<Element>.remove();

#MessagePort
!extends MessagePort EventTarget
<new EventTarget> = <MessagePort>;
<MessagePort>.postMessage(<any>);
<MessagePort>.postMessage(<any>,<sequence_Transferable_>);
<MessagePort>.start();
<MessagePort>.close();
<new EventHandler> = <MessagePort>.onmessage;
<MessagePort>.onmessage = <EventHandler>;

#DocumentOrShadowRoot
<new Selection> = <DocumentOrShadowRoot>.getSelection();
<new Element> = <DocumentOrShadowRoot>.elementFromPoint(<fuzzint>,<fuzzint>);
<new sequence_Element_> = <DocumentOrShadowRoot>.elementsFromPoint(<fuzzint>,<fuzzint>);
<new Element> = <DocumentOrShadowRoot>.activeElement;
<new StyleSheetList> = <DocumentOrShadowRoot>.styleSheets;
<new Element> = <DocumentOrShadowRoot>.pointerLockElement;

#DocumentType
!extends DocumentType Element
<new Element> = <DocumentType>;
<new DOMString> = <DocumentType>.name;
<new DOMString> = <DocumentType>.publicId;
<new DOMString> = <DocumentType>.systemId;

#ParentNode
<new HTMLCollection> = <Element>.children;
<new Element> = <Element>.firstElementChild;
<new Element> = <Element>.lastElementChild;
<new long> = <Element>.childElementCount;
<Element>.prepend(<Element>);
<Element>.prepend(<DOMString>);
<Element>.append(<Element>);
<Element>.append(<DOMString>);
<new Element> = <Element>.querySelector("<selector>");
<new NodeList> = <Element>.querySelectorAll("<selector>");

#Text
!extends Text CharacterData
<new CharacterData> = <Text>;
<new Text> = <Text>.splitText(<fuzzint>);
<new DOMString> = <Text>.wholeText;
<new NodeList> = <Text>.getDestinationInsertionPoints();
<new HTMLSlotElement> = <Text>.assignedSlot;
!extends Document GlobalEventHandlers
<new GlobalEventHandlers> = <Document>;

!extends Document DocumentOrShadowRoot
<new DocumentOrShadowRoot> = <Document>;

#Document
<new DOMImplementation> = <Document>.implementation;
<new DOMString> = <Document>.URL;
<new DOMString> = <Document>.documentURI;
<new DOMString> = <Document>.origin;
<new DOMString> = <Document>.suborigin;
<new DOMString> = <Document>.compatMode;
<new DOMString> = <Document>.characterSet;
<new DOMString> = <Document>.charset;
<new DOMString> = <Document>.inputEncoding;
<new DOMString> = <Document>.contentType;
<new DocumentType> = <Document>.doctype;
<new Element> = <Document>.documentElement;
<new HTMLCollection> = <Document>.getElementsByTagName(<string_tag>);
<new HTMLCollection> = <Document>.getElementsByTagNameNS("http://www.w3.org/1999/xhtml",<string_tag>);
<new HTMLCollection> = <Document>.getElementsByClassName("<class>");
<new Element> = <Document>.createElement(<string_tag>);
<new Element> = <Document>.createElementNS("http://www.w3.org/1999/xhtml",<string_tag>);
<new DocumentFragment> = <Document>.createDocumentFragment();
<new Text> = <Document>.createTextNode(<DOMString>);
<new CDATASection> = <Document>.createCDATASection(<DOMString>);
<new Comment> = <Document>.createComment(<DOMString>);
<new ProcessingInstruction> = <Document>.createProcessingInstruction(<DOMString>,<DOMString>);
<new Element> = <Document>.importNode(<Element>);
<new Element> = <Document>.importNode(<Element>,<boolean>);
<new Element> = <Document>.adoptNode(<Element>);
<new Attr> = <Document>.createAttribute(<string_attr>);
<new Attr> = <Document>.createAttributeNS("http://www.w3.org/1999/xhtml",<string_attr>);
<new Event> = <Document>.createEvent(<DOMString>);
<new Range> = <Document>.createRange();
<new NodeIterator> = <Document>.createNodeIterator(<Element>);
<new NodeIterator> = <Document>.createNodeIterator(<Element>,<fuzzint>);
<new NodeIterator> = <Document>.createNodeIterator(<Element>,<fuzzint>,<NodeFilter>);
<new TreeWalker> = <Document>.createTreeWalker(<Element>);
<new TreeWalker> = <Document>.createTreeWalker(<Element>,<fuzzint>);
<new TreeWalker> = <Document>.createTreeWalker(<Element>,<fuzzint>,<NodeFilter>);
<new Element> = <Document>.rootScroller;
<Document>.rootScroller = <Element>;
<new DOMString> = <Document>.xmlEncoding;
<new DOMString> = <Document>.xmlVersion;
<Document>.xmlVersion = <DOMString>;
<new boolean> = <Document>.xmlStandalone;
<Document>.xmlStandalone = <boolean>;
#<new Location> = <Document>.location;
<new DOMString> = <Document>.domain;
<Document>.domain = <DOMString>;
<new DOMString> = <Document>.referrer;
<new DOMString> = <Document>.cookie;
<Document>.cookie = <DOMString>;
<new DOMString> = <Document>.lastModified;
<new DocumentReadyState> = <Document>.readyState;
<new DOMString> = <Document>.title;
<Document>.title = <DOMString>;
<new DOMString> = <Document>.dir;
<Document>.dir = <DOMString>;
<new Element> = <Document>.body;
#<Document>.body = <Element>;
<new HTMLHeadElement> = <Document>.head;
<new HTMLCollection> = <Document>.images;
<new HTMLCollection> = <Document>.embeds;
<new HTMLCollection> = <Document>.plugins;
<new HTMLCollection> = <Document>.links;
<new HTMLCollection> = <Document>.forms;
<new HTMLCollection> = <Document>.scripts;
<new NodeList> = <Document>.getElementsByName(<DOMString>);
<new HTMLOrSVGScriptElement> = <Document>.currentScript;
#<Document>.open();
#<Document>.close();
#<Document>.write(<DOMString>);
#<Document>.writeln(<DOMString>);
<new Window> = <Document>.defaultView;
<new boolean> = <Document>.hasFocus();
<new DOMString> = <Document>.designMode;
<Document>.designMode = <DOMString>;
<new boolean> = <Document>.execCommand("backColor", false, "<color>");
<new boolean> = <Document>.execCommand("bold", false);
<new boolean> = <Document>.execCommand("contentReadOnly", false, <boolean>);
#<new boolean> = <Document>.execCommand("copy", false);
<new boolean> = <Document>.execCommand("createLink", false, "<hash>foo");
#<new boolean> = <Document>.execCommand("cut", false);
<new boolean> = <Document>.execCommand("decreaseFontSize", false);
<new boolean> = <Document>.execCommand("delete", false);
<new boolean> = <Document>.execCommand("enableInlineTableEditing", false);
<new boolean> = <Document>.execCommand("enableObjectResizing", false);
<new boolean> = <Document>.execCommand("fontName", false, "<face_value>");
<new boolean> = <Document>.execCommand("fontSize", false, <int min=1 max=7>);
<new boolean> = <Document>.execCommand("foreColor", false, "<color>");
<new boolean> = <Document>.execCommand("formatBlock", false);
<new boolean> = <Document>.execCommand("forwardDelete", false);
<new boolean> = <Document>.execCommand("heading", false, "H<int min=1 max=6>");
<new boolean> = <Document>.execCommand("hiliteColor", false, "<color>");
<new boolean> = <Document>.execCommand("increaseFontSize", false);
<new boolean> = <Document>.execCommand("indent", false);
<new boolean> = <Document>.execCommand("insertBrOnReturn", false);
<new boolean> = <Document>.execCommand("insertHorizontalRule", false);
<new boolean> = <Document>.execCommand("insertHTML", false, <htmlstring>);
<new boolean> = <Document>.execCommand("insertImage", false, "<hash>foo");
<new boolean> = <Document>.execCommand("insertOrderedList", false);
<new boolean> = <Document>.execCommand("insertUnorderedList", false);
#<new boolean> = <Document>.execCommand("insertParagraph", false);
<new boolean> = <Document>.execCommand("insertText", false, <DOMString>);
<new boolean> = <Document>.execCommand("italic", false);
<new boolean> = <Document>.execCommand("justifyCenter", false);
<new boolean> = <Document>.execCommand("justifyFull", false);
<new boolean> = <Document>.execCommand("justifyLeft", false);
<new boolean> = <Document>.execCommand("justifyRight", false);
<new boolean> = <Document>.execCommand("outdent", false);
#<new boolean> = <Document>.execCommand("paste", false);
<new boolean> = <Document>.execCommand("redo", false);
<new boolean> = <Document>.execCommand("removeFormat", false);
<new boolean> = <Document>.execCommand("selectAll", false);
<new boolean> = <Document>.execCommand("selectAll", false);
<new boolean> = <Document>.execCommand("selectAll", false);
<new boolean> = <Document>.execCommand("selectAll", false);
<new boolean> = <Document>.execCommand("selectAll", false);
<new boolean> = <Document>.execCommand("strikeThrough", false);
<new boolean> = <Document>.execCommand("subscript", false);
<new boolean> = <Document>.execCommand("superscript", false);
<new boolean> = <Document>.execCommand("underline", false);
<new boolean> = <Document>.execCommand("undo", false);
<new boolean> = <Document>.execCommand("unlink", false);
<new boolean> = <Document>.execCommand("useCSS", false, <boolean>);
<new boolean> = <Document>.execCommand("styleWithCSS", false, <boolean>);
<new boolean> = <Document>.queryCommandEnabled(<DOMString>);
<new boolean> = <Document>.queryCommandIndeterm(<DOMString>);
<new boolean> = <Document>.queryCommandState(<DOMString>);
<new boolean> = <Document>.queryCommandSupported(<DOMString>);
<new DOMString> = <Document>.queryCommandValue(<DOMString>);
<new EventHandler> = <Document>.onreadystatechange;
<Document>.onreadystatechange = <EventHandler>;
<new HTMLCollection> = <Document>.anchors;
<new HTMLCollection> = <Document>.applets;
<new DOMString> = <Document>.selectedStylesheetSet;
<Document>.selectedStylesheetSet = <DOMString>;
<new DOMString> = <Document>.preferredStylesheetSet;
<new Element> = <Document>.scrollingElement;
<new EventHandler> = <Document>.onpointerlockchange;
<Document>.onpointerlockchange = <EventHandler>;
<new EventHandler> = <Document>.onpointerlockerror;
<Document>.onpointerlockerror = <EventHandler>;
<Document>.exitPointerLock();
<new Touch> = <Document>.createTouch();
<new Touch> = <Document>.createTouch(<Window>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>,<double>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>,<double>,<double>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>,<double>,<double>,<double>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>,<double>,<double>,<double>,<double>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>,<double>,<double>,<double>,<double>,<double>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>,<double>,<double>,<double>,<double>,<double>,<float>);
<new Touch> = <Document>.createTouch(<Window>,<EventTarget>,<fuzzint>,<double>,<double>,<double>,<double>,<double>,<double>,<float>,<float>);
<new TouchList> = <Document>.createTouchList(<Touch>);
<new CustomElementConstructor> = <Document>.registerElement(<DOMString>);
<new CustomElementConstructor> = <Document>.registerElement(<DOMString>,<ElementRegistrationOptions>);
<new Element> = <Document>.createElement(<string_tag>,<DOMString>);
<new Element> = <Document>.createElementNS("http://www.w3.org/1999/xhtml",<string_tag>,<DOMString>);
<new boolean> = <Document>.hidden;
<new VisibilityState> = <Document>.visibilityState;
<new AddressSpace> = <Document>.addressSpace;
<new Range> = <Document>.caretRangeFromPoint();
<new Range> = <Document>.caretRangeFromPoint(<int min=0 max=500>,<int min=0 max=500>);
<new DOMString> = <Document>.webkitVisibilityState;
<new boolean> = <Document>.webkitHidden;
<new EventHandler> = <Document>.onbeforecopy;
<Document>.onbeforecopy = <EventHandler>;
<new EventHandler> = <Document>.onbeforecut;
<Document>.onbeforecut = <EventHandler>;
<new EventHandler> = <Document>.onbeforepaste;
<Document>.onbeforepaste = <EventHandler>;
<new EventHandler> = <Document>.oncopy;
<Document>.oncopy = <EventHandler>;
<new EventHandler> = <Document>.oncut;
<Document>.oncut = <EventHandler>;
<new EventHandler> = <Document>.onpaste;
<Document>.onpaste = <EventHandler>;
<new EventHandler> = <Document>.onsearch;
<Document>.onsearch = <EventHandler>;
<new EventHandler> = <Document>.onsecuritypolicyviolation;
<Document>.onsecuritypolicyviolation = <EventHandler>;
<new EventHandler> = <Document>.onselectionchange;
<Document>.onselectionchange = <EventHandler>;
<new EventHandler> = <Document>.onselectstart;
<Document>.onselectstart = <EventHandler>;
<new EventHandler> = <Document>.onwheel;
<Document>.onwheel = <EventHandler>;

#HTMLDocument
<new DOMString> = <Document>.fgColor;
<Document>.fgColor = <DOMString>;
<new DOMString> = <Document>.linkColor;
<Document>.linkColor = <DOMString>;
<new DOMString> = <Document>.vlinkColor;
<Document>.vlinkColor = <DOMString>;
<new DOMString> = <Document>.alinkColor;
<Document>.alinkColor = <DOMString>;
<new DOMString> = <Document>.bgColor;
<Document>.bgColor = "<bgcolor_value>";
<Document>.clear();
<Document>.captureEvents();
<Document>.releaseEvents();
<new HTMLAllCollection> = <Document>.all;


#NonElementParentNode
<new Element> = <Document>.getElementById("<elementid>");

#NamedNodeMap
<new long> = <NamedNodeMap>.length;
<new Attr> = <NamedNodeMap id=1>.item(<int min=0 max=100>%<NamedNodeMap id=1>.length);
<new Attr> = <NamedNodeMap id=1>[<int min=0 max=100>%<NamedNodeMap id=1>.length];
<NamedNodeMap>.setNamedItem(<Attr>);
<NamedNodeMap>.setNamedItemNS(<Attr>);
<NamedNodeMap id=1>.removeNamedItem(<NamedNodeMap id=1>[<int min=0 max=100>%<NamedNodeMap id=1>.length].name);
<NamedNodeMap id=1>.removeNamedItemNS("http://www.w3.org/1999/xhtml",<NamedNodeMap id=1>[<int min=0 max=100>%<NamedNodeMap id=1>.length].name);

#CDATASection
!extends CDATASection Text
<new Text> = <CDATASection>;

#GlobalEventHandlers
<new EventHandler> = <GlobalEventHandlers>.onabort;
<GlobalEventHandlers>.onabort = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onblur;
<GlobalEventHandlers>.onblur = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.oncancel;
<GlobalEventHandlers>.oncancel = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.oncanplay;
<GlobalEventHandlers>.oncanplay = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.oncanplaythrough;
<GlobalEventHandlers>.oncanplaythrough = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onchange;
<GlobalEventHandlers>.onchange = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onclick;
<GlobalEventHandlers>.onclick = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onclose;
<GlobalEventHandlers>.onclose = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.oncontextmenu;
<GlobalEventHandlers>.oncontextmenu = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.oncuechange;
<GlobalEventHandlers>.oncuechange = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondblclick;
<GlobalEventHandlers>.ondblclick = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondrag;
<GlobalEventHandlers>.ondrag = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondragend;
<GlobalEventHandlers>.ondragend = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondragenter;
<GlobalEventHandlers>.ondragenter = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondragleave;
<GlobalEventHandlers>.ondragleave = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondragover;
<GlobalEventHandlers>.ondragover = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondragstart;
<GlobalEventHandlers>.ondragstart = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondrop;
<GlobalEventHandlers>.ondrop = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ondurationchange;
<GlobalEventHandlers>.ondurationchange = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onemptied;
<GlobalEventHandlers>.onemptied = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onended;
<GlobalEventHandlers>.onended = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onerror;
<GlobalEventHandlers>.onerror = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onfocus;
<GlobalEventHandlers>.onfocus = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.oninput;
<GlobalEventHandlers>.oninput = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.oninvalid;
<GlobalEventHandlers>.oninvalid = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onkeydown;
<GlobalEventHandlers>.onkeydown = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onkeypress;
<GlobalEventHandlers>.onkeypress = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onkeyup;
<GlobalEventHandlers>.onkeyup = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onload;
<GlobalEventHandlers>.onload = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onloadeddata;
<GlobalEventHandlers>.onloadeddata = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onloadedmetadata;
<GlobalEventHandlers>.onloadedmetadata = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onloadstart;
<GlobalEventHandlers>.onloadstart = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmousedown;
<GlobalEventHandlers>.onmousedown = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmouseenter;
<GlobalEventHandlers>.onmouseenter = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmouseleave;
<GlobalEventHandlers>.onmouseleave = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmousemove;
<GlobalEventHandlers>.onmousemove = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmouseout;
<GlobalEventHandlers>.onmouseout = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmouseover;
<GlobalEventHandlers>.onmouseover = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmouseup;
<GlobalEventHandlers>.onmouseup = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onmousewheel;
<GlobalEventHandlers>.onmousewheel = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpause;
<GlobalEventHandlers>.onpause = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onplay;
<GlobalEventHandlers>.onplay = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onplaying;
<GlobalEventHandlers>.onplaying = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onprogress;
<GlobalEventHandlers>.onprogress = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onratechange;
<GlobalEventHandlers>.onratechange = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onreset;
<GlobalEventHandlers>.onreset = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onresize;
<GlobalEventHandlers>.onresize = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onscroll;
<GlobalEventHandlers>.onscroll = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onseeked;
<GlobalEventHandlers>.onseeked = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onseeking;
<GlobalEventHandlers>.onseeking = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onselect;
<GlobalEventHandlers>.onselect = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onshow;
<GlobalEventHandlers>.onshow = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onstalled;
<GlobalEventHandlers>.onstalled = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onsubmit;
<GlobalEventHandlers>.onsubmit = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onsuspend;
<GlobalEventHandlers>.onsuspend = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ontimeupdate;
<GlobalEventHandlers>.ontimeupdate = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ontoggle;
<GlobalEventHandlers>.ontoggle = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onvolumechange;
<GlobalEventHandlers>.onvolumechange = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onwaiting;
<GlobalEventHandlers>.onwaiting = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onauxclick;
<GlobalEventHandlers>.onauxclick = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointerdown;
<GlobalEventHandlers>.onpointerdown = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointermove;
<GlobalEventHandlers>.onpointermove = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointerup;
<GlobalEventHandlers>.onpointerup = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointercancel;
<GlobalEventHandlers>.onpointercancel = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointerover;
<GlobalEventHandlers>.onpointerover = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointerout;
<GlobalEventHandlers>.onpointerout = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointerenter;
<GlobalEventHandlers>.onpointerenter = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.onpointerleave;
<GlobalEventHandlers>.onpointerleave = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ontouchcancel;
<GlobalEventHandlers>.ontouchcancel = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ontouchend;
<GlobalEventHandlers>.ontouchend = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ontouchmove;
<GlobalEventHandlers>.ontouchmove = <EventHandler>;
<new EventHandler> = <GlobalEventHandlers>.ontouchstart;
<GlobalEventHandlers>.ontouchstart = <EventHandler>;

#NodeList
<new Element> = <NodeList id=1>.item(<int min=0 max=100>%<NodeList id=1>.length);
<new long> = <NodeList>.length;

#MutationObserver
<MutationObserver>.observe(<Element>,<MutationObserverInit>);
<MutationObserver>.disconnect();
<new sequence_MutationRecord_> = <MutationObserver>.takeRecords();

#TouchList
<new long> = <TouchList>.length;
<new Touch> = <TouchList id=1>.item(<int min=0 max=100>%<TouchList id=1>.length);

#DOMStringMap
<new DOMString> = <DOMStringMap>[<DOMString>];
<DOMStringMap>[<DOMString>] = <DOMString>;

#MutationRecord
<new DOMString> = <MutationRecord>.type;
<new Element> = <MutationRecord>.target;
<new NodeList> = <MutationRecord>.addedNodes;
<new NodeList> = <MutationRecord>.removedNodes;
<new Element> = <MutationRecord>.previousSibling;
<new Element> = <MutationRecord>.nextSibling;
<new DOMString> = <MutationRecord>.attributeName;
<new DOMString> = <MutationRecord>.attributeNamespace;
<new DOMString> = <MutationRecord>.oldValue;

#CharacterData
!extends CharacterData Element
<new Element> = <CharacterData>;
<new DOMString> = <CharacterData>.data;
<CharacterData>.data = <DOMString>;
<new long> = <CharacterData>.length;
<new DOMString> = <CharacterData>.substringData(<fuzzint>,<fuzzint>);
<CharacterData>.appendData(<DOMString>);
<CharacterData>.insertData(<fuzzint>,<DOMString>);
<CharacterData>.deleteData(<fuzzint>,<fuzzint>);
<CharacterData>.replaceData(<fuzzint>,<fuzzint>,<DOMString>);

#Range
<new Element> = <Range>.startContainer;
<new long> = <Range>.startOffset;
<new Element> = <Range>.endContainer;
<new long> = <Range>.endOffset;
<new boolean> = <Range>.collapsed;
<new Element> = <Range>.commonAncestorContainer;
<Range>.setStart(<Element>,<fuzzint>);
<Range>.setEnd(<Element>,<fuzzint>);
<Range>.setStartBefore(<Element>);
<Range>.setStartAfter(<Element>);
<Range>.setEndBefore(<Element>);
<Range>.setEndAfter(<Element>);
<Range>.collapse();
<Range>.collapse(<boolean>);
<Range>.selectNode(<Element>);
<Range>.selectNodeContents(<Element>);
<new short> = <Range>.compareBoundaryPoints(<fuzzint>,<Range>);
<Range>.deleteContents();
<new DocumentFragment> = <Range>.extractContents();
<new DocumentFragment> = <Range>.cloneContents();
<Range>.insertNode(<Element>);
<Range>.surroundContents(<Element>);
<new Range> = <Range>.cloneRange();
<Range>.detach();
<new boolean> = <Range>.isPointInRange(<Element>,<fuzzint>);
<new short> = <Range>.comparePoint(<Element>,<fuzzint>);
<new boolean> = <Range>.intersectsNode(<Element>);
<new ClientRectList> = <Range>.getClientRects();
<new ClientRect> = <Range>.getBoundingClientRect();
<new DocumentFragment> = <Range>.createContextualFragment(<DOMString>);
<Range>.expand();
<Range>.expand(<DOMString>);

#Element
<Element>.requestFullscreen();
<Element>.webkitRequestFullScreen();
<Element>.webkitRequestFullscreen();
<new EventHandler> = <Element>.onwebkitfullscreenchange;
<Element>.onwebkitfullscreenchange = <EventHandler>;
<new EventHandler> = <Element>.onwebkitfullscreenerror;
<Element>.onwebkitfullscreenerror = <EventHandler>;

#URL
<new USVString> = <URL>.href;
<URL>.href = <USVString>;
<new USVString> = <URL>.origin;
<new USVString> = <URL>.protocol;
<URL>.protocol = <USVString>;
<new USVString> = <URL>.username;
<URL>.username = <USVString>;
<new USVString> = <URL>.password;
<URL>.password = <USVString>;
<new USVString> = <URL>.host;
<URL>.host = <USVString>;
<new USVString> = <URL>.hostname;
<URL>.hostname = <USVString>;
<new USVString> = <URL>.port;
<URL>.port = <USVString>;
<new USVString> = <URL>.pathname;
<URL>.pathname = <USVString>;
<new USVString> = <URL>.search;
<URL>.search = <USVString>;
<new URLSearchParams> = <URL>.searchParams;
<new USVString> = <URL>.hash;
<URL>.hash = <USVString>;

#ProcessingInstruction
!extends ProcessingInstruction CharacterData
<new CharacterData> = <ProcessingInstruction>;
<new DOMString> = <ProcessingInstruction>.target;
<new StyleSheet> = <ProcessingInstruction>.sheet;

#DOMStringList
<new long> = <DOMStringList>.length;
<new DOMString> = <DOMStringList id=1>[<int min=0 max=100>%<DOMStringList id=1>.length];
<new boolean> = <DOMStringList>.contains(<DOMString>);

#Touch
<new long> = <Touch>.identifier;
<new EventTarget> = <Touch>.target;
<new double> = <Touch>.screenX;
<new double> = <Touch>.screenY;
<new double> = <Touch>.clientX;
<new double> = <Touch>.clientY;
<new double> = <Touch>.pageX;
<new double> = <Touch>.pageY;
<new float> = <Touch>.radiusX;
<new float> = <Touch>.radiusY;
<new float> = <Touch>.rotationAngle;
<new float> = <Touch>.force;
<new DOMString> = <Touch>.region;

#Document
<new boolean> = <Document>.fullscreenEnabled;
<new Element> = <Document>.fullscreenElement;
<Document>.exitFullscreen();
<new EventHandler> = <Document>.onfullscreenchange;
<Document>.onfullscreenchange = <EventHandler>;
<new EventHandler> = <Document>.onfullscreenerror;
<Document>.onfullscreenerror = <EventHandler>;
<new boolean> = <Document>.webkitIsFullScreen;
<new Element> = <Document>.webkitCurrentFullScreenElement;
<Document>.webkitCancelFullScreen();
<new boolean> = <Document>.webkitFullscreenEnabled;
<new Element> = <Document>.webkitFullscreenElement;
<Document>.webkitExitFullscreen();
<new EventHandler> = <Document>.onwebkitfullscreenchange;
<Document>.onwebkitfullscreenchange = <EventHandler>;
<new EventHandler> = <Document>.onwebkitfullscreenerror;
<Document>.onwebkitfullscreenerror = <EventHandler>;

#DocumentFragment
!extends DocumentFragment Element
<new Element> = <DocumentFragment>;

#NonDocumentTypeChildNode
<new Element> = <Element>.previousElementSibling;
<new Element> = <Element>.nextElementSibling;

#DOMRect
!extends DOMRect DOMRectReadOnly
<new DOMRectReadOnly> = <DOMRect>;
<new double> = <DOMRect>.x;
<DOMRect>.x = <double>;
<new double> = <DOMRect>.y;
<DOMRect>.y = <double>;
<new double> = <DOMRect>.width;
<DOMRect>.width = <double>;
<new double> = <DOMRect>.height;
<DOMRect>.height = <double>;

#DOMRectReadOnly
<new double> = <DOMRectReadOnly>.x;
<new double> = <DOMRectReadOnly>.y;
<new double> = <DOMRectReadOnly>.width;
<new double> = <DOMRectReadOnly>.height;
<new double> = <DOMRectReadOnly>.top;
<new double> = <DOMRectReadOnly>.right;
<new double> = <DOMRectReadOnly>.bottom;
<new double> = <DOMRectReadOnly>.left;

#Element
<new DOMString> = <Element>.namespaceURI;
<new DOMString> = <Element>.prefix;
<new DOMString> = <Element>.localName;
<new DOMString> = <Element>.tagName;
<new DOMString> = <Element>.id;
<Element>.id = <DOMString>;
<new DOMString> = <Element>.className;
<Element>.className = <DOMString>;
<new DOMTokenList> = <Element>.classList;
<Element>.setPointerCapture(<fuzzint>);
<Element>.releasePointerCapture(<fuzzint>);
<new EventHandler> = <Element>.ongotpointercapture;
<Element>.ongotpointercapture = <EventHandler>;
<new EventHandler> = <Element>.onlostpointercapture;
<Element>.onlostpointercapture = <EventHandler>;
<new boolean> = <Element>.hasPointerCapture(<fuzzint>);
<new boolean> = <Element>.hasAttributes();
<new NamedNodeMap> = <Element>.attributes;
<new DOMString> = <Element>.getAttribute(<string_attr>);
<new DOMString> = <Element>.getAttributeNS("http://www.w3.org/1999/xhtml",<string_attr>);
#<Element>.setAttribute(<DOMString>,<DOMString>);
#<Element>.setAttributeNS(<DOMString>,<DOMString>,<DOMString>);
<Element id=1>.removeAttribute(<Element id=1>.attributes[<int min=0 max=100>%<Element id=1>.attributes.length].name);
<Element id=1>.removeAttributeNS("http://www.w3.org/1999/xhtml",<Element id=1>.attributes[<int min=0 max=100>%<Element id=1>.attributes.length].name);
<new boolean> = <Element>.hasAttribute(<string_attr>);
<new boolean> = <Element>.hasAttributeNS("http://www.w3.org/1999/xhtml",<string_attr>);
<new Attr> = <Element>.getAttributeNode(<string_attr>);
<new Attr> = <Element>.getAttributeNodeNS("http://www.w3.org/1999/xhtml",<string_attr>);
<new Attr> = <Element>.setAttributeNode(<Attr>);
<new Attr> = <Element>.setAttributeNodeNS(<Attr>);
<new Attr> = <Element id=1>.removeAttributeNode(<Element id=1>.attributes[<int min=0 max=100>%<Element id=1>.attributes.length].name);
<new Element> = <Element>.closest(<DOMString>);
<new boolean> = <Element>.matches(<DOMString>);
<new boolean> = <Element>.webkitMatchesSelector(<DOMString>);
<new HTMLCollection> = <Element>.getElementsByTagName(<string_tag>);
<new HTMLCollection> = <Element>.getElementsByTagNameNS("http://www.w3.org/1999/xhtml",<string_tag>);
<new HTMLCollection> = <Element>.getElementsByClassName("<class>");
<new Element> = <Element>.insertAdjacentElement(<string_where>,<Element>);
<Element>.insertAdjacentText(<string_where>,<DOMString>);
<new htmlstring> = <Element>.innerHTML;
<Element>.innerHTML = <htmlstring>;
<new htmlstring> = <Element>.outerHTML;
<Element>.outerHTML = <htmlstring>;
<Element>.insertAdjacentHTML(<string_where>,<htmlstring>);
<new ShadowRoot> = <Element>.createShadowRoot();
<new ShadowRoot> = <Element>.attachShadow(<ShadowRootInit>);
<new NodeList> = <Element>.getDestinationInsertionPoints();
<new ShadowRoot> = <Element>.shadowRoot;
<new DOMString> = <Element>.slot;
<Element>.slot = <DOMString>;
<new HTMLSlotElement> = <Element>.assignedSlot;
<Element>.requestPointerLock();
<new ClientRectList> = <Element>.getClientRects();
<new ClientRect> = <Element>.getBoundingClientRect();
<Element>.scrollIntoView();
<Element>.scrollIntoView(<boolean>);
<Element>.scroll();
<Element>.scroll(<ScrollToOptions>);
<Element>.scroll(<double>,<double>);
<Element>.scrollTo();
<Element>.scrollTo(<ScrollToOptions>);
<Element>.scrollTo(<double>,<double>);
<Element>.scrollBy();
<Element>.scrollBy(<ScrollToOptions>);
<Element>.scrollBy(<double>,<double>);
<new double> = <Element>.scrollTop;
<Element>.scrollTop = <double>;
<new double> = <Element>.scrollLeft;
<Element>.scrollLeft = <double>;
<new long> = <Element>.scrollWidth;
<new long> = <Element>.scrollHeight;
<new long> = <Element>.clientTop;
<new long> = <Element>.clientLeft;
<new long> = <Element>.clientWidth;
<new long> = <Element>.clientHeight;
<Element>.setApplyScroll(<ScrollStateCallback>,<NativeScrollBehavior>);
<Element>.setDistributeScroll(<ScrollStateCallback>,<NativeScrollBehavior>);
<Element>.scrollIntoViewIfNeeded();
<Element>.scrollIntoViewIfNeeded(<boolean>);
<new DOMString> = <Element>.computedRole;
<new DOMString> = <Element>.computedName;
<new EventHandler> = <Element>.onbeforecopy;
<Element>.onbeforecopy = <EventHandler>;
<new EventHandler> = <Element>.onbeforecut;
<Element>.onbeforecut = <EventHandler>;
<new EventHandler> = <Element>.onbeforepaste;
<Element>.onbeforepaste = <EventHandler>;
<new EventHandler> = <Element>.oncopy;
<Element>.oncopy = <EventHandler>;
<new EventHandler> = <Element>.oncut;
<Element>.oncut = <EventHandler>;
<new EventHandler> = <Element>.onpaste;
<Element>.onpaste = <EventHandler>;
<new EventHandler> = <Element>.onsearch;
<Element>.onsearch = <EventHandler>;
<new EventHandler> = <Element>.onselectstart;
<Element>.onselectstart = <EventHandler>;
<new EventHandler> = <Element>.onwheel;
<Element>.onwheel = <EventHandler>;

#NodeIterator
<new Element> = <NodeIterator>.root;
<new Element> = <NodeIterator>.referenceNode;
<new boolean> = <NodeIterator>.pointerBeforeReferenceNode;
<new long> = <NodeIterator>.whatToShow;
<new NodeFilter> = <NodeIterator>.filter;
<new Element> = <NodeIterator>.nextNode();
<new Element> = <NodeIterator>.previousNode();
<NodeIterator>.detach();

#TreeWalker
<new Element> = <TreeWalker>.root;
<new long> = <TreeWalker>.whatToShow;
<new NodeFilter> = <TreeWalker>.filter;
<new Element> = <TreeWalker>.currentNode;
<TreeWalker>.currentNode = <Element>;
<new Element> = <TreeWalker>.parentNode();
<new Element> = <TreeWalker>.firstChild();
<new Element> = <TreeWalker>.lastChild();
<new Element> = <TreeWalker>.previousSibling();
<new Element> = <TreeWalker>.nextSibling();
<new Element> = <TreeWalker>.previousNode();
<new Element> = <TreeWalker>.nextNode();

#MessageChannel
<new MessagePort> = <MessageChannel>.port1;
<new MessagePort> = <MessageChannel>.port2;

#CustomElementRegistry
<CustomElementRegistry>.define(<DOMString>,<Function>);
<CustomElementRegistry>.define(<DOMString>,<Function>,<ElementRegistrationOptions>);
<new any> = <CustomElementRegistry>.get(<DOMString>);
<new Promise_void_> = <CustomElementRegistry>.whenDefined(<DOMString>);
!extends ShadowRoot DocumentOrShadowRoot
<new DocumentOrShadowRoot> = <ShadowRoot>;

#ShadowRoot
!extends ShadowRoot DocumentFragment
<new DocumentFragment> = <ShadowRoot>;
<new ShadowRootMode> = <ShadowRoot>.mode;
<new Element> = <ShadowRoot>.host;
<new ShadowRoot> = <ShadowRoot>.olderShadowRoot;
<new htmlstring> = <ShadowRoot>.innerHTML;
<ShadowRoot>.innerHTML = <htmlstring>;
<new boolean> = <ShadowRoot>.delegatesFocus;
<new Element> = <ShadowRoot>.cloneNode();
<new Element> = <ShadowRoot>.cloneNode(<boolean>);

#NavigatorLanguage
<new DOMString> = <NavigatorLanguage>.language;
<new DOMString> = <NavigatorLanguage>.languages;

#BarProp
<new boolean> = <BarProp>.visible;

#NavigatorStorageUtils
<new boolean> = <NavigatorStorageUtils>.cookieEnabled;

#Screen
<new long> = <Screen>.availWidth;
<new long> = <Screen>.availHeight;
<new long> = <Screen>.width;
<new long> = <Screen>.height;
<new long> = <Screen>.colorDepth;
<new long> = <Screen>.pixelDepth;
<new long> = <Screen>.availLeft;
<new long> = <Screen>.availTop;

#WindowBase64
<new DOMString> = <WindowBase64>.btoa(<DOMString>);
<new DOMString> = <WindowBase64>.atob(<DOMString>);

#WindowEventHandlers
<new EventHandler> = <WindowEventHandlers>.onbeforeunload;
<WindowEventHandlers>.onbeforeunload = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onhashchange;
<WindowEventHandlers>.onhashchange = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onlanguagechange;
<WindowEventHandlers>.onlanguagechange = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onmessage;
<WindowEventHandlers>.onmessage = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onoffline;
<WindowEventHandlers>.onoffline = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.ononline;
<WindowEventHandlers>.ononline = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onpagehide;
<WindowEventHandlers>.onpagehide = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onpageshow;
<WindowEventHandlers>.onpageshow = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onpopstate;
<WindowEventHandlers>.onpopstate = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onrejectionhandled;
<WindowEventHandlers>.onrejectionhandled = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onstorage;
<WindowEventHandlers>.onstorage = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onunhandledrejection;
<WindowEventHandlers>.onunhandledrejection = <EventHandler>;
<new EventHandler> = <WindowEventHandlers>.onunload;
<WindowEventHandlers>.onunload = <EventHandler>;

#NavigatorCPU
<new long> = <NavigatorCPU>.hardwareConcurrency;

#NavigatorID
<new DOMString> = <NavigatorID>.appCodeName;
<new DOMString> = <NavigatorID>.appName;
<new DOMString> = <NavigatorID>.appVersion;
<new DOMString> = <NavigatorID>.platform;
<new DOMString> = <NavigatorID>.product;
<new DOMString> = <NavigatorID>.userAgent;
!extends Window GlobalEventHandlers
<new GlobalEventHandlers> = <Window>;
!extends Window WindowBase64
<new WindowBase64> = <Window>;
!extends Window WindowEventHandlers
<new WindowEventHandlers> = <Window>;
!extends Window WindowTimers
<new WindowTimers> = <Window>;

#Window
!extends Window EventTarget
<new EventTarget> = <Window>;
<new Window> = <Window>.window;
<new Window> = <Window>.self;
<new Document> = <Window>.document;
<new DOMString> = <Window>.name;
<Window>.name = <DOMString>;
#<new Location> = <Window>.location;
<new History> = <Window>.history;
<new BarProp> = <Window>.locationbar;
<new BarProp> = <Window>.menubar;
<new BarProp> = <Window>.personalbar;
<new BarProp> = <Window>.scrollbars;
<new BarProp> = <Window>.statusbar;
<new BarProp> = <Window>.toolbar;
<new DOMString> = <Window>.status;
<Window>.status = <DOMString>;
#<Window>.close();
<new boolean> = <Window>.closed;
<Window>.stop();
<Window>.focus();
<Window>.blur();
<new Window> = <Window>.frames;
<new long> = <Window>.length;
<new Window> = <Window>.top;
<new Window> = <Window>.opener;
<Window>.opener = <Window>;
<new Window> = <Window>.parent;
<new Element> = <Window>.frameElement;
#<new Window> = <Window>.open(<DOMString>,<DOMString>);
#<new Window> = <Window>.open(<DOMString>,<DOMString>,<DOMString>);
<new Window> = <Window id=1>[<int min=0 max=100>%<Window id=1>.length];
<new Navigator> = <Window>.navigator;
<new ApplicationCache> = <Window>.applicationCache;
#<Window>.alert();
#<Window>.alert(<DOMString>);
#<new boolean> = <Window>.confirm();
#<new boolean> = <Window>.confirm(<DOMString>);
#<new DOMString> = <Window>.prompt();
#<new DOMString> = <Window>.prompt(<DOMString>);
#<new DOMString> = <Window>.prompt(<DOMString>,<DOMString>);
#<Window>.print();
<new long> = <Window>.requestAnimationFrame(<FrameRequestCallback>);
<Window>.cancelAnimationFrame(<fuzzint>);
<new long> = <Window>.requestIdleCallback(<IdleRequestCallback>);
<new long> = <Window>.requestIdleCallback(<IdleRequestCallback>,<IdleRequestOptions>);
<Window>.cancelIdleCallback(<fuzzint>);
<Window>.postMessage(<any>,<DOMString>);
<Window>.postMessage(<any>,<DOMString>,<sequence_Transferable_>);
<new CustomElementRegistry> = <Window>.customElements;
<Window>.captureEvents();
<Window>.releaseEvents();
<new External> = <Window>.external;
<Window>.getComputedStyle(<Element>);
<Window>.getComputedStyle(<Element>,<DOMString>);
<new MediaQueryList> = <Window>.matchMedia(<DOMString>);
<new Screen> = <Window>.screen;
<Window>.moveTo(<fuzzint>,<fuzzint>);
<Window>.moveBy(<fuzzint>,<fuzzint>);
<Window>.resizeTo(<fuzzint>,<fuzzint>);
<Window>.resizeBy(<fuzzint>,<fuzzint>);
<new long> = <Window>.innerWidth;
<new long> = <Window>.innerHeight;
<new double> = <Window>.scrollX;
<new double> = <Window>.pageXOffset;
<new double> = <Window>.scrollY;
<new double> = <Window>.pageYOffset;
<Window>.scroll();
<Window>.scroll(<ScrollToOptions>);
<Window>.scroll(<double>,<double>);
<Window>.scrollTo();
<Window>.scrollTo(<ScrollToOptions>);
<Window>.scrollTo(<double>,<double>);
<Window>.scrollBy();
<Window>.scrollBy(<ScrollToOptions>);
<Window>.scrollBy(<double>,<double>);
<new VisualViewport> = <Window>.visualViewport;
<new long> = <Window>.screenX;
<new long> = <Window>.screenY;
<new long> = <Window>.outerWidth;
<new long> = <Window>.outerHeight;
<new double> = <Window>.devicePixelRatio;
<new Selection> = <Window>.getSelection();
<new Navigator> = <Window>.clientInformation;
<new Event> = <Window>.event;
<Window>.event = <Event>;
<new boolean> = <Window>.find();
<new boolean> = <Window>.find(<DOMString>);
<new boolean> = <Window>.find(<DOMString>,<boolean>);
<new boolean> = <Window>.find(<DOMString>,<boolean>,<boolean>);
<new boolean> = <Window>.find(<DOMString>,<boolean>,<boolean>,<boolean>);
<new boolean> = <Window>.find(<DOMString>,<boolean>,<boolean>,<boolean>,<boolean>);
<new boolean> = <Window>.find(<DOMString>,<boolean>,<boolean>,<boolean>,<boolean>,<boolean>);
<new boolean> = <Window>.find(<DOMString>,<boolean>,<boolean>,<boolean>,<boolean>,<boolean>,<boolean>);
<new boolean> = <Window>.offscreenBuffering;
<new long> = <Window>.screenLeft;
<new long> = <Window>.screenTop;
<new DOMString> = <Window>.defaultStatus;
<Window>.defaultStatus = <DOMString>;
<new DOMString> = <Window>.defaultstatus;
<Window>.defaultstatus = <DOMString>;
<new StyleMedia> = <Window>.styleMedia;
<new CSSRuleList> = <Window>.getMatchedCSSRules();
<new CSSRuleList> = <Window>.getMatchedCSSRules(<Element>);
<new CSSRuleList> = <Window>.getMatchedCSSRules(<Element>,<DOMString>);
<new long> = <Window>.orientation;
<new long> = <Window>.webkitRequestAnimationFrame(<FrameRequestCallback>);
<Window>.webkitCancelAnimationFrame(<fuzzint>);
<Window>.webkitCancelRequestAnimationFrame(<fuzzint>);
<new TransitionEventConstructor> = <Window>.WebKitTransitionEvent;
<Window>.WebKitTransitionEvent = <TransitionEventConstructor>;
<new AnimationEventConstructor> = <Window>.WebKitAnimationEvent;
<Window>.WebKitAnimationEvent = <AnimationEventConstructor>;
<new URLConstructor> = <Window>.webkitURL;
<Window>.webkitURL = <URLConstructor>;
<new MutationObserverConstructor> = <Window>.WebKitMutationObserver;
<Window>.WebKitMutationObserver = <MutationObserverConstructor>;
<new EventHandler> = <Window>.onanimationend;
<Window>.onanimationend = <EventHandler>;
<new EventHandler> = <Window>.onanimationiteration;
<Window>.onanimationiteration = <EventHandler>;
<new EventHandler> = <Window>.onanimationstart;
<Window>.onanimationstart = <EventHandler>;
<new EventHandler> = <Window>.onorientationchange;
<Window>.onorientationchange = <EventHandler>;
<new EventHandler> = <Window>.onsearch;
<Window>.onsearch = <EventHandler>;
<new EventHandler> = <Window>.ontransitionend;
<Window>.ontransitionend = <EventHandler>;
<new EventHandler> = <Window>.onwebkitanimationend;
<Window>.onwebkitanimationend = <EventHandler>;
<new EventHandler> = <Window>.onwebkitanimationiteration;
<Window>.onwebkitanimationiteration = <EventHandler>;
<new EventHandler> = <Window>.onwebkitanimationstart;
<Window>.onwebkitanimationstart = <EventHandler>;
<new EventHandler> = <Window>.onwebkittransitionend;
<Window>.onwebkittransitionend = <EventHandler>;
<new EventHandler> = <Window>.onwheel;
<Window>.onwheel = <EventHandler>;
<new boolean> = <Window>.isSecureContext;

#History
<new long> = <History>.length;
<new ScrollRestoration> = <History>.scrollRestoration;
<History>.scrollRestoration = <ScrollRestoration>;
<new SerializedScriptValue> = <History>.state;
#<History>.go();
#<History>.go(<fuzzint>);
#<History>.back();
#<History>.forward();
<History>.pushState(<SerializedScriptValue>,<DOMString>);
<History>.pushState(<SerializedScriptValue>,<DOMString>,<DOMString>);
<History>.replaceState(<SerializedScriptValue>,<DOMString>);
<History>.replaceState(<SerializedScriptValue>,<DOMString>,<DOMString>);

#VisualViewport
!extends VisualViewport EventTarget
<new EventTarget> = <VisualViewport>;
<new double> = <VisualViewport>.scrollLeft;
<new double> = <VisualViewport>.scrollTop;
<new double> = <VisualViewport>.pageX;
<new double> = <VisualViewport>.pageY;
<new double> = <VisualViewport>.clientWidth;
<new double> = <VisualViewport>.clientHeight;
<new double> = <VisualViewport>.scale;

#Location
#<Location>.assign(<DOMString>);
#<Location>.replace(<DOMString>);
#<Location>.reload();
#<new DOMStringList> = <Location>.ancestorOrigins;
#<new DOMString> = <Location>.href;
#<Location>.href = <DOMString>;
#<new DOMString> = <Location>.toString();
#<new DOMString> = <Location>.origin;
#<new DOMString> = <Location>.protocol;
#<Location>.protocol = <DOMString>;
#<new DOMString> = <Location>.host;
#<Location>.host = <DOMString>;
#<new DOMString> = <Location>.hostname;
#<Location>.hostname = <DOMString>;
#<new DOMString> = <Location>.port;
#<Location>.port = <DOMString>;
#<new DOMString> = <Location>.pathname;
#<Location>.pathname = <DOMString>;
#<new DOMString> = <Location>.search;
#<Location>.search = <DOMString>;
#<new DOMString> = <Location>.hash;
#<Location>.hash = <DOMString>;
#<new any> = <Location>.valueOf();

!extends Navigator NavigatorCPU
<new NavigatorCPU> = <Navigator>;
!extends Navigator NavigatorID
<new NavigatorID> = <Navigator>;
!extends Navigator NavigatorLanguage
<new NavigatorLanguage> = <Navigator>;
!extends Navigator NavigatorOnLine
<new NavigatorOnLine> = <Navigator>;
!extends Navigator NavigatorStorageUtils
<new NavigatorStorageUtils> = <Navigator>;

#Navigator
<new DOMString> = <Navigator>.vendorSub;
<new DOMString> = <Navigator>.productSub;
<new DOMString> = <Navigator>.vendor;
<Navigator>.sendBeacon(<url_string>, <DOMString>)

#External
<External>.AddSearchProvider();
<External>.IsSearchProviderInstalled();

#NavigatorOnLine
<new boolean> = <NavigatorOnLine>.onLine;

#Attribute setters with correct arguments
<Element>.setAttribute("abbr", "<abbr_value>");
<Element>.setAttribute("accept", "<accept_value>");
<Element>.setAttribute("accept-charset", "<accept-charset_value>");
<Element>.setAttribute("accepts-touch", "<accepts-touch_value>");
<Element>.setAttribute("accesskey", "<accesskey_value>");
<Element>.setAttribute("accumulate", "<accumulate_value>");
<Element>.setAttribute("additive", "<additive_value>");
<Element>.setAttribute("align", "<align_value>");
<Element>.setAttribute("alink", "<alink_value>");
<Element>.setAttribute("allowfullscreen", "<allowfullscreen_value>");
<Element>.setAttribute("alt", "<alt_value>");
<Element>.setAttribute("archive", "<archive_value>");
<Element>.setAttribute("aria-activedescendant", "<aria-activedescendant_value>");
<Element>.setAttribute("aria-autocomplete", "<aria-autocomplete_value>");
<Element>.setAttribute("aria-atomic", "<aria-atomic_value>");
<Element>.setAttribute("aria-busy", "<aria-busy_value>");
<Element>.setAttribute("aria-checked", "<aria-checked_value>");
<Element>.setAttribute("aria-controls", "<aria-controls_value>");
<Element>.setAttribute("aria-describedby", "<aria-describedby_value>");
<Element>.setAttribute("aria-disabled", "<aria-disabled_value>");
<Element>.setAttribute("aria-dropeffect", "<aria-dropeffect_value>");
<Element>.setAttribute("aria-expanded", "<aria-expanded_value>");
<Element>.setAttribute("aria-flowto", "<aria-flowto_value>");
<Element>.setAttribute("aria-grabbed", "<aria-grabbed_value>");
<Element>.setAttribute("aria-haspopup", "<aria-haspopup_value>");
<Element>.setAttribute("aria-help", "<aria-help_value>");
<Element>.setAttribute("aria-hidden", "<aria-hidden_value>");
<Element>.setAttribute("aria-invalid", "<aria-invalid_value>");
<Element>.setAttribute("aria-label", "<aria-label_value>");
<Element>.setAttribute("aria-labeledby", "<aria-labeledby_value>");
<Element>.setAttribute("aria-labelledby", "<aria-labelledby_value>");
<Element>.setAttribute("aria-level", "<aria-level_value>");
<Element>.setAttribute("aria-multiline", "<aria-live_value>");
<Element>.setAttribute("aria-multiline", "<aria-multiline_value>");
<Element>.setAttribute("aria-multiselectable", "<aria-multiselectable_value>");
<Element>.setAttribute("aria-name", "<aria-name_value>");
<Element>.setAttribute("aria-orientation", "<aria-orientation_value>");
<Element>.setAttribute("aria-owns", "<aria-owns_value>");
<Element>.setAttribute("aria-posinset", "<aria-posinset_value>");
<Element>.setAttribute("aria-pressed", "<aria-pressed_value>");
<Element>.setAttribute("aria-readonly", "<aria-readonly_value>");
<Element>.setAttribute("aria-relevant", "<aria-relevant_value>");
<Element>.setAttribute("aria-required", "<aria-required_value>");
<Element>.setAttribute("aria-selected", "<aria-selected_value>");
<Element>.setAttribute("aria-setsize", "<aria-setsize_value>");
<Element>.setAttribute("aria-sort", "<aria-sort_value>");
<Element>.setAttribute("aria-valuemax", "<aria-valuemax_value>");
<Element>.setAttribute("aria-valuemin", "<aria-valuemin_value>");
<Element>.setAttribute("aria-valuenow", "<aria-valuenow_value>");
<Element>.setAttribute("aria-valuetext", "<aria-valuetext_value>");
<Element>.setAttribute("as", "<as_value>");
<Element>.setAttribute("async", "<async_value>");
<Element>.setAttribute("autocomplete", "<autocomplete_value>");
<Element>.setAttribute("autofocus", "<autofocus_value>");
<Element>.setAttribute("autoload", "<autoload_value>");
<Element>.setAttribute("autoplay", "<autoplay_value>");
<Element>.setAttribute("axis", "<axis_value>");
<Element>.setAttribute("azimuth", "<azimuth_value>");
<Element>.setAttribute("background", "<background_value>");
<Element>.setAttribute("background-color", "<background-color_value>");
<Element>.setAttribute("basefrequency", "<basefrequency_value>");
<Element>.setAttribute("baseprofile", "<baseprofile_value>");
<Element>.setAttribute("behavior", "<behavior_value>");
<Element>.setAttribute("bgcolor", "<bgcolor_value>");
<Element>.setAttribute("bgproperties", "<bgproperties_value>");
<Element>.setAttribute("border", "<border_value>");
<Element>.setAttribute("bordercolor", "<bordercolor_value>");
<Element>.setAttribute("buffered-rendering", "<buffered-rendering_value>");
<Element>.setAttribute("can-process-drag", "<can-process-drag_value>");
<Element>.setAttribute("case", "<case_value>");
<Element>.setAttribute("case", "<capture_value>");
<Element>.setAttribute("cellpadding", "<cellpadding_value>");
<Element>.setAttribute("cellspacing", "<cellspacing_value>");
<Element>.setAttribute("challenge", "<challenge_value>");
<Element>.setAttribute("char", "<char_value>");
<Element>.setAttribute("charoff", "<charoff_value>");
<Element>.setAttribute("charset", "<charset_value>");
<Element>.setAttribute("checked", "<checked_value>");
<Element>.setAttribute("cite", "<cite_value>");
<Element>.setAttribute("class", "<class_value>");
<Element>.setAttribute("classid", "<classid_value>");
<Element>.setAttribute("clear", "<clear_value>");
<Element>.setAttribute("code", "<code_value>");
<Element>.setAttribute("codebase", "<codebase_value>");
<Element>.setAttribute("codetype", "<codetype_value>");
<Element>.setAttribute("color", "<color_value>");
<Element>.setAttribute("cols", "<cols_value>");
<Element>.setAttribute("colspan", "<colspan_value>");
<Element>.setAttribute("compact", "<compact_value>");
<Element>.setAttribute("content", "<content_value>");
<Element>.setAttribute("contenteditable", "<contenteditable_value>");
<Element>.setAttribute("contextmenu", "<contextmenu_value>");
<Element>.setAttribute("controls", "<controls_value>");
<Element>.setAttribute("coords", "<coords_value>");
<Element>.setAttribute("crossorigin", "<crossorigin_value>");
<Element>.setAttribute("data", "<data_value>");
<Element>.setAttribute("datetime", "<datetime_value>");
<Element>.setAttribute("declare", "<declare_value>");
<Element>.setAttribute("default", "<default_value>");
<Element>.setAttribute("defer", "<defer_value>");
<Element>.setAttribute("desc", "<desc_value>");
<Element>.setAttribute("description", "<description_value>");
<Element>.setAttribute("dir", "<dir_value>");
<Element>.setAttribute("direction", "<direction_value>");
<Element>.setAttribute("dirname", "<dirname_value>");
<Element>.setAttribute("disabled", "<disabled_value>");
<Element>.setAttribute("display", "<display_value>");
<Element>.setAttribute("disposition", "<disposition_value>");
<Element>.setAttribute("download", "<download_value>");
<Element>.setAttribute("draggable", "<draggable_value>");
<Element>.setAttribute("encoding", "<encoding_value>");
<Element>.setAttribute("enctype", "<enctype_value>");
<Element>.setAttribute("expanded", "<expanded_value>");
<Element>.setAttribute("face", "<face_value>");
<Element>.setAttribute("focus", "<focus_value>");
<Element>.setAttribute("focused", "<focused_value>");
<Element>.setAttribute("for", "<for_value>");
<Element>.setAttribute("form", "<form_value>");
<Element>.setAttribute("formaction", "<formaction_value>");
<Element>.setAttribute("formenctype", "<formenctype_value>");
<Element>.setAttribute("formmethod", "<formmethod_value>");
<Element>.setAttribute("formnovalidate", "<formnovalidate_value>");
<Element>.setAttribute("formtarget", "<formtarget_value>");
<Element>.setAttribute("frame", "<frame_value>");
<Element>.setAttribute("frameborder", "<frameborder_value>");
<Element>.setAttribute("framemargin", "<framemargin_value>");
<Element>.setAttribute("framespacing", "<framespacing_value>");
<Element>.setAttribute("headers", "<headers_value>");
<Element>.setAttribute("height", "<height_value>");
<Element>.setAttribute("hidden", "<hidden_value>");
<Element>.setAttribute("high", "<high_value>");
<Element>.setAttribute("href", "<href_value>");
<Element>.setAttribute("hreflang", "<hreflang_value>");
<Element>.setAttribute("hspace", "<hspace_value>");
<Element>.setAttribute("http-equiv", "<http-equiv_value>");
<Element>.setAttribute("icon", "<icon_value>");
<Element>.setAttribute("incremental", "<incremental_value>");
<Element>.setAttribute("indeterminate", "<indeterminate_value>");
<Element>.setAttribute("inner", "<inner_value>");
<Element>.setAttribute("inputmode", "<inputmode_value>");
<Element>.setAttribute("is", "<is_value>");
<Element>.setAttribute("ismap", "<ismap_value>");
<Element>.setAttribute("item", "<item_value>");
<Element>.setAttribute("itemid", "<itemid_value>");
<Element>.setAttribute("itemprop", "<itemprop_value>");
<Element>.setAttribute("itemref", "<itemref_value>");
<Element>.setAttribute("itemscope", "<itemscope_value>");
<Element>.setAttribute("itemtype", "<itemtype_value>");
<Element>.setAttribute("keytype", "<keytype_value>");
<Element>.setAttribute("kind", "<kind_value>");
<Element>.setAttribute("label", "<label_value>");
<Element>.setAttribute("lang", "<lang_value>");
<Element>.setAttribute("language", "<language_value>");
<Element>.setAttribute("layout", "<layout_value>");
<Element>.setAttribute("left", "<left_value>");
<Element>.setAttribute("leftmargin", "<leftmargin_value>");
<Element>.setAttribute("link", "<link_value>");
<Element>.setAttribute("list", "<list_value>");
<Element>.setAttribute("longdesc", "<longdesc_value>");
<Element>.setAttribute("loop", "<loop_value>");
<Element>.setAttribute("loopend", "<loopend_value>");
<Element>.setAttribute("loopstart", "<loopstart_value>");
<Element>.setAttribute("low", "<low_value>");
<Element>.setAttribute("lowsrc", "<lowsrc_value>");
<Element>.setAttribute("manifest", "<manifest_value>");
<Element>.setAttribute("margin", "<margin_value>");
<Element>.setAttribute("marginheight", "<marginheight_value>");
<Element>.setAttribute("marginwidth", "<marginwidth_value>");
<Element>.setAttribute("max", "<max_value>");
<Element>.setAttribute("maxlength", "<maxlength_value>");
<Element>.setAttribute("mayscript", "<mayscript_value>");
<Element>.setAttribute("media", "<media_value>");
<Element>.setAttribute("menu", "<menu_value>");
<Element>.setAttribute("method", "<method_value>");
<Element>.setAttribute("min", "<min_value>");
<Element>.setAttribute("minlength", "<minlength_value>");
<Element>.setAttribute("mode", "<mode_value>");
<Element>.setAttribute("multiple", "<multiple_value>");
<Element>.setAttribute("muted", "<muted_value>");
<Element>.setAttribute("name", "<name_value>");
<Element>.setAttribute("nohref", "<nohref_value>");
<Element>.setAttribute("nonce", "<nonce_value>");
<Element>.setAttribute("noresize", "<noresize_value>");
<Element>.setAttribute("noshade", "<noshade_value>");
<Element>.setAttribute("novalidate", "<novalidate_value>");
<Element>.setAttribute("nowrap", "<nowrap_value>");
<Element>.setAttribute("open", "<open_value>");
<Element>.setAttribute("optimum", "<optimum_value>");
<Element>.setAttribute("pattern", "<pattern_value>");
<Element>.setAttribute("ping", "<ping_value>");
<Element>.setAttribute("placeholder", "<placeholder_value>");
<Element>.setAttribute("playcount", "<playcount_value>");
<Element>.setAttribute("pluginspage", "<pluginspage_value>");
<Element>.setAttribute("poster", "<poster_value>");
<Element>.setAttribute("preload", "<preload_value>");
<Element>.setAttribute("profile", "<profile_value>");
<Element>.setAttribute("prompt", "<prompt_value>");
<Element>.setAttribute("quality", "<quality_value>");
<Element>.setAttribute("radiogroup", "<radiogroup_value>");
<Element>.setAttribute("readonly", "<readonly_value>");
<Element>.setAttribute("ref", "<ref_value>");
<Element>.setAttribute("referrerpolicy", "<referrerpolicy_value>");
<Element>.setAttribute("rel", "<rel_value>");
<Element>.setAttribute("required", "<required_value>");
<Element>.setAttribute("results", "<results_value>");
<Element>.setAttribute("rev", "<rev_value>");
<Element>.setAttribute("reversed", "<reversed_value>");
<Element>.setAttribute("right", "<right_value>");
<Element>.setAttribute("rightmargin", "<rightmargin_value>");
<Element>.setAttribute("role", "<role_value>");
<Element>.setAttribute("row", "<row_value>");
<Element>.setAttribute("rows", "<rows_value>");
<Element>.setAttribute("rowspan", "<rowspan_value>");
<Element>.setAttribute("rules", "<rules_value>");
<Element>.setAttribute("sandbox", "<sandbox_value>");
<Element>.setAttribute("scheme", "<scheme_value>");
<Element>.setAttribute("scope", "<scope_value>");
<Element>.setAttribute("scoped", "<scoped_value>");
<Element>.setAttribute("scrollamount", "<scrollamount_value>");
<Element>.setAttribute("scrolldelay", "<scrolldelay_value>");
<Element>.setAttribute("scrolling", "<scrolling_value>");
<Element>.setAttribute("seamless", "<seamless_value>");
<Element>.setAttribute("seed", "<seed_value>");
<Element>.setAttribute("select", "<select_value>");
<Element>.setAttribute("selected", "<selected_value>");
<Element>.setAttribute("shape", "<shape_value>");
<Element>.setAttribute("shouldfocus", "<shouldfocus_value>");
<Element>.setAttribute("size", "<size_value>");
<Element>.setAttribute("sizes", "<sizes_value>");
<Element>.setAttribute("slope", "<slope_value>");
<Element>.setAttribute("slot", "<slot_value>");
<Element>.setAttribute("span", "<span_value>");
<Element>.setAttribute("spellcheck", "<spellcheck_value>");
<Element>.setAttribute("src", "<src_value>");
<Element>.setAttribute("srcdoc", "<srcdoc_value>");
<Element>.setAttribute("srcset", "<srcset_value>");
<Element>.setAttribute("srclang", "<srclang_value>");
<Element>.setAttribute("standby", "<standby_value>");
<Element>.setAttribute("start", "<start_value>");
<Element>.setAttribute("startoffset", "<startoffset_value>");
<Element>.setAttribute("startval", "<startval_value>");
<Element>.setAttribute("step", "<step_value>");
<Element>.setAttribute("style", "<import from=cssgrammar symbol=declaration5>");
<Element>.setAttribute("summary", "<summary_value>");
<Element>.setAttribute("tabindex", "<tabindex_value>");
<Element>.setAttribute("target", "<target_value>");
<Element>.setAttribute("text", "<text_value>");
<Element>.setAttribute("title", "<title_value>");
<Element>.setAttribute("topmargin", "<topmargin_value>");
<Element>.setAttribute("translate", "<translate_value>");
<Element>.setAttribute("truespeed", "<truespeed_value>");
<Element>.setAttribute("type", "<type_value>");
<Element>.setAttribute("usemap", "<usemap_value>");
<Element>.setAttribute("valign", "<valign_value>");
<Element>.setAttribute("value", "<value_value>");
<Element>.setAttribute("valuetype", "<valuetype_value>");
<Element>.setAttribute("version", "<version_value>");
<Element>.setAttribute("vlink", "<vlink_value>");
<Element>.setAttribute("vspace", "<vspace_value>");
<Element>.setAttribute("width", "<width_value>");
<Element>.setAttribute("wrap", "<wrap_value>");
<Element>.setAttribute("onabort", "<eventhandlerstr>");
<Element>.setAttribute("onautocomplete", "<eventhandlerstr>");
<Element>.setAttribute("onautocompleteerror", "<eventhandlerstr>");
<Element>.setAttribute("onafterscriptexecute", "<eventhandlerstr>");
<Element>.setAttribute("onanimationend", "<eventhandlerstr>");
<Element>.setAttribute("onanimationiteration", "<eventhandlerstr>");
<Element>.setAttribute("onanimationstart", "<eventhandlerstr>");
<Element>.setAttribute("onbeforecopy", "<eventhandlerstr>");
<Element>.setAttribute("onbeforecut", "<eventhandlerstr>");
<Element>.setAttribute("onbeforeload", "<eventhandlerstr>");
<Element>.setAttribute("onbeforepaste", "<eventhandlerstr>");
<Element>.setAttribute("onbeforescriptexecute", "<eventhandlerstr>");
<Element>.setAttribute("onbeforeunload", "<eventhandlerstr>");
<Element>.setAttribute("onbegin", "<eventhandlerstr>");
<Element>.setAttribute("onblur", "<eventhandlerstr>");
<Element>.setAttribute("oncanplay", "<eventhandlerstr>");
<Element>.setAttribute("oncanplaythrough", "<eventhandlerstr>");
<Element>.setAttribute("onchange", "<eventhandlerstr>");
<Element>.setAttribute("onclick", "<eventhandlerstr>");
<Element>.setAttribute("oncontextmenu", "<eventhandlerstr>");
<Element>.setAttribute("oncopy", "<eventhandlerstr>");
<Element>.setAttribute("oncut", "<eventhandlerstr>");
<Element>.setAttribute("ondblclick", "<eventhandlerstr>");
<Element>.setAttribute("ondrag", "<eventhandlerstr>");
<Element>.setAttribute("ondragend", "<eventhandlerstr>");
<Element>.setAttribute("ondragenter", "<eventhandlerstr>");
<Element>.setAttribute("ondragleave", "<eventhandlerstr>");
<Element>.setAttribute("ondragover", "<eventhandlerstr>");
<Element>.setAttribute("ondragstart", "<eventhandlerstr>");
<Element>.setAttribute("ondrop", "<eventhandlerstr>");
<Element>.setAttribute("ondurationchange", "<eventhandlerstr>");
<Element>.setAttribute("onend", "<eventhandlerstr>");
<Element>.setAttribute("onemptied", "<eventhandlerstr>");
<Element>.setAttribute("onended", "<eventhandlerstr>");
<Element>.setAttribute("onerror", "<eventhandlerstr>");
<Element>.setAttribute("onfocus", "<eventhandlerstr>");
<Element>.setAttribute("onfocusin", "<eventhandlerstr>");
<Element>.setAttribute("onfocusout", "<eventhandlerstr>");
<Element>.setAttribute("onhashchange", "<eventhandlerstr>");
<Element>.setAttribute("oninput", "<eventhandlerstr>");
<Element>.setAttribute("oninvalid", "<eventhandlerstr>");
<Element>.setAttribute("onkeydown", "<eventhandlerstr>");
<Element>.setAttribute("onkeypress", "<eventhandlerstr>");
<Element>.setAttribute("onkeyup", "<eventhandlerstr>");
<Element>.setAttribute("onload", "<eventhandlerstr>");
<Element>.setAttribute("onloadeddata", "<eventhandlerstr>");
<Element>.setAttribute("onloadedmetadata", "<eventhandlerstr>");
<Element>.setAttribute("onloadstart", "<eventhandlerstr>");
<Element>.setAttribute("onmessage", "<eventhandlerstr>");
<Element>.setAttribute("onmousedown", "<eventhandlerstr>");
<Element>.setAttribute("onmouseenter", "<eventhandlerstr>");
<Element>.setAttribute("onmouseleave", "<eventhandlerstr>");
<Element>.setAttribute("onmousemove", "<eventhandlerstr>");
<Element>.setAttribute("onmouseout", "<eventhandlerstr>");
<Element>.setAttribute("onmouseover", "<eventhandlerstr>");
<Element>.setAttribute("onmouseup", "<eventhandlerstr>");
<Element>.setAttribute("onmousewheel", "<eventhandlerstr>");
<Element>.setAttribute("onoffline", "<eventhandlerstr>");
<Element>.setAttribute("ononline", "<eventhandlerstr>");
<Element>.setAttribute("onorientationchange", "<eventhandlerstr>");
<Element>.setAttribute("onpagehide", "<eventhandlerstr>");
<Element>.setAttribute("onpageshow", "<eventhandlerstr>");
<Element>.setAttribute("onpaste", "<eventhandlerstr>");
<Element>.setAttribute("onpause", "<eventhandlerstr>");
<Element>.setAttribute("onplay", "<eventhandlerstr>");
<Element>.setAttribute("onplaying", "<eventhandlerstr>");
<Element>.setAttribute("onpopstate", "<eventhandlerstr>");
<Element>.setAttribute("onprogress", "<eventhandlerstr>");
<Element>.setAttribute("onratechange", "<eventhandlerstr>");
<Element>.setAttribute("onreset", "<eventhandlerstr>");
<Element>.setAttribute("onresize", "<eventhandlerstr>");
<Element>.setAttribute("onscroll", "<eventhandlerstr>");
<Element>.setAttribute("onsearch", "<eventhandlerstr>");
<Element>.setAttribute("onseeked", "<eventhandlerstr>");
<Element>.setAttribute("onseeking", "<eventhandlerstr>");
<Element>.setAttribute("onselect", "<eventhandlerstr>");
<Element>.setAttribute("onselectionchange", "<eventhandlerstr>");
<Element>.setAttribute("onselectstart", "<eventhandlerstr>");
<Element>.setAttribute("onstalled", "<eventhandlerstr>");
<Element>.setAttribute("onstorage", "<eventhandlerstr>");
<Element>.setAttribute("onsubmit", "<eventhandlerstr>");
<Element>.setAttribute("onsuspend", "<eventhandlerstr>");
<Element>.setAttribute("ontimeupdate", "<eventhandlerstr>");
<Element>.setAttribute("ontoggle", "<eventhandlerstr>");
<Element>.setAttribute("ontouchcancel", "<eventhandlerstr>");
<Element>.setAttribute("ontouchend", "<eventhandlerstr>");
<Element>.setAttribute("ontouchmove", "<eventhandlerstr>");
<Element>.setAttribute("ontouchstart", "<eventhandlerstr>");
<Element>.setAttribute("ontransitionend", "<eventhandlerstr>");
<Element>.setAttribute("onunload", "<eventhandlerstr>");
<Element>.setAttribute("onvolumechange", "<eventhandlerstr>");
<Element>.setAttribute("onwaiting", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitanimationend", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitanimationiteration", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitanimationstart", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitfullscreenchange", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitfullscreenerror", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitkeyadded", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitkeyerror", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitkeymessage", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitneedkey", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitsourceclose", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitsourceended", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitsourceopen", "<eventhandlerstr>");
<Element>.setAttribute("onwebkitspeechchange", "<eventhandlerstr>");
<Element>.setAttribute("onwebkittransitionend", "<eventhandlerstr>");
<Element>.setAttribute("onwheel", "<eventhandlerstr>");



<CSSStyleDeclaration>.setProperty("-ms-flex-align", "<cssproperty_-ms-flex-align>");
<CSSStyleDeclaration>.setProperty("-ms-font-feature-settings", "<cssproperty_-ms-font-feature-settings>");
<CSSStyleDeclaration>.setProperty("-ms-text-combine-horizontal", "<cssproperty_-ms-text-combine-horizontal>");
<CSSStyleDeclaration>.setProperty("-ms-user-select", "<cssproperty_-ms-user-select>");
<CSSStyleDeclaration>.setProperty("-webkit-align-content", "<cssproperty_-webkit-align-content>");
<CSSStyleDeclaration>.setProperty("-webkit-align-items", "<cssproperty_-webkit-align-items>");
<CSSStyleDeclaration>.setProperty("-webkit-align-self", "<cssproperty_-webkit-align-self>");
<CSSStyleDeclaration>.setProperty("-webkit-animation", "<cssproperty_-webkit-animation>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-delay", "<cssproperty_-webkit-animation-delay>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-direction", "<cssproperty_-webkit-animation-direction>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-duration", "<cssproperty_-webkit-animation-duration>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-fill-mode", "<cssproperty_-webkit-animation-fill-mode>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-iteration-count", "<cssproperty_-webkit-animation-iteration-count>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-name", "<cssproperty_-webkit-animation-name>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-play-state", "<cssproperty_-webkit-animation-play-state>");
<CSSStyleDeclaration>.setProperty("-webkit-animation-timing-function", "<cssproperty_-webkit-animation-timing-function>");
<CSSStyleDeclaration>.setProperty("-webkit-app-region", "<cssproperty_-webkit-app-region>");
<CSSStyleDeclaration>.setProperty("-webkit-appearance", "<cssproperty_-webkit-appearance>");
<CSSStyleDeclaration>.setProperty("-webkit-backface-visibility", "<cssproperty_-webkit-backface-visibility>");
<CSSStyleDeclaration>.setProperty("-webkit-background-clip", "<cssproperty_-webkit-background-clip>");
<CSSStyleDeclaration>.setProperty("-webkit-background-origin", "<cssproperty_-webkit-background-origin>");
<CSSStyleDeclaration>.setProperty("-webkit-background-size", "<cssproperty_-webkit-background-size>");
<CSSStyleDeclaration>.setProperty("-webkit-border-after", "<cssproperty_-webkit-border-after>");
<CSSStyleDeclaration>.setProperty("-webkit-border-after-color", "<cssproperty_-webkit-border-after-color>");
<CSSStyleDeclaration>.setProperty("-webkit-border-after-width", "<cssproperty_-webkit-border-after-width>");
<CSSStyleDeclaration>.setProperty("-webkit-border-before", "<cssproperty_-webkit-border-before>");
<CSSStyleDeclaration>.setProperty("-webkit-border-before-color", "<cssproperty_-webkit-border-before-color>");
<CSSStyleDeclaration>.setProperty("-webkit-border-before-style", "<cssproperty_-webkit-border-before-style>");
<CSSStyleDeclaration>.setProperty("-webkit-border-before-width", "<cssproperty_-webkit-border-before-width>");
<CSSStyleDeclaration>.setProperty("-webkit-border-bottom-left-radius", "<cssproperty_-webkit-border-bottom-left-radius>");
<CSSStyleDeclaration>.setProperty("-webkit-border-bottom-right-radius", "<cssproperty_-webkit-border-bottom-right-radius>");
<CSSStyleDeclaration>.setProperty("-webkit-border-end", "<cssproperty_-webkit-border-end>");
<CSSStyleDeclaration>.setProperty("-webkit-border-end-color", "<cssproperty_-webkit-border-end-color>");
<CSSStyleDeclaration>.setProperty("-webkit-border-end-width", "<cssproperty_-webkit-border-end-width>");
<CSSStyleDeclaration>.setProperty("-webkit-border-image", "<cssproperty_-webkit-border-image>");
<CSSStyleDeclaration>.setProperty("-webkit-border-radius", "<cssproperty_-webkit-border-radius>");
<CSSStyleDeclaration>.setProperty("-webkit-border-start", "<cssproperty_-webkit-border-start>");
<CSSStyleDeclaration>.setProperty("-webkit-border-start-color", "<cssproperty_-webkit-border-start-color>");
<CSSStyleDeclaration>.setProperty("-webkit-border-start-width", "<cssproperty_-webkit-border-start-width>");
<CSSStyleDeclaration>.setProperty("-webkit-border-top-left-radius", "<cssproperty_-webkit-border-top-left-radius>");
<CSSStyleDeclaration>.setProperty("-webkit-border-top-right-radius", "<cssproperty_-webkit-border-top-right-radius>");
<CSSStyleDeclaration>.setProperty("-webkit-border-vertical-spacing", "<cssproperty_-webkit-border-vertical-spacing>");
<CSSStyleDeclaration>.setProperty("-webkit-box-align", "<cssproperty_-webkit-box-align>");
<CSSStyleDeclaration>.setProperty("-webkit-box-decoration-break", "<cssproperty_-webkit-box-decoration-break>");
<CSSStyleDeclaration>.setProperty("-webkit-box-direction", "<cssproperty_-webkit-box-direction>");
<CSSStyleDeclaration>.setProperty("-webkit-box-flex", "<cssproperty_-webkit-box-flex>");
<CSSStyleDeclaration>.setProperty("-webkit-box-flex-group", "<cssproperty_-webkit-box-flex-group>");
<CSSStyleDeclaration>.setProperty("-webkit-box-lines", "<cssproperty_-webkit-box-lines>");
<CSSStyleDeclaration>.setProperty("-webkit-box-ordinal-group", "<cssproperty_-webkit-box-ordinal-group>");
<CSSStyleDeclaration>.setProperty("-webkit-box-orient", "<cssproperty_-webkit-box-orient>");
<CSSStyleDeclaration>.setProperty("-webkit-box-pack", "<cssproperty_-webkit-box-pack>");
<CSSStyleDeclaration>.setProperty("-webkit-box-reflect", "<cssproperty_-webkit-box-reflect>");
<CSSStyleDeclaration>.setProperty("-webkit-box-shadow", "<cssproperty_-webkit-box-shadow>");
<CSSStyleDeclaration>.setProperty("-webkit-box-sizing", "<cssproperty_-webkit-box-sizing>");
<CSSStyleDeclaration>.setProperty("-webkit-clip-path", "<cssproperty_-webkit-clip-path>");
<CSSStyleDeclaration>.setProperty("-webkit-color-correction", "<cssproperty_-webkit-color-correction>");
<CSSStyleDeclaration>.setProperty("-webkit-column-break-after", "<cssproperty_-webkit-column-break-after>");
<CSSStyleDeclaration>.setProperty("-webkit-column-break-before", "<cssproperty_-webkit-column-break-before>");
<CSSStyleDeclaration>.setProperty("-webkit-column-break-inside", "<cssproperty_-webkit-column-break-inside>");
<CSSStyleDeclaration>.setProperty("-webkit-column-count", "<cssproperty_-webkit-column-count>");
<CSSStyleDeclaration>.setProperty("-webkit-column-fill", "<cssproperty_-webkit-column-fill>");
<CSSStyleDeclaration>.setProperty("-webkit-column-gap", "<cssproperty_-webkit-column-gap>");
<CSSStyleDeclaration>.setProperty("-webkit-column-rule", "<cssproperty_-webkit-column-rule>");
<CSSStyleDeclaration>.setProperty("-webkit-column-rule-color", "<cssproperty_-webkit-column-rule-color>");
<CSSStyleDeclaration>.setProperty("-webkit-column-rule-style", "<cssproperty_-webkit-column-rule-style>");
<CSSStyleDeclaration>.setProperty("-webkit-column-rule-width", "<cssproperty_-webkit-column-rule-width>");
<CSSStyleDeclaration>.setProperty("-webkit-column-span", "<cssproperty_-webkit-column-span>");
<CSSStyleDeclaration>.setProperty("-webkit-column-width", "<cssproperty_-webkit-column-width>");
<CSSStyleDeclaration>.setProperty("-webkit-columns", "<cssproperty_-webkit-columns>");
<CSSStyleDeclaration>.setProperty("-webkit-direction", "<cssproperty_-webkit-direction>");
<CSSStyleDeclaration>.setProperty("-webkit-filter", "<cssproperty_-webkit-filter>");
<CSSStyleDeclaration>.setProperty("-webkit-flex", "<cssproperty_-webkit-flex>");
<CSSStyleDeclaration>.setProperty("-webkit-flex-direction", "<cssproperty_-webkit-flex-direction>");
<CSSStyleDeclaration>.setProperty("-webkit-flex-wrap", "<cssproperty_-webkit-flex-wrap>");
<CSSStyleDeclaration>.setProperty("-webkit-flow-from", "<cssproperty_-webkit-flow-from>");
<CSSStyleDeclaration>.setProperty("-webkit-flow-into", "<cssproperty_-webkit-flow-into>");
<CSSStyleDeclaration>.setProperty("-webkit-font-feature-settings", "<cssproperty_-webkit-font-feature-settings>");
<CSSStyleDeclaration>.setProperty("-webkit-font-smoothing", "<cssproperty_-webkit-font-smoothing>");
<CSSStyleDeclaration>.setProperty("-webkit-highlight", "<cssproperty_-webkit-highlight>");
<CSSStyleDeclaration>.setProperty("-webkit-hyphenate-character", "<cssproperty_-webkit-hyphenate-character>");
<CSSStyleDeclaration>.setProperty("-webkit-hyphens", "<cssproperty_-webkit-hyphens>");
<CSSStyleDeclaration>.setProperty("-webkit-justify-content", "<cssproperty_-webkit-justify-content>");
<CSSStyleDeclaration>.setProperty("-webkit-line-break", "<cssproperty_-webkit-line-break>");
<CSSStyleDeclaration>.setProperty("-webkit-line-clamp", "<cssproperty_-webkit-line-clamp>");
<CSSStyleDeclaration>.setProperty("-webkit-locale", "<cssproperty_-webkit-locale>");
<CSSStyleDeclaration>.setProperty("-webkit-logical-height", "<cssproperty_-webkit-logical-height>");
<CSSStyleDeclaration>.setProperty("-webkit-logical-width", "<cssproperty_-webkit-logical-width>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-after", "<cssproperty_-webkit-margin-after>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-after-collapse", "<cssproperty_-webkit-margin-after-collapse>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-before", "<cssproperty_-webkit-margin-before>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-before-collapse", "<cssproperty_-webkit-margin-before-collapse>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-bottom-collapse", "<cssproperty_-webkit-margin-bottom-collapse>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-collapse", "<cssproperty_-webkit-margin-collapse>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-end", "<cssproperty_-webkit-margin-end>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-start", "<cssproperty_-webkit-margin-start>");
<CSSStyleDeclaration>.setProperty("-webkit-margin-top-collapse", "<cssproperty_-webkit-margin-top-collapse>");
<CSSStyleDeclaration>.setProperty("-webkit-marquee-speed", "<cssproperty_-webkit-marquee-speed>");
<CSSStyleDeclaration>.setProperty("-webkit-mask", "<cssproperty_-webkit-mask>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-box-image", "<cssproperty_-webkit-mask-box-image>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-box-image-outset", "<cssproperty_-webkit-mask-box-image-outset>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-box-image-repeat", "<cssproperty_-webkit-mask-box-image-repeat>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-box-image-slice", "<cssproperty_-webkit-mask-box-image-slice>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-box-image-source", "<cssproperty_-webkit-mask-box-image-source>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-box-image-width", "<cssproperty_-webkit-mask-box-image-width>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-clip", "<cssproperty_-webkit-mask-clip>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-composite", "<cssproperty_-webkit-mask-composite>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-image", "<cssproperty_-webkit-mask-image>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-origin", "<cssproperty_-webkit-mask-origin>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-position", "<cssproperty_-webkit-mask-position>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-repeat", "<cssproperty_-webkit-mask-repeat>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-repeat-y", "<cssproperty_-webkit-mask-repeat-y>");
<CSSStyleDeclaration>.setProperty("-webkit-mask-size", "<cssproperty_-webkit-mask-size>");
<CSSStyleDeclaration>.setProperty("-webkit-min-logical-height", "<cssproperty_-webkit-min-logical-height>");
<CSSStyleDeclaration>.setProperty("-webkit-nbsp-mode", "<cssproperty_-webkit-nbsp-mode>");
<CSSStyleDeclaration>.setProperty("-webkit-opacity", "<cssproperty_-webkit-opacity>");
<CSSStyleDeclaration>.setProperty("-webkit-overflow-scrolling", "<cssproperty_-webkit-overflow-scrolling>");
<CSSStyleDeclaration>.setProperty("-webkit-padding-after", "<cssproperty_-webkit-padding-after>");
<CSSStyleDeclaration>.setProperty("-webkit-padding-before", "<cssproperty_-webkit-padding-before>");
<CSSStyleDeclaration>.setProperty("-webkit-padding-end", "<cssproperty_-webkit-padding-end>");
<CSSStyleDeclaration>.setProperty("-webkit-padding-start", "<cssproperty_-webkit-padding-start>");
<CSSStyleDeclaration>.setProperty("-webkit-perspective", "<cssproperty_-webkit-perspective>");
<CSSStyleDeclaration>.setProperty("-webkit-perspective-origin", "<cssproperty_-webkit-perspective-origin>");
<CSSStyleDeclaration>.setProperty("-webkit-perspective-origin-x", "<cssproperty_-webkit-perspective-origin-x>");
<CSSStyleDeclaration>.setProperty("-webkit-perspective-origin-y", "<cssproperty_-webkit-perspective-origin-y>");
<CSSStyleDeclaration>.setProperty("-webkit-print-color-adjust", "<cssproperty_-webkit-print-color-adjust>");
<CSSStyleDeclaration>.setProperty("-webkit-rtl-ordering", "<cssproperty_-webkit-rtl-ordering>");
<CSSStyleDeclaration>.setProperty("-webkit-ruby-position", "<cssproperty_-webkit-ruby-position>");
<CSSStyleDeclaration>.setProperty("-webkit-shape-margin", "<cssproperty_-webkit-shape-margin>");
<CSSStyleDeclaration>.setProperty("-webkit-shape-outside", "<cssproperty_-webkit-shape-outside>");
<CSSStyleDeclaration>.setProperty("-webkit-tap-highlight-color", "<cssproperty_-webkit-tap-highlight-color>");
<CSSStyleDeclaration>.setProperty("-webkit-text-combine", "<cssproperty_-webkit-text-combine>");
<CSSStyleDeclaration>.setProperty("-webkit-text-decorations-in-effect", "<cssproperty_-webkit-text-decorations-in-effect>");
<CSSStyleDeclaration>.setProperty("-webkit-text-emphasis", "<cssproperty_-webkit-text-emphasis>");
<CSSStyleDeclaration>.setProperty("-webkit-text-emphasis-color", "<cssproperty_-webkit-text-emphasis-color>");
<CSSStyleDeclaration>.setProperty("-webkit-text-emphasis-position", "<cssproperty_-webkit-text-emphasis-position>");
<CSSStyleDeclaration>.setProperty("-webkit-text-emphasis-style", "<cssproperty_-webkit-text-emphasis-style>");
<CSSStyleDeclaration>.setProperty("-webkit-text-fill-color", "<cssproperty_-webkit-text-fill-color>");
<CSSStyleDeclaration>.setProperty("-webkit-text-orientation", "<cssproperty_-webkit-text-orientation>");
<CSSStyleDeclaration>.setProperty("-webkit-text-security", "<cssproperty_-webkit-text-security>");
<CSSStyleDeclaration>.setProperty("-webkit-text-stroke", "<cssproperty_-webkit-text-stroke>");
<CSSStyleDeclaration>.setProperty("-webkit-text-stroke-color", "<cssproperty_-webkit-text-stroke-color>");
<CSSStyleDeclaration>.setProperty("-webkit-text-stroke-width", "<cssproperty_-webkit-text-stroke-width>");
<CSSStyleDeclaration>.setProperty("-webkit-transform", "<cssproperty_-webkit-transform>");
<CSSStyleDeclaration>.setProperty("-webkit-transform-origin", "<cssproperty_-webkit-transform-origin>");
<CSSStyleDeclaration>.setProperty("-webkit-transform-style", "<cssproperty_-webkit-transform-style>");
<CSSStyleDeclaration>.setProperty("-webkit-transition", "<cssproperty_-webkit-transition>");
<CSSStyleDeclaration>.setProperty("-webkit-transition-delay", "<cssproperty_-webkit-transition-delay>");
<CSSStyleDeclaration>.setProperty("-webkit-transition-duration", "<cssproperty_-webkit-transition-duration>");
<CSSStyleDeclaration>.setProperty("-webkit-transition-property", "<cssproperty_-webkit-transition-property>");
<CSSStyleDeclaration>.setProperty("-webkit-transition-timing-function", "<cssproperty_-webkit-transition-timing-function>");
<CSSStyleDeclaration>.setProperty("-webkit-user-drag", "<cssproperty_-webkit-user-drag>");
<CSSStyleDeclaration>.setProperty("-webkit-user-modify", "<cssproperty_-webkit-user-modify>");
<CSSStyleDeclaration>.setProperty("-webkit-user-select", "<cssproperty_-webkit-user-select>");
<CSSStyleDeclaration>.setProperty("-webkit-wrap-flow", "<cssproperty_-webkit-wrap-flow>");
<CSSStyleDeclaration>.setProperty("-webkit-writing-mode", "<cssproperty_-webkit-writing-mode>");
<CSSStyleDeclaration>.setProperty("align-content", "<cssproperty_align-content>");
<CSSStyleDeclaration>.setProperty("align-items", "<cssproperty_align-items>");
<CSSStyleDeclaration>.setProperty("align-self", "<cssproperty_align-self>");
<CSSStyleDeclaration>.setProperty("alignx", "<cssproperty_alignx>");
<CSSStyleDeclaration>.setProperty("animation", "<cssproperty_animation>");
<CSSStyleDeclaration>.setProperty("animation-delay", "<cssproperty_animation-delay>");
<CSSStyleDeclaration>.setProperty("animation-direction", "<cssproperty_animation-direction>");
<CSSStyleDeclaration>.setProperty("animation-duration", "<cssproperty_animation-duration>");
<CSSStyleDeclaration>.setProperty("animation-fill-mode", "<cssproperty_animation-fill-mode>");
<CSSStyleDeclaration>.setProperty("animation-iteration-count", "<cssproperty_animation-iteration-count>");
<CSSStyleDeclaration>.setProperty("animation-name", "<cssproperty_animation-name>");
<CSSStyleDeclaration>.setProperty("animation-play-state", "<cssproperty_animation-play-state>");
<CSSStyleDeclaration>.setProperty("animation-timing-function", "<cssproperty_animation-timing-function>");
<CSSStyleDeclaration>.setProperty("backdrop-filter", "<cssproperty_backdrop-filter>");
<CSSStyleDeclaration>.setProperty("backface-visibility", "<cssproperty_backface-visibility>");
<CSSStyleDeclaration>.setProperty("background", "<cssproperty_background>");
<CSSStyleDeclaration>.setProperty("background-attachment", "<cssproperty_background-attachment>");
<CSSStyleDeclaration>.setProperty("background-blend-mode", "<cssproperty_background-blend-mode>");
<CSSStyleDeclaration>.setProperty("background-clip", "<cssproperty_background-clip>");
<CSSStyleDeclaration>.setProperty("background-color", "<cssproperty_background-color>");
<CSSStyleDeclaration>.setProperty("background-image", "<cssproperty_background-image>");
<CSSStyleDeclaration>.setProperty("background-origin", "<cssproperty_background-origin>");
<CSSStyleDeclaration>.setProperty("background-position", "<cssproperty_background-position>");
<CSSStyleDeclaration>.setProperty("background-position-x", "<cssproperty_background-position-x>");
<CSSStyleDeclaration>.setProperty("background-repeat", "<cssproperty_background-repeat>");
<CSSStyleDeclaration>.setProperty("background-repeat-x", "<cssproperty_background-repeat-x>");
<CSSStyleDeclaration>.setProperty("background-repeat-y", "<cssproperty_background-repeat-y>");
<CSSStyleDeclaration>.setProperty("background-size", "<cssproperty_background-size>");
<CSSStyleDeclaration>.setProperty("baseline-shift", "<cssproperty_baseline-shift>");
<CSSStyleDeclaration>.setProperty("border", "<cssproperty_border>");
<CSSStyleDeclaration>.setProperty("border-bottom", "<cssproperty_border-bottom>");
<CSSStyleDeclaration>.setProperty("border-bottom-color", "<cssproperty_border-bottom-color>");
<CSSStyleDeclaration>.setProperty("border-bottom-left-radius", "<cssproperty_border-bottom-left-radius>");
<CSSStyleDeclaration>.setProperty("border-bottom-right-radius", "<cssproperty_border-bottom-right-radius>");
<CSSStyleDeclaration>.setProperty("border-bottom-style", "<cssproperty_border-bottom-style>");
<CSSStyleDeclaration>.setProperty("border-bottom-width", "<cssproperty_border-bottom-width>");
<CSSStyleDeclaration>.setProperty("border-collapse", "<cssproperty_border-collapse>");
<CSSStyleDeclaration>.setProperty("border-color", "<cssproperty_border-color>");
<CSSStyleDeclaration>.setProperty("border-image", "<cssproperty_border-image>");
<CSSStyleDeclaration>.setProperty("border-image-outset", "<cssproperty_border-image-outset>");
<CSSStyleDeclaration>.setProperty("border-image-repeat", "<cssproperty_border-image-repeat>");
<CSSStyleDeclaration>.setProperty("border-image-slice", "<cssproperty_border-image-slice>");
<CSSStyleDeclaration>.setProperty("border-image-source", "<cssproperty_border-image-source>");
<CSSStyleDeclaration>.setProperty("border-image-width", "<cssproperty_border-image-width>");
<CSSStyleDeclaration>.setProperty("border-left", "<cssproperty_border-left>");
<CSSStyleDeclaration>.setProperty("border-left-color", "<cssproperty_border-left-color>");
<CSSStyleDeclaration>.setProperty("border-left-style", "<cssproperty_border-left-style>");
<CSSStyleDeclaration>.setProperty("border-left-width", "<cssproperty_border-left-width>");
<CSSStyleDeclaration>.setProperty("border-radius", "<cssproperty_border-radius>");
<CSSStyleDeclaration>.setProperty("border-right", "<cssproperty_border-right>");
<CSSStyleDeclaration>.setProperty("border-right-color", "<cssproperty_border-right-color>");
<CSSStyleDeclaration>.setProperty("border-right-style", "<cssproperty_border-right-style>");
<CSSStyleDeclaration>.setProperty("border-right-width", "<cssproperty_border-right-width>");
<CSSStyleDeclaration>.setProperty("border-size", "<cssproperty_border-size>");
<CSSStyleDeclaration>.setProperty("border-spacing", "<cssproperty_border-spacing>");
<CSSStyleDeclaration>.setProperty("border-style", "<cssproperty_border-style>");
<CSSStyleDeclaration>.setProperty("border-top", "<cssproperty_border-top>");
<CSSStyleDeclaration>.setProperty("border-top-color", "<cssproperty_border-top-color>");
<CSSStyleDeclaration>.setProperty("border-top-left-radius", "<cssproperty_border-top-left-radius>");
<CSSStyleDeclaration>.setProperty("border-top-right-radius", "<cssproperty_border-top-right-radius>");
<CSSStyleDeclaration>.setProperty("border-top-style", "<cssproperty_border-top-style>");
<CSSStyleDeclaration>.setProperty("border-top-width", "<cssproperty_border-top-width>");
<CSSStyleDeclaration>.setProperty("border-width", "<cssproperty_border-width>");
<CSSStyleDeclaration>.setProperty("bottom", "<cssproperty_bottom>");
<CSSStyleDeclaration>.setProperty("box-align", "<cssproperty_box-align>");
<CSSStyleDeclaration>.setProperty("box-decoration-break", "<cssproperty_box-decoration-break>");
<CSSStyleDeclaration>.setProperty("box-direction", "<cssproperty_box-direction>");
<CSSStyleDeclaration>.setProperty("box-flex", "<cssproperty_box-flex>");
<CSSStyleDeclaration>.setProperty("box-flex-group", "<cssproperty_box-flex-group>");
<CSSStyleDeclaration>.setProperty("box-ordinal-group", "<cssproperty_box-ordinal-group>");
<CSSStyleDeclaration>.setProperty("box-orient", "<cssproperty_box-orient>");
<CSSStyleDeclaration>.setProperty("box-pack", "<cssproperty_box-pack>");
<CSSStyleDeclaration>.setProperty("box-reflect", "<cssproperty_box-reflect>");
<CSSStyleDeclaration>.setProperty("box-shadow", "<cssproperty_box-shadow>");
<CSSStyleDeclaration>.setProperty("box-sizing", "<cssproperty_box-sizing>");
<CSSStyleDeclaration>.setProperty("break-after", "<cssproperty_break-after>");
<CSSStyleDeclaration>.setProperty("break-before", "<cssproperty_break-before>");
<CSSStyleDeclaration>.setProperty("break-inside", "<cssproperty_break-inside>");
<CSSStyleDeclaration>.setProperty("caption-side", "<cssproperty_caption-side>");
<CSSStyleDeclaration>.setProperty("cellpadding", "<cssproperty_cellpadding>");
<CSSStyleDeclaration>.setProperty("cellspacing", "<cssproperty_cellspacing>");
<CSSStyleDeclaration>.setProperty("clear", "<cssproperty_clear>");
<CSSStyleDeclaration>.setProperty("clip", "<cssproperty_clip>");
<CSSStyleDeclaration>.setProperty("clip-path", "<cssproperty_clip-path>");
<CSSStyleDeclaration>.setProperty("color", "<cssproperty_color>");
<CSSStyleDeclaration>.setProperty("color-interpolation-filters", "<cssproperty_color-interpolation-filters>");
<CSSStyleDeclaration>.setProperty("color-profile", "<cssproperty_color-profile>");
<CSSStyleDeclaration>.setProperty("column-break-after", "<cssproperty_column-break-after>");
<CSSStyleDeclaration>.setProperty("column-break-before", "<cssproperty_column-break-before>");
<CSSStyleDeclaration>.setProperty("column-count", "<cssproperty_column-count>");
<CSSStyleDeclaration>.setProperty("column-fill", "<cssproperty_column-fill>");
<CSSStyleDeclaration>.setProperty("column-gap", "<cssproperty_column-gap>");
<CSSStyleDeclaration>.setProperty("column-rule", "<cssproperty_column-rule>");
<CSSStyleDeclaration>.setProperty("column-rule-style", "<cssproperty_column-rule-style>");
<CSSStyleDeclaration>.setProperty("column-span", "<cssproperty_column-span>");
<CSSStyleDeclaration>.setProperty("column-width", "<cssproperty_column-width>");
<CSSStyleDeclaration>.setProperty("columns", "<cssproperty_columns>");
<CSSStyleDeclaration>.setProperty("contain", "<cssproperty_contain>");
<CSSStyleDeclaration>.setProperty("content", "<cssproperty_content>");
<CSSStyleDeclaration>.setProperty("counter-increment", "<cssproperty_counter-increment>");
<CSSStyleDeclaration>.setProperty("counter-reset", "<cssproperty_counter-reset>");
<CSSStyleDeclaration>.setProperty("css-float", "<cssproperty_css-float>");
<CSSStyleDeclaration>.setProperty("cursor", "<cssproperty_cursor>");
<CSSStyleDeclaration>.setProperty("cx", "<cssproperty_cx>");
<CSSStyleDeclaration>.setProperty("cy", "<cssproperty_cy>");
<CSSStyleDeclaration>.setProperty("direction", "<cssproperty_direction>");
<CSSStyleDeclaration>.setProperty("display", "<cssproperty_display>");
<CSSStyleDeclaration>.setProperty("dominant-baseline", "<cssproperty_dominant-baseline>");
<CSSStyleDeclaration>.setProperty("empty-cells", "<cssproperty_empty-cells>");
<CSSStyleDeclaration>.setProperty("fill", "<cssproperty_fill>");
<CSSStyleDeclaration>.setProperty("fill-opacity", "<cssproperty_fill-opacity>");
<CSSStyleDeclaration>.setProperty("fill-rule", "<cssproperty_fill-rule>");
<CSSStyleDeclaration>.setProperty("filter", "<cssproperty_filter>");
<CSSStyleDeclaration>.setProperty("flex", "<cssproperty_flex>");
<CSSStyleDeclaration>.setProperty("flex-basis", "<cssproperty_flex-basis>");
<CSSStyleDeclaration>.setProperty("flex-direction", "<cssproperty_flex-direction>");
<CSSStyleDeclaration>.setProperty("flex-flow", "<cssproperty_flex-flow>");
<CSSStyleDeclaration>.setProperty("flex-grow", "<cssproperty_flex-grow>");
<CSSStyleDeclaration>.setProperty("flex-shrink", "<cssproperty_flex-shrink>");
<CSSStyleDeclaration>.setProperty("flex-wrap", "<cssproperty_flex-wrap>");
<CSSStyleDeclaration>.setProperty("float", "<cssproperty_float>");
<CSSStyleDeclaration>.setProperty("flood-color", "<cssproperty_flood-color>");
<CSSStyleDeclaration>.setProperty("flood-opacity", "<cssproperty_flood-opacity>");
<CSSStyleDeclaration>.setProperty("font", "<cssproperty_font>");
<CSSStyleDeclaration>.setProperty("font-face", "<cssproperty_font-face>");
<CSSStyleDeclaration>.setProperty("font-family", "<cssproperty_font-family>");
<CSSStyleDeclaration>.setProperty("font-feature-settings", "<cssproperty_font-feature-settings>");
<CSSStyleDeclaration>.setProperty("font-kerning", "<cssproperty_font-kerning>");
<CSSStyleDeclaration>.setProperty("font-size", "<cssproperty_font-size>");
<CSSStyleDeclaration>.setProperty("font-size-adjust", "<cssproperty_font-size-adjust>");
<CSSStyleDeclaration>.setProperty("font-stretch", "<cssproperty_font-stretch>");
<CSSStyleDeclaration>.setProperty("font-style", "<cssproperty_font-style>");
<CSSStyleDeclaration>.setProperty("font-variant", "<cssproperty_font-variant>");
<CSSStyleDeclaration>.setProperty("font-variant-caps", "<cssproperty_font-variant-caps>");
<CSSStyleDeclaration>.setProperty("font-variant-ligatures", "<cssproperty_font-variant-ligatures>");
<CSSStyleDeclaration>.setProperty("font-vendor", "<cssproperty_font-vendor>");
<CSSStyleDeclaration>.setProperty("font-weight", "<cssproperty_font-weight>");
<CSSStyleDeclaration>.setProperty("grid", "<cssproperty_grid>");
<CSSStyleDeclaration>.setProperty("grid-area", "<cssproperty_grid-area>");
<CSSStyleDeclaration>.setProperty("grid-auto-columns", "<cssproperty_grid-auto-columns>");
<CSSStyleDeclaration>.setProperty("grid-auto-flow", "<cssproperty_grid-auto-flow>");
<CSSStyleDeclaration>.setProperty("grid-auto-rows", "<cssproperty_grid-auto-rows>");
<CSSStyleDeclaration>.setProperty("grid-column", "<cssproperty_grid-column>");
<CSSStyleDeclaration>.setProperty("grid-column-end", "<cssproperty_grid-column-end>");
<CSSStyleDeclaration>.setProperty("grid-column-gap", "<cssproperty_grid-column-gap>");
<CSSStyleDeclaration>.setProperty("grid-column-start", "<cssproperty_grid-column-start>");
<CSSStyleDeclaration>.setProperty("grid-gap", "<cssproperty_grid-gap>");
<CSSStyleDeclaration>.setProperty("grid-row", "<cssproperty_grid-row>");
<CSSStyleDeclaration>.setProperty("grid-row-end", "<cssproperty_grid-row-end>");
<CSSStyleDeclaration>.setProperty("grid-row-gap", "<cssproperty_grid-row-gap>");
<CSSStyleDeclaration>.setProperty("grid-row-start", "<cssproperty_grid-row-start>");
<CSSStyleDeclaration>.setProperty("grid-template", "<cssproperty_grid-template>");
<CSSStyleDeclaration>.setProperty("grid-template-areas", "<cssproperty_grid-template-areas>");
<CSSStyleDeclaration>.setProperty("grid-template-columns", "<cssproperty_grid-template-columns>");
<CSSStyleDeclaration>.setProperty("grid-template-rows", "<cssproperty_grid-template-rows>");
<CSSStyleDeclaration>.setProperty("height", "<cssproperty_height>");
<CSSStyleDeclaration>.setProperty("hyphens", "<cssproperty_hyphens>");
<CSSStyleDeclaration>.setProperty("image-orientation", "<cssproperty_image-orientation>");
<CSSStyleDeclaration>.setProperty("image-rendering", "<cssproperty_image-rendering>");
<CSSStyleDeclaration>.setProperty("isolation", "<cssproperty_isolation>");
<CSSStyleDeclaration>.setProperty("justify-content", "<cssproperty_justify-content>");
<CSSStyleDeclaration>.setProperty("justify-items", "<cssproperty_justify-items>");
<CSSStyleDeclaration>.setProperty("justify-self", "<cssproperty_justify-self>");
<CSSStyleDeclaration>.setProperty("kerning", "<cssproperty_kerning>");
<CSSStyleDeclaration>.setProperty("left", "<cssproperty_left>");
<CSSStyleDeclaration>.setProperty("letter-spacing", "<cssproperty_letter-spacing>");
<CSSStyleDeclaration>.setProperty("lighting-color", "<cssproperty_lighting-color>");
<CSSStyleDeclaration>.setProperty("line-break", "<cssproperty_line-break>");
<CSSStyleDeclaration>.setProperty("line-height", "<cssproperty_line-height>");
<CSSStyleDeclaration>.setProperty("list-style", "<cssproperty_list-style>");
<CSSStyleDeclaration>.setProperty("list-style-image", "<cssproperty_list-style-image>");
<CSSStyleDeclaration>.setProperty("list-style-position", "<cssproperty_list-style-position>");
<CSSStyleDeclaration>.setProperty("list-style-type", "<cssproperty_list-style-type>");
<CSSStyleDeclaration>.setProperty("margin", "<cssproperty_margin>");
<CSSStyleDeclaration>.setProperty("margin-bottom", "<cssproperty_margin-bottom>");
<CSSStyleDeclaration>.setProperty("margin-left", "<cssproperty_margin-left>");
<CSSStyleDeclaration>.setProperty("margin-right", "<cssproperty_margin-right>");
<CSSStyleDeclaration>.setProperty("margin-top", "<cssproperty_margin-top>");
<CSSStyleDeclaration>.setProperty("marker", "<cssproperty_marker>");
<CSSStyleDeclaration>.setProperty("marker-mid", "<cssproperty_marker-mid>");
<CSSStyleDeclaration>.setProperty("mask-source-type", "<cssproperty_mask-source-type>");
<CSSStyleDeclaration>.setProperty("max-height", "<cssproperty_max-height>");
<CSSStyleDeclaration>.setProperty("max-width", "<cssproperty_max-width>");
<CSSStyleDeclaration>.setProperty("max-zoom", "<cssproperty_max-zoom>");
<CSSStyleDeclaration>.setProperty("min-height", "<cssproperty_min-height>");
<CSSStyleDeclaration>.setProperty("min-width", "<cssproperty_min-width>");
<CSSStyleDeclaration>.setProperty("min-zoom", "<cssproperty_min-zoom>");
<CSSStyleDeclaration>.setProperty("mix-blend-mode", "<cssproperty_mix-blend-mode>");
<CSSStyleDeclaration>.setProperty("motion", "<cssproperty_motion>");
<CSSStyleDeclaration>.setProperty("motion-offset", "<cssproperty_motion-offset>");
<CSSStyleDeclaration>.setProperty("motion-path", "<cssproperty_motion-path>");
<CSSStyleDeclaration>.setProperty("motion-rotation", "<cssproperty_motion-rotation>");
<CSSStyleDeclaration>.setProperty("mso-background-source", "<cssproperty_mso-background-source>");
<CSSStyleDeclaration>.setProperty("mso-bidi-font-size", "<cssproperty_mso-bidi-font-size>");
<CSSStyleDeclaration>.setProperty("mso-border-alt", "<cssproperty_mso-border-alt>");
<CSSStyleDeclaration>.setProperty("mso-border-left-alt", "<cssproperty_mso-border-left-alt>");
<CSSStyleDeclaration>.setProperty("mso-border-top-alt", "<cssproperty_mso-border-top-alt>");
<CSSStyleDeclaration>.setProperty("mso-data-placement", "<cssproperty_mso-data-placement>");
<CSSStyleDeclaration>.setProperty("mso-displayed-decimal-separator", "<cssproperty_mso-displayed-decimal-separator>");
<CSSStyleDeclaration>.setProperty("mso-displayed-thousand-separator", "<cssproperty_mso-displayed-thousand-separator>");
<CSSStyleDeclaration>.setProperty("mso-fareast-font-family", "<cssproperty_mso-fareast-font-family>");
<CSSStyleDeclaration>.setProperty("mso-font-charset", "<cssproperty_mso-font-charset>");
<CSSStyleDeclaration>.setProperty("mso-font-kerning", "<cssproperty_mso-font-kerning>");
<CSSStyleDeclaration>.setProperty("mso-generic-font-family", "<cssproperty_mso-generic-font-family>");
<CSSStyleDeclaration>.setProperty("mso-height-source", "<cssproperty_mso-height-source>");
<CSSStyleDeclaration>.setProperty("mso-ignore", "<cssproperty_mso-ignore>");
<CSSStyleDeclaration>.setProperty("mso-number-format", "<cssproperty_mso-number-format>");
<CSSStyleDeclaration>.setProperty("mso-outline-level", "<cssproperty_mso-outline-level>");
<CSSStyleDeclaration>.setProperty("mso-padding-alt", "<cssproperty_mso-padding-alt>");
<CSSStyleDeclaration>.setProperty("mso-pagination", "<cssproperty_mso-pagination>");
<CSSStyleDeclaration>.setProperty("mso-pattern", "<cssproperty_mso-pattern>");
<CSSStyleDeclaration>.setProperty("mso-protection", "<cssproperty_mso-protection>");
<CSSStyleDeclaration>.setProperty("mso-rotate", "<cssproperty_mso-rotate>");
<CSSStyleDeclaration>.setProperty("mso-style-id", "<cssproperty_mso-style-id>");
<CSSStyleDeclaration>.setProperty("mso-style-name", "<cssproperty_mso-style-name>");
<CSSStyleDeclaration>.setProperty("mso-style-next", "<cssproperty_mso-style-next>");
<CSSStyleDeclaration>.setProperty("mso-style-parent", "<cssproperty_mso-style-parent>");
<CSSStyleDeclaration>.setProperty("mso-width-alt", "<cssproperty_mso-width-alt>");
<CSSStyleDeclaration>.setProperty("mso-width-source", "<cssproperty_mso-width-source>");
<CSSStyleDeclaration>.setProperty("object-fit", "<cssproperty_object-fit>");
<CSSStyleDeclaration>.setProperty("object-position", "<cssproperty_object-position>");
<CSSStyleDeclaration>.setProperty("offset", "<cssproperty_offset>");
<CSSStyleDeclaration>.setProperty("offset-anchor", "<cssproperty_offset-anchor>");
<CSSStyleDeclaration>.setProperty("offset-distance", "<cssproperty_offset-distance>");
<CSSStyleDeclaration>.setProperty("offset-path", "<cssproperty_offset-path>");
<CSSStyleDeclaration>.setProperty("offset-position", "<cssproperty_offset-position>");
<CSSStyleDeclaration>.setProperty("offset-rotation", "<cssproperty_offset-rotation>");
<CSSStyleDeclaration>.setProperty("opacity", "<cssproperty_opacity>");
<CSSStyleDeclaration>.setProperty("order", "<cssproperty_order>");
<CSSStyleDeclaration>.setProperty("orientation", "<cssproperty_orientation>");
<CSSStyleDeclaration>.setProperty("orphans", "<cssproperty_orphans>");
<CSSStyleDeclaration>.setProperty("outline", "<cssproperty_outline>");
<CSSStyleDeclaration>.setProperty("outline-bottom", "<cssproperty_outline-bottom>");
<CSSStyleDeclaration>.setProperty("outline-color", "<cssproperty_outline-color>");
<CSSStyleDeclaration>.setProperty("outline-offset", "<cssproperty_outline-offset>");
<CSSStyleDeclaration>.setProperty("outline-style", "<cssproperty_outline-style>");
<CSSStyleDeclaration>.setProperty("outline-width", "<cssproperty_outline-width>");
<CSSStyleDeclaration>.setProperty("overflow", "<cssproperty_overflow>");
<CSSStyleDeclaration>.setProperty("overflow-anchor", "<cssproperty_overflow-anchor>");
<CSSStyleDeclaration>.setProperty("overflow-wrap", "<cssproperty_overflow-wrap>");
<CSSStyleDeclaration>.setProperty("overflow-x", "<cssproperty_overflow-x>");
<CSSStyleDeclaration>.setProperty("overflow-y", "<cssproperty_overflow-y>");
<CSSStyleDeclaration>.setProperty("padding", "<cssproperty_padding>");
<CSSStyleDeclaration>.setProperty("padding-bottom", "<cssproperty_padding-bottom>");
<CSSStyleDeclaration>.setProperty("padding-left", "<cssproperty_padding-left>");
<CSSStyleDeclaration>.setProperty("padding-right", "<cssproperty_padding-right>");
<CSSStyleDeclaration>.setProperty("padding-top", "<cssproperty_padding-top>");
<CSSStyleDeclaration>.setProperty("page", "<cssproperty_page>");
<CSSStyleDeclaration>.setProperty("page-break-after", "<cssproperty_page-break-after>");
<CSSStyleDeclaration>.setProperty("page-break-before", "<cssproperty_page-break-before>");
<CSSStyleDeclaration>.setProperty("page-break-inside", "<cssproperty_page-break-inside>");
<CSSStyleDeclaration>.setProperty("perspective", "<cssproperty_perspective>");
<CSSStyleDeclaration>.setProperty("perspective-origin", "<cssproperty_perspective-origin>");
<CSSStyleDeclaration>.setProperty("pointer-events", "<cssproperty_pointer-events>");
<CSSStyleDeclaration>.setProperty("position", "<cssproperty_position>");
<CSSStyleDeclaration>.setProperty("prince-hyphens", "<cssproperty_prince-hyphens>");
<CSSStyleDeclaration>.setProperty("quotes", "<cssproperty_quotes>");
<CSSStyleDeclaration>.setProperty("resize", "<cssproperty_resize>");
<CSSStyleDeclaration>.setProperty("right", "<cssproperty_right>");
<CSSStyleDeclaration>.setProperty("rotate", "<cssproperty_rotate>");
<CSSStyleDeclaration>.setProperty("rotation", "<cssproperty_rotation>");
<CSSStyleDeclaration>.setProperty("rotation-code", "<cssproperty_rotation-code>");
<CSSStyleDeclaration>.setProperty("rx", "<cssproperty_rx>");
<CSSStyleDeclaration>.setProperty("ry", "<cssproperty_ry>");
<CSSStyleDeclaration>.setProperty("scale", "<cssproperty_scale>");
<CSSStyleDeclaration>.setProperty("scroll-behavior", "<cssproperty_scroll-behavior>");
<CSSStyleDeclaration>.setProperty("scroll-snap-coordinate", "<cssproperty_scroll-snap-coordinate>");
<CSSStyleDeclaration>.setProperty("scroll-snap-destination", "<cssproperty_scroll-snap-destination>");
<CSSStyleDeclaration>.setProperty("scroll-snap-points-x", "<cssproperty_scroll-snap-points-x>");
<CSSStyleDeclaration>.setProperty("scroll-snap-points-y", "<cssproperty_scroll-snap-points-y>");
<CSSStyleDeclaration>.setProperty("scroll-snap-type", "<cssproperty_scroll-snap-type>");
<CSSStyleDeclaration>.setProperty("shape-image-threshold", "<cssproperty_shape-image-threshold>");
<CSSStyleDeclaration>.setProperty("shape-inside", "<cssproperty_shape-inside>");
<CSSStyleDeclaration>.setProperty("shape-margin", "<cssproperty_shape-margin>");
<CSSStyleDeclaration>.setProperty("shape-outside", "<cssproperty_shape-outside>");
<CSSStyleDeclaration>.setProperty("snap-height", "<cssproperty_snap-height>");
<CSSStyleDeclaration>.setProperty("src", "<cssproperty_src>");
<CSSStyleDeclaration>.setProperty("stop-color", "<cssproperty_stop-color>");
<CSSStyleDeclaration>.setProperty("stop-opacity", "<cssproperty_stop-opacity>");
<CSSStyleDeclaration>.setProperty("stroke", "<cssproperty_stroke>");
<CSSStyleDeclaration>.setProperty("stroke-dasharray", "<cssproperty_stroke-dasharray>");
<CSSStyleDeclaration>.setProperty("stroke-dashoffset", "<cssproperty_stroke-dashoffset>");
<CSSStyleDeclaration>.setProperty("stroke-linecap", "<cssproperty_stroke-linecap>");
<CSSStyleDeclaration>.setProperty("stroke-linejoin", "<cssproperty_stroke-linejoin>");
<CSSStyleDeclaration>.setProperty("stroke-miterlimit", "<cssproperty_stroke-miterlimit>");
<CSSStyleDeclaration>.setProperty("stroke-opacity", "<cssproperty_stroke-opacity>");
<CSSStyleDeclaration>.setProperty("stroke-width", "<cssproperty_stroke-width>");
<CSSStyleDeclaration>.setProperty("tab-size", "<cssproperty_tab-size>");
<CSSStyleDeclaration>.setProperty("table-layout", "<cssproperty_table-layout>");
<CSSStyleDeclaration>.setProperty("text-align", "<cssproperty_text-align>");
<CSSStyleDeclaration>.setProperty("text-align-last", "<cssproperty_text-align-last>");
<CSSStyleDeclaration>.setProperty("text-anchor", "<cssproperty_text-anchor>");
<CSSStyleDeclaration>.setProperty("text-combine-upright", "<cssproperty_text-combine-upright>");
<CSSStyleDeclaration>.setProperty("text-decoration", "<cssproperty_text-decoration>");
<CSSStyleDeclaration>.setProperty("text-decoration-color", "<cssproperty_text-decoration-color>");
<CSSStyleDeclaration>.setProperty("text-decoration-line", "<cssproperty_text-decoration-line>");
<CSSStyleDeclaration>.setProperty("text-decoration-style", "<cssproperty_text-decoration-style>");
<CSSStyleDeclaration>.setProperty("text-decoration-upright", "<cssproperty_text-decoration-upright>");
<CSSStyleDeclaration>.setProperty("text-indent", "<cssproperty_text-indent>");
<CSSStyleDeclaration>.setProperty("text-justify", "<cssproperty_text-justify>");
<CSSStyleDeclaration>.setProperty("text-orientation", "<cssproperty_text-orientation>");
<CSSStyleDeclaration>.setProperty("text-overflow", "<cssproperty_text-overflow>");
<CSSStyleDeclaration>.setProperty("text-rendering", "<cssproperty_text-rendering>");
<CSSStyleDeclaration>.setProperty("text-shadow", "<cssproperty_text-shadow>");
<CSSStyleDeclaration>.setProperty("text-transform", "<cssproperty_text-transform>");
<CSSStyleDeclaration>.setProperty("text-underline", "<cssproperty_text-underline>");
<CSSStyleDeclaration>.setProperty("text-underline-position", "<cssproperty_text-underline-position>");
<CSSStyleDeclaration>.setProperty("top", "<cssproperty_top>");
<CSSStyleDeclaration>.setProperty("touch-action", "<cssproperty_touch-action>");
<CSSStyleDeclaration>.setProperty("transform", "<cssproperty_transform>");
<CSSStyleDeclaration>.setProperty("transform-origin", "<cssproperty_transform-origin>");
<CSSStyleDeclaration>.setProperty("transform-style", "<cssproperty_transform-style>");
<CSSStyleDeclaration>.setProperty("transition", "<cssproperty_transition>");
<CSSStyleDeclaration>.setProperty("transition-delay", "<cssproperty_transition-delay>");
<CSSStyleDeclaration>.setProperty("transition-duration", "<cssproperty_transition-duration>");
<CSSStyleDeclaration>.setProperty("transition-properties", "<cssproperty_transition-properties>");
<CSSStyleDeclaration>.setProperty("transition-property", "<cssproperty_transition-property>");
<CSSStyleDeclaration>.setProperty("transition-timing-function", "<cssproperty_transition-timing-function>");
<CSSStyleDeclaration>.setProperty("translate", "<cssproperty_translate>");
<CSSStyleDeclaration>.setProperty("unicode-bidi", "<cssproperty_unicode-bidi>");
<CSSStyleDeclaration>.setProperty("user-select", "<cssproperty_user-select>");
<CSSStyleDeclaration>.setProperty("user-zoom", "<cssproperty_user-zoom>");
<CSSStyleDeclaration>.setProperty("vector-effect", "<cssproperty_vector-effect>");
<CSSStyleDeclaration>.setProperty("vertical-align", "<cssproperty_vertical-align>");
<CSSStyleDeclaration>.setProperty("visibility", "<cssproperty_visibility>");
<CSSStyleDeclaration>.setProperty("weight", "<cssproperty_weight>");
<CSSStyleDeclaration>.setProperty("white", "<cssproperty_white>");
<CSSStyleDeclaration>.setProperty("white-space", "<cssproperty_white-space>");
<CSSStyleDeclaration>.setProperty("whitespace", "<cssproperty_whitespace>");
<CSSStyleDeclaration>.setProperty("widows", "<cssproperty_widows>");
<CSSStyleDeclaration>.setProperty("width", "<cssproperty_width>");
<CSSStyleDeclaration>.setProperty("will-change", "<cssproperty_will-change>");
<CSSStyleDeclaration>.setProperty("word-break", "<cssproperty_word-break>");
<CSSStyleDeclaration>.setProperty("word-space", "<cssproperty_word-space>");
<CSSStyleDeclaration>.setProperty("word-spacing", "<cssproperty_word-spacing>");
<CSSStyleDeclaration>.setProperty("word-wrap", "<cssproperty_word-wrap>");
<CSSStyleDeclaration>.setProperty("writing-mode", "<cssproperty_writing-mode>");
<CSSStyleDeclaration>.setProperty("z-index", "<cssproperty_z-index>");
<CSSStyleDeclaration>.setProperty("zoom", "<cssproperty_zoom>");

<CSSStyleDeclaration>.setProperty("<cssvar>", <string_cssvalue>);
<CSSStyleDeclaration>.setProperty(<string_cssproperty>, "var(<cssvar>)");

document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);
document.all[<int min=0 max=100>%document.all.length].appendChild(<Element>);

<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;
<new CSSStyleDeclaration> = <Element>.style;

################################################
#SVG
################################################

!extends SVGElement GlobalEventHandlers
<new GlobalEventHandlers> = <SVGElement>;

!extends SVGElement EventTarget
<new EventTarget> = <SVGElement>;

#NodeList
<new SVGElement> = <SVGNodeList id=1>.item(<int min=0 max=100>%<SVGNodeList id=1>.length);
<new long> = <SVGNodeList>.length;

#Node
<new short> = <SVGElement>.nodeType;
<new DOMString> = <SVGElement>.nodeName;
<new DOMString> = <SVGElement>.baseURI;
<new boolean> = <SVGElement>.isConnected;
<new Document> = <SVGElement>.ownerDocument;
<new SVGElement> = <SVGElement>.parentNode;
<new SVGElement> = <SVGElement>.parentElement;
<new boolean> = <SVGElement>.hasChildNodes();
<new SVGNodeList> = <SVGElement>.childNodes;
<new SVGElement> = <SVGElement>.firstChild;
<new SVGElement> = <SVGElement>.lastChild;
<new SVGElement> = <SVGElement>.previousSibling;
<new SVGElement> = <SVGElement>.nextSibling;
<new SVGElement> = <SVGElement>.getRootNode();
<new SVGElement> = <SVGElement>.getRootNode(<GetRootNodeOptions>);
<new DOMString> = <SVGElement>.nodeValue;
<SVGElement>.nodeValue = <DOMString>;
<new DOMString> = <SVGElement>.textContent;
<SVGElement>.textContent = <DOMString>;
<SVGElement>.normalize();
<new SVGElement> = <SVGElement>.cloneNode();
<new SVGElement> = <SVGElement>.cloneNode(<boolean>);
<new boolean> = <SVGElement>.isEqualNode(<SVGElement>);
<new boolean> = <SVGElement>.isSameNode(<SVGElement>);
<new short> = <SVGElement>.compareDocumentPosition(<SVGElement>);
<new boolean> = <SVGElement>.contains(<SVGElement>);
<new DOMString> = <SVGElement>.lookupPrefix(<DOMString>);
<new DOMString> = <SVGElement>.lookupNamespaceURI(<DOMString>);
<new boolean> = <SVGElement>.isDefaultNamespace(<DOMString>);
<new SVGElement> = <SVGElement id=1>.insertBefore(<SVGElement>,<SVGElement id=1>.childNodes[<int min=0 max=100>%<SVGElement id=1>.childNodes.length]);
<new SVGElement> = <SVGElement>.appendChild(<SVGElement>);
<new SVGElement> = <SVGElement id=1>.replaceChild(<SVGElement>,<SVGElement id=1>.childNodes[<int min=0 max=100>%<SVGElement id=1>.childNodes.length]);
<new SVGElement> = <SVGElement id=1>.removeChild(<SVGElement id=1>.childNodes[<int min=0 max=100>%<SVGElement id=1>.childNodes.length]);

#ChildNode
<SVGElement>.before(<SVGElement>);
<SVGElement>.before(<DOMString>);
<SVGElement>.after(<SVGElement>);
<SVGElement>.after(<DOMString>);
<SVGElement>.replaceWith(<SVGElement>);
<SVGElement>.replaceWith(<DOMString>);
<SVGElement>.remove();

#ParentNode
<new HTMLCollection> = <SVGElement>.children;
<new SVGElement> = <SVGElement>.firstElementChild;
<new SVGElement> = <SVGElement>.lastElementChild;
<new long> = <SVGElement>.childElementCount;
<SVGElement>.prepend(<SVGElement>);
<SVGElement>.prepend(<DOMString>);
<SVGElement>.append(<SVGElement>);
<SVGElement>.append(<DOMString>);
<new SVGElement> = <SVGElement>.querySelector("<selector>");
<new SVGNodeList> = <SVGElement>.querySelectorAll("<selector>");

#NonDocumentTypeChildNode
<new SVGElement> = <SVGElement>.previousElementSibling;
<new SVGElement> = <SVGElement>.nextElementSibling;

#Element
<new DOMString> = <SVGElement>.namespaceURI;
<new DOMString> = <SVGElement>.prefix;
<new DOMString> = <SVGElement>.localName;
<new DOMString> = <SVGElement>.tagName;
<new DOMString> = <SVGElement>.id;
<SVGElement>.id = <DOMString>;
<new DOMString> = <SVGElement>.className;
<SVGElement>.className = <DOMString>;
<new DOMTokenList> = <SVGElement>.classList;
<SVGElement>.setPointerCapture(<fuzzint>);
<SVGElement>.releasePointerCapture(<fuzzint>);
<new EventHandler> = <SVGElement>.ongotpointercapture;
<SVGElement>.ongotpointercapture = <EventHandler>;
<new EventHandler> = <SVGElement>.onlostpointercapture;
<SVGElement>.onlostpointercapture = <EventHandler>;
<new boolean> = <SVGElement>.hasPointerCapture(<fuzzint>);
<new boolean> = <SVGElement>.hasAttributes();
<new NamedNodeMap> = <SVGElement>.attributes;
<new DOMString> = <SVGElement>.getAttribute(<string_attr>);
<new DOMString> = <SVGElement>.getAttributeNS("http://www.w3.org/2000/svg",<string_attr>);
#<SVGElement>.setAttribute(<DOMString>,<DOMString>);
#<SVGElement>.setAttributeNS(<DOMString>,<DOMString>,<DOMString>);
<SVGElement id=1>.removeAttribute(<SVGElement id=1>.attributes[<int min=0 max=100>%<SVGElement id=1>.attributes.length].name);
<SVGElement id=1>.removeAttributeNS("http://www.w3.org/2000/svg",<SVGElement id=1>.attributes[<int min=0 max=100>%<SVGElement id=1>.attributes.length].name);
<new boolean> = <SVGElement>.hasAttribute(<string_attr>);
<new boolean> = <SVGElement>.hasAttributeNS("http://www.w3.org/2000/svg",<string_attr>);
<new Attr> = <SVGElement>.getAttributeNode(<string_attr>);
<new Attr> = <SVGElement>.getAttributeNodeNS("http://www.w3.org/2000/svg",<string_attr>);
<new Attr> = <SVGElement>.setAttributeNode(<Attr>);
<new Attr> = <SVGElement>.setAttributeNodeNS(<Attr>);
<new Attr> = <SVGElement id=1>.removeAttributeNode(<SVGElement id=1>.attributes[<int min=0 max=100>%<SVGElement id=1>.attributes.length].name);
<new SVGElement> = <SVGElement>.closest(<DOMString>);
<new boolean> = <SVGElement>.matches(<DOMString>);
<new boolean> = <SVGElement>.webkitMatchesSelector(<DOMString>);
<new HTMLCollection> = <SVGElement>.getElementsByTagName(<string_tag>);
<new HTMLCollection> = <SVGElement>.getElementsByTagNameNS("http://www.w3.org/2000/svg",<string_tag>);
<new HTMLCollection> = <SVGElement>.getElementsByClassName("<class>");
<new SVGElement> = <SVGElement>.insertAdjacentElement(<string_where>,<SVGElement>);
<SVGElement>.insertAdjacentText(<string_where>,<DOMString>);
<new htmlstring> = <SVGElement>.innerHTML;
<SVGElement>.innerHTML = <htmlstring>;
<new htmlstring> = <SVGElement>.outerHTML;
<SVGElement>.outerHTML = <htmlstring>;
<SVGElement>.insertAdjacentHTML(<string_where>,<htmlstring>);
<new ShadowRoot> = <SVGElement>.createShadowRoot();
<new ShadowRoot> = <SVGElement>.attachShadow(<ShadowRootInit>);
<new NodeList> = <SVGElement>.getDestinationInsertionPoints();
<new ShadowRoot> = <SVGElement>.shadowRoot;
<new DOMString> = <SVGElement>.slot;
<SVGElement>.slot = <DOMString>;
<new HTMLSlotElement> = <SVGElement>.assignedSlot;
<SVGElement>.requestPointerLock();
<new ClientRectList> = <SVGElement>.getClientRects();
<new ClientRect> = <SVGElement>.getBoundingClientRect();
<SVGElement>.scrollIntoView();
<SVGElement>.scrollIntoView(<boolean>);
<SVGElement>.scroll();
<SVGElement>.scroll(<ScrollToOptions>);
<SVGElement>.scroll(<double>,<double>);
<SVGElement>.scrollTo();
<SVGElement>.scrollTo(<ScrollToOptions>);
<SVGElement>.scrollTo(<double>,<double>);
<SVGElement>.scrollBy();
<SVGElement>.scrollBy(<ScrollToOptions>);
<SVGElement>.scrollBy(<double>,<double>);
<new double> = <SVGElement>.scrollTop;
<SVGElement>.scrollTop = <double>;
<new double> = <SVGElement>.scrollLeft;
<SVGElement>.scrollLeft = <double>;
<new long> = <SVGElement>.scrollWidth;
<new long> = <SVGElement>.scrollHeight;
<new long> = <SVGElement>.clientTop;
<new long> = <SVGElement>.clientLeft;
<new long> = <SVGElement>.clientWidth;
<new long> = <SVGElement>.clientHeight;
<SVGElement>.setApplyScroll(<ScrollStateCallback>,<NativeScrollBehavior>);
<SVGElement>.setDistributeScroll(<ScrollStateCallback>,<NativeScrollBehavior>);
<SVGElement>.scrollIntoViewIfNeeded();
<SVGElement>.scrollIntoViewIfNeeded(<boolean>);
<new DOMString> = <SVGElement>.computedRole;
<new DOMString> = <SVGElement>.computedName;
<new EventHandler> = <SVGElement>.onbeforecopy;
<SVGElement>.onbeforecopy = <EventHandler>;
<new EventHandler> = <SVGElement>.onbeforecut;
<SVGElement>.onbeforecut = <EventHandler>;
<new EventHandler> = <SVGElement>.onbeforepaste;
<SVGElement>.onbeforepaste = <EventHandler>;
<new EventHandler> = <SVGElement>.oncopy;
<SVGElement>.oncopy = <EventHandler>;
<new EventHandler> = <SVGElement>.oncut;
<SVGElement>.oncut = <EventHandler>;
<new EventHandler> = <SVGElement>.onpaste;
<SVGElement>.onpaste = <EventHandler>;
<new EventHandler> = <SVGElement>.onsearch;
<SVGElement>.onsearch = <EventHandler>;
<new EventHandler> = <SVGElement>.onselectstart;
<SVGElement>.onselectstart = <EventHandler>;
<new EventHandler> = <SVGElement>.onwheel;
<SVGElement>.onwheel = <EventHandler>;


#SVGTextContentElement
!extends SVGTextContentElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGTextContentElement>;
<new SVGAnimatedLength> = <SVGTextContentElement>.textLength;
<new SVGAnimatedEnumeration> = <SVGTextContentElement>.lengthAdjust;
<new long> = <SVGTextContentElement>.getNumberOfChars();
<new float> = <SVGTextContentElement>.getComputedTextLength();
<new float> = <SVGTextContentElement>.getSubStringLength(<fuzzint>,<fuzzint>);
<new SVGPoint> = <SVGTextContentElement>.getStartPositionOfChar(<fuzzint>);
<new SVGPoint> = <SVGTextContentElement>.getEndPositionOfChar(<fuzzint>);
<new SVGRect> = <SVGTextContentElement>.getExtentOfChar(<fuzzint>);
<new float> = <SVGTextContentElement>.getRotationOfChar(<fuzzint>);
<new long> = <SVGTextContentElement>.getCharNumAtPosition(<SVGPoint>);
<SVGTextContentElement>.selectSubString(<fuzzint>,<fuzzint>);
!extends SVGViewElement SVGFitToViewBox
<new SVGFitToViewBox> = <SVGViewElement>;
!extends SVGViewElement SVGZoomAndPan
<new SVGZoomAndPan> = <SVGViewElement>;

#SVGViewElement
!extends SVGViewElement SVGElement
<new SVGElement> = <SVGViewElement>;
<new SVGStringList> = <SVGViewElement>.viewTarget;

#SVGAnimatedLengthList
<new SVGLengthList> = <SVGAnimatedLengthList>.baseVal;
<new SVGLengthList> = <SVGAnimatedLengthList>.animVal;
!extends SVGFEColorMatrixElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEColorMatrixElement>;

#SVGFEColorMatrixElement
!extends SVGFEColorMatrixElement SVGElement
<new SVGElement> = <SVGFEColorMatrixElement>;
<new SVGAnimatedString> = <SVGFEColorMatrixElement>.in1;
<new SVGAnimatedEnumeration> = <SVGFEColorMatrixElement>.type;
<new SVGAnimatedNumberList> = <SVGFEColorMatrixElement>.values;

#SVGDescElement
!extends SVGDescElement SVGElement
<new SVGElement> = <SVGDescElement>;

#SVGDiscardElement
!extends SVGDiscardElement SVGElement
<new SVGElement> = <SVGDiscardElement>;

#SVGNumber
<new float> = <SVGNumber>.value;
<SVGNumber>.value = <float>;

#SVGAnimateElement
!extends SVGAnimateElement SVGAnimationElement
<new SVGAnimationElement> = <SVGAnimateElement>;

#SVGAnimatedInteger
<new long> = <SVGAnimatedInteger>.baseVal;
<SVGAnimatedInteger>.baseVal = <fuzzint>;
<new long> = <SVGAnimatedInteger>.animVal;

#SVGAnimateMotionElement
!extends SVGAnimateMotionElement SVGAnimationElement
<new SVGAnimationElement> = <SVGAnimateMotionElement>;

#SVGRadialGradientElement
!extends SVGRadialGradientElement SVGGradientElement
<new SVGGradientElement> = <SVGRadialGradientElement>;
<new SVGAnimatedLength> = <SVGRadialGradientElement>.cx;
<new SVGAnimatedLength> = <SVGRadialGradientElement>.cy;
<new SVGAnimatedLength> = <SVGRadialGradientElement>.r;
<new SVGAnimatedLength> = <SVGRadialGradientElement>.fx;
<new SVGAnimatedLength> = <SVGRadialGradientElement>.fy;
<new SVGAnimatedLength> = <SVGRadialGradientElement>.fr;
!extends SVGFEComponentTransferElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEComponentTransferElement>;

#SVGFEComponentTransferElement
!extends SVGFEComponentTransferElement SVGElement
<new SVGElement> = <SVGFEComponentTransferElement>;
<new SVGAnimatedString> = <SVGFEComponentTransferElement>.in1;

#SVGTransformList
<new long> = <SVGTransformList>.length;
<new long> = <SVGTransformList>.numberOfItems;
<SVGTransformList>.clear();
<new SVGTransform> = <SVGTransformList>.initialize(<SVGTransform>);
<new SVGTransform> = <SVGTransformList>.getItem(<fuzzint>);
<new SVGTransform> = <SVGTransformList>.insertItemBefore(<SVGTransform>,<fuzzint>);
<new SVGTransform> = <SVGTransformList>.replaceItem(<SVGTransform>,<fuzzint>);
<new SVGTransform> = <SVGTransformList>.removeItem(<fuzzint>);
<new SVGTransform> = <SVGTransformList>.appendItem(<SVGTransform>);
<new SVGTransform> = <SVGTransformList>.createSVGTransformFromMatrix(<SVGMatrix>);
<new SVGTransform> = <SVGTransformList>.consolidate();
<SVGTransformList>[<fuzzint>] = <SVGTransform>;

!extends SVGFEDisplacementMapElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEDisplacementMapElement>;

#SVGFEDisplacementMapElement
!extends SVGFEDisplacementMapElement SVGElement
<new SVGElement> = <SVGFEDisplacementMapElement>;
<new SVGAnimatedString> = <SVGFEDisplacementMapElement>.in1;
<new SVGAnimatedString> = <SVGFEDisplacementMapElement>.in2;
<new SVGAnimatedNumber> = <SVGFEDisplacementMapElement>.scale;
<new SVGAnimatedEnumeration> = <SVGFEDisplacementMapElement>.xChannelSelector;
<new SVGAnimatedEnumeration> = <SVGFEDisplacementMapElement>.yChannelSelector;
!extends SVGGradientElement SVGURIReference
<new SVGURIReference> = <SVGGradientElement>;

#SVGGradientElement
!extends SVGGradientElement SVGElement
<new SVGElement> = <SVGGradientElement>;
<new SVGAnimatedEnumeration> = <SVGGradientElement>.gradientUnits;
<new SVGAnimatedTransformList> = <SVGGradientElement>.gradientTransform;
<new SVGAnimatedEnumeration> = <SVGGradientElement>.spreadMethod;

#SVGNumberList
<new long> = <SVGNumberList>.length;
<new long> = <SVGNumberList>.numberOfItems;
<SVGNumberList>.clear();
<new SVGNumber> = <SVGNumberList>.initialize(<SVGNumber>);
<new SVGNumber> = <SVGNumberList>.getItem(<fuzzint>);
<new SVGNumber> = <SVGNumberList>.insertItemBefore(<SVGNumber>,<fuzzint>);
<new SVGNumber> = <SVGNumberList>.replaceItem(<SVGNumber>,<fuzzint>);
<new SVGNumber> = <SVGNumberList>.removeItem(<fuzzint>);
<new SVGNumber> = <SVGNumberList>.appendItem(<SVGNumber>);
<SVGNumberList>[<fuzzint>] = <SVGNumber>;

#SVGFEFuncGElement
!extends SVGFEFuncGElement SVGComponentTransferFunctionElement
<new SVGComponentTransferFunctionElement> = <SVGFEFuncGElement>;

#SVGMatrix
<new double> = <SVGMatrix>.a;
<SVGMatrix>.a = <double>;
<new double> = <SVGMatrix>.b;
<SVGMatrix>.b = <double>;
<new double> = <SVGMatrix>.c;
<SVGMatrix>.c = <double>;
<new double> = <SVGMatrix>.d;
<SVGMatrix>.d = <double>;
<new double> = <SVGMatrix>.e;
<SVGMatrix>.e = <double>;
<new double> = <SVGMatrix>.f;
<SVGMatrix>.f = <double>;
<new SVGMatrix> = <SVGMatrix>.multiply(<SVGMatrix>);
<new SVGMatrix> = <SVGMatrix>.inverse();
<new SVGMatrix> = <SVGMatrix>.translate(<float>,<float>);
<new SVGMatrix> = <SVGMatrix>.scale(<float>);
<new SVGMatrix> = <SVGMatrix>.scaleNonUniform(<float>,<float>);
<new SVGMatrix> = <SVGMatrix>.rotate(<float>);
<new SVGMatrix> = <SVGMatrix>.rotateFromVector(<float>,<float>);
<new SVGMatrix> = <SVGMatrix>.flipX();
<new SVGMatrix> = <SVGMatrix>.flipY();
<new SVGMatrix> = <SVGMatrix>.skewX(<float>);
<new SVGMatrix> = <SVGMatrix>.skewY(<float>);

#SVGFESpotLightElement
!extends SVGFESpotLightElement SVGElement
<new SVGElement> = <SVGFESpotLightElement>;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.x;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.y;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.z;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.pointsAtX;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.pointsAtY;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.pointsAtZ;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.specularExponent;
<new SVGAnimatedNumber> = <SVGFESpotLightElement>.limitingConeAngle;
!extends SVGPatternElement SVGFitToViewBox
<new SVGFitToViewBox> = <SVGPatternElement>;
!extends SVGPatternElement SVGURIReference
<new SVGURIReference> = <SVGPatternElement>;
!extends SVGPatternElement SVGTests
<new SVGTests> = <SVGPatternElement>;

#SVGPatternElement
!extends SVGPatternElement SVGElement
<new SVGElement> = <SVGPatternElement>;
<new SVGAnimatedEnumeration> = <SVGPatternElement>.patternUnits;
<new SVGAnimatedEnumeration> = <SVGPatternElement>.patternContentUnits;
<new SVGAnimatedTransformList> = <SVGPatternElement>.patternTransform;
<new SVGAnimatedLength> = <SVGPatternElement>.x;
<new SVGAnimatedLength> = <SVGPatternElement>.y;
<new SVGAnimatedLength> = <SVGPatternElement>.width;
<new SVGAnimatedLength> = <SVGPatternElement>.height;

#SVGLinearGradientElement
!extends SVGLinearGradientElement SVGGradientElement
<new SVGGradientElement> = <SVGLinearGradientElement>;
<new SVGAnimatedLength> = <SVGLinearGradientElement>.x1;
<new SVGAnimatedLength> = <SVGLinearGradientElement>.y1;
<new SVGAnimatedLength> = <SVGLinearGradientElement>.x2;
<new SVGAnimatedLength> = <SVGLinearGradientElement>.y2;

#SVGRectElement
!extends SVGRectElement SVGGeometryElement
<new SVGGeometryElement> = <SVGRectElement>;
<new SVGAnimatedLength> = <SVGRectElement>.x;
<new SVGAnimatedLength> = <SVGRectElement>.y;
<new SVGAnimatedLength> = <SVGRectElement>.width;
<new SVGAnimatedLength> = <SVGRectElement>.height;
<new SVGAnimatedLength> = <SVGRectElement>.rx;
<new SVGAnimatedLength> = <SVGRectElement>.ry;

#SVGAnimatedRect
<new SVGRect> = <SVGAnimatedRect>.baseVal;
<new SVGRect> = <SVGAnimatedRect>.animVal;

#SVGAnimateTransformElement
!extends SVGAnimateTransformElement SVGAnimationElement
<new SVGAnimationElement> = <SVGAnimateTransformElement>;
!extends SVGElement GlobalEventHandlers
<new GlobalEventHandlers> = <SVGElement>;

#SVGElement
<new SVGAnimatedString> = <SVGElement>.className;
<new DOMStringMap> = <SVGElement>.dataset;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new SVGSVGElement> = <SVGElement>.ownerSVGElement;
<new SVGElement> = <SVGElement>.viewportElement;
<new long> = <SVGElement>.tabIndex;
<SVGElement>.tabIndex = <fuzzint>;
<SVGElement>.focus();
<SVGElement>.blur();

#SVGGraphicsElement
!extends SVGGraphicsElement SVGElement
<new SVGElement> = <SVGGraphicsElement>;
<new SVGAnimatedTransformList> = <SVGGraphicsElement>.transform;
<new SVGElement> = <SVGGraphicsElement>.nearestViewportElement;
<new SVGElement> = <SVGGraphicsElement>.farthestViewportElement;
<new SVGRect> = <SVGGraphicsElement>.getBBox();
<new SVGMatrix> = <SVGGraphicsElement>.getCTM();
<new SVGMatrix> = <SVGGraphicsElement>.getScreenCTM();
!extends SVGSVGElement SVGFitToViewBox
<new SVGFitToViewBox> = <SVGSVGElement>;
!extends SVGSVGElement SVGZoomAndPan
<new SVGZoomAndPan> = <SVGSVGElement>;

#SVGSVGElement
!extends SVGSVGElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGSVGElement>;
<new SVGAnimatedLength> = <SVGSVGElement>.x;
<new SVGAnimatedLength> = <SVGSVGElement>.y;
<new SVGAnimatedLength> = <SVGSVGElement>.width;
<new SVGAnimatedLength> = <SVGSVGElement>.height;
<new boolean> = <SVGSVGElement>.useCurrentView;
<new SVGViewSpec> = <SVGSVGElement>.currentView;
<new float> = <SVGSVGElement>.currentScale;
<SVGSVGElement>.currentScale = <float>;
<new SVGPoint> = <SVGSVGElement>.currentTranslate;
<new long> = <SVGSVGElement>.suspendRedraw(<fuzzint>);
<SVGSVGElement>.unsuspendRedraw(<fuzzint>);
<SVGSVGElement>.unsuspendRedrawAll();
<SVGSVGElement>.forceRedraw();
<SVGSVGElement>.pauseAnimations();
<SVGSVGElement>.unpauseAnimations();
<new boolean> = <SVGSVGElement>.animationsPaused();
<new float> = <SVGSVGElement>.getCurrentTime();
<SVGSVGElement>.setCurrentTime(<float>);
<new NodeList> = <SVGSVGElement>.getIntersectionList(<SVGRect>,<SVGElement>);
<new NodeList> = <SVGSVGElement>.getEnclosureList(<SVGRect>,<SVGElement>);
<new boolean> = <SVGSVGElement>.checkIntersection(<SVGElement>,<SVGRect>);
<new boolean> = <SVGSVGElement>.checkEnclosure(<SVGElement>,<SVGRect>);
<SVGSVGElement>.deselectAll();
<new SVGNumber> = <SVGSVGElement>.createSVGNumber();
<new SVGLength> = <SVGSVGElement>.createSVGLength();
<new SVGAngle> = <SVGSVGElement>.createSVGAngle();
<new SVGPoint> = <SVGSVGElement>.createSVGPoint();
<new SVGMatrix> = <SVGSVGElement>.createSVGMatrix();
<new SVGRect> = <SVGSVGElement>.createSVGRect();
<new SVGTransform> = <SVGSVGElement>.createSVGTransform();
<new SVGTransform> = <SVGSVGElement>.createSVGTransformFromMatrix(<SVGMatrix>);
<new SVGElement> = <SVGSVGElement>.getElementById(<DOMString>);
!extends SVGTextPathElement SVGURIReference
<new SVGURIReference> = <SVGTextPathElement>;

#SVGTextPathElement
!extends SVGTextPathElement SVGTextContentElement
<new SVGTextContentElement> = <SVGTextPathElement>;
<new SVGAnimatedLength> = <SVGTextPathElement>.startOffset;
<new SVGAnimatedEnumeration> = <SVGTextPathElement>.method;
<new SVGAnimatedEnumeration> = <SVGTextPathElement>.spacing;
!extends SVGFETileElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFETileElement>;

#SVGFETileElement
!extends SVGFETileElement SVGElement
<new SVGElement> = <SVGFETileElement>;
<new SVGAnimatedString> = <SVGFETileElement>.in1;

#SVGFEPointLightElement
!extends SVGFEPointLightElement SVGElement
<new SVGElement> = <SVGFEPointLightElement>;
<new SVGAnimatedNumber> = <SVGFEPointLightElement>.x;
<new SVGAnimatedNumber> = <SVGFEPointLightElement>.y;
<new SVGAnimatedNumber> = <SVGFEPointLightElement>.z;

#SVGAnimatedNumber
<new float> = <SVGAnimatedNumber>.baseVal;
<SVGAnimatedNumber>.baseVal = <fuzzint>;
<new float> = <SVGAnimatedNumber>.animVal;

#SVGForeignObjectElement
!extends SVGForeignObjectElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGForeignObjectElement>;
<new SVGAnimatedLength> = <SVGForeignObjectElement>.x;
<new SVGAnimatedLength> = <SVGForeignObjectElement>.y;
<new SVGAnimatedLength> = <SVGForeignObjectElement>.width;
<new SVGAnimatedLength> = <SVGForeignObjectElement>.height;
!extends SVGFECompositeElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFECompositeElement>;

#SVGFECompositeElement
!extends SVGFECompositeElement SVGElement
<new SVGElement> = <SVGFECompositeElement>;
<new SVGAnimatedString> = <SVGFECompositeElement>.in2;
<new SVGAnimatedString> = <SVGFECompositeElement>.in1;
<new SVGAnimatedEnumeration> = <SVGFECompositeElement>.operator;
<new SVGAnimatedNumber> = <SVGFECompositeElement>.k1;
<new SVGAnimatedNumber> = <SVGFECompositeElement>.k2;
<new SVGAnimatedNumber> = <SVGFECompositeElement>.k3;
<new SVGAnimatedNumber> = <SVGFECompositeElement>.k4;
!extends SVGFEDropShadowElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEDropShadowElement>;

#SVGFEDropShadowElement
!extends SVGFEDropShadowElement SVGElement
<new SVGElement> = <SVGFEDropShadowElement>;
<new SVGAnimatedString> = <SVGFEDropShadowElement>.in1;
<new SVGAnimatedNumber> = <SVGFEDropShadowElement>.dx;
<new SVGAnimatedNumber> = <SVGFEDropShadowElement>.dy;
<new SVGAnimatedNumber> = <SVGFEDropShadowElement>.stdDeviationX;
<new SVGAnimatedNumber> = <SVGFEDropShadowElement>.stdDeviationY;
<SVGFEDropShadowElement>.setStdDeviation(<float>,<float>);

#SVGSetElement
!extends SVGSetElement SVGAnimationElement
<new SVGAnimationElement> = <SVGSetElement>;

#SVGRect
<new float> = <SVGRect>.x;
<SVGRect>.x = <fuzzint>;
<new float> = <SVGRect>.y;
<SVGRect>.y = <fuzzint>;
<new float> = <SVGRect>.width;
<SVGRect>.width = <fuzzint>;
<new float> = <SVGRect>.height;
<SVGRect>.height = <fuzzint>;

#SVGAngle
<new short> = <SVGAngle>.unitType;
<new float> = <SVGAngle>.value;
<SVGAngle>.value = <float>;
<new float> = <SVGAngle>.valueInSpecifiedUnits;
<SVGAngle>.valueInSpecifiedUnits = <float>;
<new DOMString> = <SVGAngle>.valueAsString;
<SVGAngle>.valueAsString = <DOMString>;
<SVGAngle>.newValueSpecifiedUnits(<fuzzint>,<float>);
<SVGAngle>.convertToSpecifiedUnits(<fuzzint>);

#SVGPreserveAspectRatio
<new short> = <SVGPreserveAspectRatio>.align;
<SVGPreserveAspectRatio>.align = <fuzzint>;
<new short> = <SVGPreserveAspectRatio>.meetOrSlice;
<SVGPreserveAspectRatio>.meetOrSlice = <fuzzint>;
!extends SVGFilterElement SVGURIReference
<new SVGURIReference> = <SVGFilterElement>;

#SVGFilterElement
!extends SVGFilterElement SVGElement
<new SVGElement> = <SVGFilterElement>;
<new SVGAnimatedEnumeration> = <SVGFilterElement>.filterUnits;
<new SVGAnimatedEnumeration> = <SVGFilterElement>.primitiveUnits;
<new SVGAnimatedLength> = <SVGFilterElement>.x;
<new SVGAnimatedLength> = <SVGFilterElement>.y;
<new SVGAnimatedLength> = <SVGFilterElement>.width;
<new SVGAnimatedLength> = <SVGFilterElement>.height;

#SVGURIReference
<new SVGAnimatedString> = <SVGURIReference>.href;

#SVGClipPathElement
!extends SVGClipPathElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGClipPathElement>;
<new SVGAnimatedEnumeration> = <SVGClipPathElement>.clipPathUnits;
!extends SVGImageElement SVGURIReference
<new SVGURIReference> = <SVGImageElement>;

#SVGImageElement
!extends SVGImageElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGImageElement>;
<new SVGAnimatedLength> = <SVGImageElement>.x;
<new SVGAnimatedLength> = <SVGImageElement>.y;
<new SVGAnimatedLength> = <SVGImageElement>.width;
<new SVGAnimatedLength> = <SVGImageElement>.height;
<new SVGAnimatedPreserveAspectRatio> = <SVGImageElement>.preserveAspectRatio;

#SVGAnimatedTransformList
<new SVGTransformList> = <SVGAnimatedTransformList>.baseVal;
<new SVGTransformList> = <SVGAnimatedTransformList>.animVal;
!extends SVGFEGaussianBlurElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEGaussianBlurElement>;

#SVGFEGaussianBlurElement
!extends SVGFEGaussianBlurElement SVGElement
<new SVGElement> = <SVGFEGaussianBlurElement>;
<new SVGAnimatedString> = <SVGFEGaussianBlurElement>.in1;
<new SVGAnimatedNumber> = <SVGFEGaussianBlurElement>.stdDeviationX;
<new SVGAnimatedNumber> = <SVGFEGaussianBlurElement>.stdDeviationY;
<SVGFEGaussianBlurElement>.setStdDeviation(<float>,<float>);

#SVGTextPositioningElement
!extends SVGTextPositioningElement SVGTextContentElement
<new SVGTextContentElement> = <SVGTextPositioningElement>;
<new SVGAnimatedLengthList> = <SVGTextPositioningElement>.x;
<new SVGAnimatedLengthList> = <SVGTextPositioningElement>.y;
<new SVGAnimatedLengthList> = <SVGTextPositioningElement>.dx;
<new SVGAnimatedLengthList> = <SVGTextPositioningElement>.dy;
<new SVGAnimatedNumberList> = <SVGTextPositioningElement>.rotate;
!extends SVGFEFloodElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEFloodElement>;

#SVGFEFloodElement
!extends SVGFEFloodElement SVGElement
<new SVGElement> = <SVGFEFloodElement>;
!extends SVGMaskElement SVGTests
<new SVGTests> = <SVGMaskElement>;

#SVGMaskElement
!extends SVGMaskElement SVGElement
<new SVGElement> = <SVGMaskElement>;
<new SVGAnimatedEnumeration> = <SVGMaskElement>.maskUnits;
<new SVGAnimatedEnumeration> = <SVGMaskElement>.maskContentUnits;
<new SVGAnimatedLength> = <SVGMaskElement>.x;
<new SVGAnimatedLength> = <SVGMaskElement>.y;
<new SVGAnimatedLength> = <SVGMaskElement>.width;
<new SVGAnimatedLength> = <SVGMaskElement>.height;

#SVGMetadataElement
!extends SVGMetadataElement SVGElement
<new SVGElement> = <SVGMetadataElement>;

#SVGTitleElement
!extends SVGTitleElement SVGElement
<new SVGElement> = <SVGTitleElement>;

#SVGFEFuncAElement
!extends SVGFEFuncAElement SVGComponentTransferFunctionElement
<new SVGComponentTransferFunctionElement> = <SVGFEFuncAElement>;

#SVGFEDistantLightElement
!extends SVGFEDistantLightElement SVGElement
<new SVGElement> = <SVGFEDistantLightElement>;
<new SVGAnimatedNumber> = <SVGFEDistantLightElement>.azimuth;
<new SVGAnimatedNumber> = <SVGFEDistantLightElement>.elevation;

#SVGAnimatedNumberList
<new SVGNumberList> = <SVGAnimatedNumberList>.baseVal;
<new SVGNumberList> = <SVGAnimatedNumberList>.animVal;

#SVGFEFuncRElement
!extends SVGFEFuncRElement SVGComponentTransferFunctionElement
<new SVGComponentTransferFunctionElement> = <SVGFEFuncRElement>;

#SVGAnimatedAngle
<new SVGAngle> = <SVGAnimatedAngle>.baseVal;
<new SVGAngle> = <SVGAnimatedAngle>.animVal;
!extends SVGViewSpec SVGFitToViewBox
<new SVGFitToViewBox> = <SVGViewSpec>;
!extends SVGViewSpec SVGZoomAndPan
<new SVGZoomAndPan> = <SVGViewSpec>;

#SVGViewSpec
<new SVGTransformList> = <SVGViewSpec>.transform;
<new SVGElement> = <SVGViewSpec>.viewTarget;
<new DOMString> = <SVGViewSpec>.viewBoxString;
<new DOMString> = <SVGViewSpec>.preserveAspectRatioString;
<new DOMString> = <SVGViewSpec>.transformString;
<new DOMString> = <SVGViewSpec>.viewTargetString;
!extends SVGAElement SVGURIReference
<new SVGURIReference> = <SVGAElement>;

#SVGAElement
!extends SVGAElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGAElement>;
<new SVGAnimatedString> = <SVGAElement>.target;

#SVGAnimatedLength
<new SVGLength> = <SVGAnimatedLength>.baseVal;
<new SVGLength> = <SVGAnimatedLength>.animVal;
!extends SVGFEMorphologyElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEMorphologyElement>;

#SVGFEMorphologyElement
!extends SVGFEMorphologyElement SVGElement
<new SVGElement> = <SVGFEMorphologyElement>;
<new SVGAnimatedString> = <SVGFEMorphologyElement>.in1;
<new SVGAnimatedEnumeration> = <SVGFEMorphologyElement>.operator;
<new SVGAnimatedNumber> = <SVGFEMorphologyElement>.radiusX;
<new SVGAnimatedNumber> = <SVGFEMorphologyElement>.radiusY;

#SVGLength
<new short> = <SVGLength>.unitType;
<new float> = <SVGLength>.value;
<SVGLength>.value = <fuzzint>;
<new float> = <SVGLength>.valueInSpecifiedUnits;
<SVGLength>.valueInSpecifiedUnits = <fuzzint>;
<new DOMString> = <SVGLength>.valueAsString;
<SVGLength>.valueAsString = <DOMString>;
<SVGLength>.newValueSpecifiedUnits(<fuzzint>,<fuzzint>);
<SVGLength>.convertToSpecifiedUnits(<fuzzint>);
!extends SVGMarkerElement SVGFitToViewBox
<new SVGFitToViewBox> = <SVGMarkerElement>;

#SVGMarkerElement
!extends SVGMarkerElement SVGElement
<new SVGElement> = <SVGMarkerElement>;
<new SVGAnimatedLength> = <SVGMarkerElement>.refX;
<new SVGAnimatedLength> = <SVGMarkerElement>.refY;
<new SVGAnimatedEnumeration> = <SVGMarkerElement>.markerUnits;
<new SVGAnimatedLength> = <SVGMarkerElement>.markerWidth;
<new SVGAnimatedLength> = <SVGMarkerElement>.markerHeight;
<new SVGAnimatedEnumeration> = <SVGMarkerElement>.orientType;
<new SVGAnimatedAngle> = <SVGMarkerElement>.orientAngle;
<SVGMarkerElement>.setOrientToAuto();
<SVGMarkerElement>.setOrientToAngle(<SVGAngle>);

#SVGDefsElement
!extends SVGDefsElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGDefsElement>;
!extends SVGAnimationElement SVGTests
<new SVGTests> = <SVGAnimationElement>;

#SVGAnimationElement
!extends SVGAnimationElement SVGElement
<new SVGElement> = <SVGAnimationElement>;
<new SVGElement> = <SVGAnimationElement>.targetElement;
<new EventHandler> = <SVGAnimationElement>.onbegin;
<SVGAnimationElement>.onbegin = <EventHandler>;
<new EventHandler> = <SVGAnimationElement>.onend;
<SVGAnimationElement>.onend = <EventHandler>;
<new EventHandler> = <SVGAnimationElement>.onrepeat;
<SVGAnimationElement>.onrepeat = <EventHandler>;
<new float> = <SVGAnimationElement>.getStartTime();
<new float> = <SVGAnimationElement>.getCurrentTime();
<new float> = <SVGAnimationElement>.getSimpleDuration();
<SVGAnimationElement>.beginElement();
<SVGAnimationElement>.beginElementAt(<float>);
<SVGAnimationElement>.endElement();
<SVGAnimationElement>.endElementAt(<float>);

#SVGFitToViewBox
<new SVGAnimatedRect> = <SVGFitToViewBox>.viewBox;
<new SVGAnimatedPreserveAspectRatio> = <SVGFitToViewBox>.preserveAspectRatio;

#SVGPoint
<new float> = <SVGPoint>.x;
<SVGPoint>.x = <fuzzint>;
<new float> = <SVGPoint>.y;
<SVGPoint>.y = <fuzzint>;
<new SVGPoint> = <SVGPoint>.matrixTransform(<SVGMatrix>);
!extends SVGUseElement SVGURIReference
<new SVGURIReference> = <SVGUseElement>;

#SVGUseElement
!extends SVGUseElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGUseElement>;
<new SVGAnimatedLength> = <SVGUseElement>.x;
<new SVGAnimatedLength> = <SVGUseElement>.y;
<new SVGAnimatedLength> = <SVGUseElement>.width;
<new SVGAnimatedLength> = <SVGUseElement>.height;

#SVGPolygonElement
!extends SVGPolygonElement SVGGeometryElement
<new SVGGeometryElement> = <SVGPolygonElement>;
<new SVGPointList> = <SVGPolygonElement>.points;
<new SVGPointList> = <SVGPolygonElement>.animatedPoints;
!extends SVGSymbolElement SVGFitToViewBox
<new SVGFitToViewBox> = <SVGSymbolElement>;

#SVGSymbolElement
!extends SVGSymbolElement SVGElement
<new SVGElement> = <SVGSymbolElement>;

#SVGAnimatedPreserveAspectRatio
<new SVGPreserveAspectRatio> = <SVGAnimatedPreserveAspectRatio>.baseVal;
<new SVGPreserveAspectRatio> = <SVGAnimatedPreserveAspectRatio>.animVal;

#SVGTextElement
!extends SVGTextElement SVGTextPositioningElement
<new SVGTextPositioningElement> = <SVGTextElement>;
!extends SVGFEMergeElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEMergeElement>;

#SVGFEMergeElement
!extends SVGFEMergeElement SVGElement
<new SVGElement> = <SVGFEMergeElement>;
!extends SVGFEImageElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEImageElement>;
!extends SVGFEImageElement SVGURIReference
<new SVGURIReference> = <SVGFEImageElement>;

#SVGFEImageElement
!extends SVGFEImageElement SVGElement
<new SVGElement> = <SVGFEImageElement>;
<new SVGAnimatedPreserveAspectRatio> = <SVGFEImageElement>.preserveAspectRatio;

#SVGStringList
<new long> = <SVGStringList>.length;
<new long> = <SVGStringList>.numberOfItems;
<SVGStringList>.clear();
<new DOMString> = <SVGStringList>.initialize(<DOMString>);
<new DOMString> = <SVGStringList>.getItem(<fuzzint>);
<new DOMString> = <SVGStringList>.insertItemBefore(<DOMString>,<fuzzint>);
<new DOMString> = <SVGStringList>.replaceItem(<DOMString>,<fuzzint>);
<new DOMString> = <SVGStringList>.removeItem(<fuzzint>);
<new DOMString> = <SVGStringList>.appendItem(<DOMString>);
<SVGStringList>[<fuzzint>] = <DOMString>;

#SVGLineElement
!extends SVGLineElement SVGGeometryElement
<new SVGGeometryElement> = <SVGLineElement>;
<new SVGAnimatedLength> = <SVGLineElement>.x1;
<new SVGAnimatedLength> = <SVGLineElement>.y1;
<new SVGAnimatedLength> = <SVGLineElement>.x2;
<new SVGAnimatedLength> = <SVGLineElement>.y2;
!extends SVGFEDiffuseLightingElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEDiffuseLightingElement>;

#SVGFEDiffuseLightingElement
!extends SVGFEDiffuseLightingElement SVGElement
<new SVGElement> = <SVGFEDiffuseLightingElement>;
<new SVGAnimatedString> = <SVGFEDiffuseLightingElement>.in1;
<new SVGAnimatedNumber> = <SVGFEDiffuseLightingElement>.surfaceScale;
<new SVGAnimatedNumber> = <SVGFEDiffuseLightingElement>.diffuseConstant;
<new SVGAnimatedNumber> = <SVGFEDiffuseLightingElement>.kernelUnitLengthX;
<new SVGAnimatedNumber> = <SVGFEDiffuseLightingElement>.kernelUnitLengthY;

#SVGPointList
<new long> = <SVGPointList>.length;
<new long> = <SVGPointList>.numberOfItems;
<SVGPointList>.clear();
<new SVGPoint> = <SVGPointList>.initialize(<SVGPoint>);
<new SVGPoint> = <SVGPointList>.getItem(<fuzzint>);
<new SVGPoint> = <SVGPointList>.insertItemBefore(<SVGPoint>,<fuzzint>);
<new SVGPoint> = <SVGPointList>.replaceItem(<SVGPoint>,<fuzzint>);
<new SVGPoint> = <SVGPointList>.removeItem(<fuzzint>);
<new SVGPoint> = <SVGPointList>.appendItem(<SVGPoint>);
<SVGPointList>[<fuzzint>] = <SVGPoint>;

#SVGUnitTypes

#SVGPolylineElement
!extends SVGPolylineElement SVGGeometryElement
<new SVGGeometryElement> = <SVGPolylineElement>;
<new SVGPointList> = <SVGPolylineElement>.points;
<new SVGPointList> = <SVGPolylineElement>.animatedPoints;

#SVGAnimatedBoolean
<new boolean> = <SVGAnimatedBoolean>.baseVal;
<SVGAnimatedBoolean>.baseVal = <boolean>;
<new boolean> = <SVGAnimatedBoolean>.animVal;

#SVGComponentTransferFunctionElement
!extends SVGComponentTransferFunctionElement SVGElement
<new SVGElement> = <SVGComponentTransferFunctionElement>;
<new SVGAnimatedEnumeration> = <SVGComponentTransferFunctionElement>.type;
<new SVGAnimatedNumberList> = <SVGComponentTransferFunctionElement>.tableValues;
<new SVGAnimatedNumber> = <SVGComponentTransferFunctionElement>.slope;
<new SVGAnimatedNumber> = <SVGComponentTransferFunctionElement>.intercept;
<new SVGAnimatedNumber> = <SVGComponentTransferFunctionElement>.amplitude;
<new SVGAnimatedNumber> = <SVGComponentTransferFunctionElement>.exponent;
<new SVGAnimatedNumber> = <SVGComponentTransferFunctionElement>.offset;
!extends SVGFESpecularLightingElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFESpecularLightingElement>;

#SVGFESpecularLightingElement
!extends SVGFESpecularLightingElement SVGElement
<new SVGElement> = <SVGFESpecularLightingElement>;
<new SVGAnimatedString> = <SVGFESpecularLightingElement>.in1;
<new SVGAnimatedNumber> = <SVGFESpecularLightingElement>.surfaceScale;
<new SVGAnimatedNumber> = <SVGFESpecularLightingElement>.specularConstant;
<new SVGAnimatedNumber> = <SVGFESpecularLightingElement>.specularExponent;
<new SVGAnimatedNumber> = <SVGFESpecularLightingElement>.kernelUnitLengthX;
<new SVGAnimatedNumber> = <SVGFESpecularLightingElement>.kernelUnitLengthY;

#SVGGeometryElement
!extends SVGGeometryElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGGeometryElement>;
<new boolean> = <SVGGeometryElement>.isPointInFill(<SVGPoint>);
<new boolean> = <SVGGeometryElement>.isPointInStroke(<SVGPoint>);
!extends SVGFEConvolveMatrixElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEConvolveMatrixElement>;

#SVGFEConvolveMatrixElement
!extends SVGFEConvolveMatrixElement SVGElement
<new SVGElement> = <SVGFEConvolveMatrixElement>;
<new SVGAnimatedString> = <SVGFEConvolveMatrixElement>.in1;
<new SVGAnimatedInteger> = <SVGFEConvolveMatrixElement>.orderX;
<new SVGAnimatedInteger> = <SVGFEConvolveMatrixElement>.orderY;
<new SVGAnimatedNumberList> = <SVGFEConvolveMatrixElement>.kernelMatrix;
<new SVGAnimatedNumber> = <SVGFEConvolveMatrixElement>.divisor;
<new SVGAnimatedNumber> = <SVGFEConvolveMatrixElement>.bias;
<new SVGAnimatedInteger> = <SVGFEConvolveMatrixElement>.targetX;
<new SVGAnimatedInteger> = <SVGFEConvolveMatrixElement>.targetY;
<new SVGAnimatedEnumeration> = <SVGFEConvolveMatrixElement>.edgeMode;
<new SVGAnimatedNumber> = <SVGFEConvolveMatrixElement>.kernelUnitLengthX;
<new SVGAnimatedNumber> = <SVGFEConvolveMatrixElement>.kernelUnitLengthY;
<new SVGAnimatedBoolean> = <SVGFEConvolveMatrixElement>.preserveAlpha;

#SVGFilterPrimitiveStandardAttributes
<new SVGAnimatedLength> = <SVGFilterPrimitiveStandardAttributes>.x;
<new SVGAnimatedLength> = <SVGFilterPrimitiveStandardAttributes>.y;
<new SVGAnimatedLength> = <SVGFilterPrimitiveStandardAttributes>.width;
<new SVGAnimatedLength> = <SVGFilterPrimitiveStandardAttributes>.height;
<new SVGAnimatedString> = <SVGFilterPrimitiveStandardAttributes>.result;

#SVGEllipseElement
!extends SVGEllipseElement SVGGeometryElement
<new SVGGeometryElement> = <SVGEllipseElement>;
<new SVGAnimatedLength> = <SVGEllipseElement>.cx;
<new SVGAnimatedLength> = <SVGEllipseElement>.cy;
<new SVGAnimatedLength> = <SVGEllipseElement>.rx;
<new SVGAnimatedLength> = <SVGEllipseElement>.ry;
!extends SVGFEOffsetElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEOffsetElement>;

#SVGFEOffsetElement
!extends SVGFEOffsetElement SVGElement
<new SVGElement> = <SVGFEOffsetElement>;
<new SVGAnimatedString> = <SVGFEOffsetElement>.in1;
<new SVGAnimatedNumber> = <SVGFEOffsetElement>.dx;
<new SVGAnimatedNumber> = <SVGFEOffsetElement>.dy;

#SVGTransform
<new short> = <SVGTransform>.type;
<new SVGMatrix> = <SVGTransform>.matrix;
<new float> = <SVGTransform>.angle;
<SVGTransform>.setMatrix(<SVGMatrix>);
<SVGTransform>.setTranslate(<fuzzint>,<fuzzint>);
<SVGTransform>.setScale(<fuzzint>,<fuzzint>);
<SVGTransform>.setRotate(<float>,<float>,<float>);
<SVGTransform>.setSkewX(<float>);
<SVGTransform>.setSkewY(<float>);
!extends SVGFEBlendElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFEBlendElement>;

#SVGFEBlendElement
!extends SVGFEBlendElement SVGElement
<new SVGElement> = <SVGFEBlendElement>;
<new SVGAnimatedString> = <SVGFEBlendElement>.in1;
<new SVGAnimatedString> = <SVGFEBlendElement>.in2;
<new SVGAnimatedEnumeration> = <SVGFEBlendElement>.mode;

#SVGStopElement
!extends SVGStopElement SVGElement
<new SVGElement> = <SVGStopElement>;
<new SVGAnimatedNumber> = <SVGStopElement>.offset;

#SVGLengthList
<new long> = <SVGLengthList>.length;
<new long> = <SVGLengthList>.numberOfItems;
<SVGLengthList>.clear();
<new SVGLength> = <SVGLengthList>.initialize(<SVGLength>);
<new SVGLength> = <SVGLengthList>.getItem(<fuzzint>);
<new SVGLength> = <SVGLengthList>.insertItemBefore(<SVGLength>,<fuzzint>);
<new SVGLength> = <SVGLengthList>.replaceItem(<SVGLength>,<fuzzint>);
<new SVGLength> = <SVGLengthList>.removeItem(<fuzzint>);
<new SVGLength> = <SVGLengthList>.appendItem(<SVGLength>);
<SVGLengthList>[<fuzzint>] = <SVGLength>;

#SVGFEFuncBElement
!extends SVGFEFuncBElement SVGComponentTransferFunctionElement
<new SVGComponentTransferFunctionElement> = <SVGFEFuncBElement>;

#SVGAnimatedEnumeration
<new short> = <SVGAnimatedEnumeration>.baseVal;
<SVGAnimatedEnumeration>.baseVal = <fuzzint>;
<new short> = <SVGAnimatedEnumeration>.animVal;

#SVGFEMergeNodeElement
!extends SVGFEMergeNodeElement SVGElement
<new SVGElement> = <SVGFEMergeNodeElement>;
<new SVGAnimatedString> = <SVGFEMergeNodeElement>.in1;

#SVGCircleElement
!extends SVGCircleElement SVGGeometryElement
<new SVGGeometryElement> = <SVGCircleElement>;
<new SVGAnimatedLength> = <SVGCircleElement>.cx;
<new SVGAnimatedLength> = <SVGCircleElement>.cy;
<new SVGAnimatedLength> = <SVGCircleElement>.r;
!extends SVGScriptElement SVGURIReference
<new SVGURIReference> = <SVGScriptElement>;

#SVGScriptElement
!extends SVGScriptElement SVGElement
<new SVGElement> = <SVGScriptElement>;
<new DOMString> = <SVGScriptElement>.type;
<SVGScriptElement>.type = <DOMString>;
!extends SVGMPathElement SVGURIReference
<new SVGURIReference> = <SVGMPathElement>;

#SVGMPathElement
!extends SVGMPathElement SVGElement
<new SVGElement> = <SVGMPathElement>;

#SVGGElement
!extends SVGGElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGGElement>;
!extends SVGCursorElement SVGURIReference
<new SVGURIReference> = <SVGCursorElement>;
!extends SVGCursorElement SVGTests
<new SVGTests> = <SVGCursorElement>;

#SVGCursorElement
!extends SVGCursorElement SVGElement
<new SVGElement> = <SVGCursorElement>;
<new SVGAnimatedLength> = <SVGCursorElement>.x;
<new SVGAnimatedLength> = <SVGCursorElement>.y;

#SVGPathElement
!extends SVGPathElement SVGGeometryElement
<new SVGGeometryElement> = <SVGPathElement>;
<new SVGAnimatedNumber> = <SVGPathElement>.pathLength;
<new float> = <SVGPathElement>.getTotalLength();
<new SVGPoint> = <SVGPathElement>.getPointAtLength(<fuzzint>);
<new long> = <SVGPathElement>.getPathSegAtLength(<fuzzint>);

#SVGTSpanElement
!extends SVGTSpanElement SVGTextPositioningElement
<new SVGTextPositioningElement> = <SVGTSpanElement>;

#SVGAnimatedString
<new DOMString> = <SVGAnimatedString>.baseVal;
<SVGAnimatedString>.baseVal = <DOMString>;
<new DOMString> = <SVGAnimatedString>.animVal;
!extends SVGFETurbulenceElement SVGFilterPrimitiveStandardAttributes
<new SVGFilterPrimitiveStandardAttributes> = <SVGFETurbulenceElement>;

#SVGFETurbulenceElement
!extends SVGFETurbulenceElement SVGElement
<new SVGElement> = <SVGFETurbulenceElement>;
<new SVGAnimatedNumber> = <SVGFETurbulenceElement>.baseFrequencyX;
<new SVGAnimatedNumber> = <SVGFETurbulenceElement>.baseFrequencyY;
<new SVGAnimatedInteger> = <SVGFETurbulenceElement>.numOctaves;
<new SVGAnimatedNumber> = <SVGFETurbulenceElement>.seed;
<new SVGAnimatedEnumeration> = <SVGFETurbulenceElement>.stitchTiles;
<new SVGAnimatedEnumeration> = <SVGFETurbulenceElement>.type;

#SVGSwitchElement
!extends SVGSwitchElement SVGGraphicsElement
<new SVGGraphicsElement> = <SVGSwitchElement>;

#SVGStyleElement
!extends SVGStyleElement SVGElement
<new SVGElement> = <SVGStyleElement>;
<new DOMString> = <SVGStyleElement>.type;
<SVGStyleElement>.type = <DOMString>;
<new DOMString> = <SVGStyleElement>.media;
<SVGStyleElement>.media = <DOMString>;
<new DOMString> = <SVGStyleElement>.title;
<SVGStyleElement>.title = <DOMString>;
<new StyleSheet> = <SVGStyleElement>.sheet;
<new boolean> = <SVGStyleElement>.disabled;
<SVGStyleElement>.disabled = <boolean>;

<new svg_href_path> = "<hash>" + <SVGPathElement>.id;

<new svg_url_clippath> = "url(<hash>" + <SVGClipPathElement>.id + ")";
<new svg_url_filter> = "url(<hash>" + <SVGFilterElement>.id + ")";
<new svg_url_marker> = "url(<hash>" + <SVGMarkerElement>.id + ")";
<new svg_url_mask> = "url(<hash>" + <SVGMaskElement>.id + ")";
<new svg_url_fill> = "url(<hash>" + <SVGLinearGradientElement>.id + ")";
<new svg_url_fill> = "url(<hash>" + <SVGPatternElement>.id + ")";
<new svg_url_fill> = "url(<hash>" + <SVGRadialGradientElement>.id + ")";

<SVGMPathElement>.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", <svg_href_path>);
<SVGTextPathElement>.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", <svg_href_path>);

<SVGElement>.setAttribute("accumulate", "<svgattr_accumulate_value>");
<SVGElement>.setAttribute("additive", "<svgattr_additive_value>");
<SVGElement>.setAttribute("alignment-baseline", "<svgattr_alignment-baseline_value>");
<SVGElement>.setAttribute("alphabetic", "<svgattr_alphabetic_value>");
<SVGElement>.setAttribute("alt", "<svgattr_alt_value>");
<SVGElement>.setAttribute("amplitude", "<svgattr_amplitude_value>");
<SVGElement>.setAttribute("arabic-form", "<svgattr_arabic-form_value>");
<SVGElement>.setAttribute("aria-label", "<svgattr_aria-label_value>");
<SVGElement>.setAttribute("ascent", "<svgattr_ascent_value>");
<SVGElement>.setAttribute("attributeName", "<svgattr_attributeName_value>");
<SVGElement>.setAttribute("attributeType", "<svgattr_attributeType_value>");
<SVGElement>.setAttribute("azimuth", "<svgattr_azimuth_value>");
<SVGElement>.setAttribute("baseFrequency", "<svgattr_baseFrequency_value>");
<SVGElement>.setAttribute("baseProfile", "<svgattr_baseProfile_value>");
<SVGElement>.setAttribute("baseline-shift", "<svgattr_baseline-shift_value>");
<SVGElement>.setAttribute("bbox", "<svgattr_bbox_value>");
<SVGElement>.setAttribute("begin", "<svgattr_begin_value>");
<SVGElement>.setAttribute("by", "<svgattr_by_value>");
<SVGElement>.setAttribute("calcMode", "<svgattr_calcMode_value>");
<SVGElement>.setAttribute("cap-height", "<svgattr_cap-height_value>");
<SVGElement>.setAttribute("class", "<svgattr_class_value>");
<SVGElement>.setAttribute("click", "<svgattr_click_value>");
<SVGElement>.setAttribute("clip", "<svgattr_clip_value>");
<SVGElement>.setAttribute("clip-path", svg_url_clippath);
<SVGElement>.setAttribute("clip-rule", "<svgattr_clip-rule_value>");
<SVGElement>.setAttribute("clipPathUnits", "<svgattr_clipPathUnits_value>");
<SVGElement>.setAttribute("color", "<svgattr_color_value>");
<SVGElement>.setAttribute("color-interpolation", "<svgattr_color-interpolation_value>");
<SVGElement>.setAttribute("color-interpolation-filters", "<svgattr_color-interpolation-filters_value>");
<SVGElement>.setAttribute("color-profile", "<svgattr_color-profile_value>");
<SVGElement>.setAttribute("contentScriptType", "<svgattr_contentScriptType_value>");
<SVGElement>.setAttribute("contentStyleType", "<svgattr_contentStyleType_value>");
<SVGElement>.setAttribute("cursor", "<svgattr_cursor_value>");
<SVGElement>.setAttribute("cx", "<svgattr_cx_value>");
<SVGElement>.setAttribute("cy", "<svgattr_cy_value>");
<SVGElement>.setAttribute("d", "<svgattr_d_value>");
<SVGElement>.setAttribute("descent", "<svgattr_descent_value>");
<SVGElement>.setAttribute("diffuseConstant", "<svgattr_diffuseConstant_value>");
<SVGElement>.setAttribute("direction", "<svgattr_direction_value>");
<SVGElement>.setAttribute("display", "<svgattr_display_value>");
<SVGElement>.setAttribute("divisor", "<svgattr_divisor_value>");
<SVGElement>.setAttribute("dominant-baseline", "<svgattr_dominant-baseline_value>");
<SVGElement>.setAttribute("dur", "<svgattr_dur_value>");
<SVGElement>.setAttribute("dx", "<svgattr_dx_value>");
<SVGElement>.setAttribute("dy", "<svgattr_dy_value>");
<SVGElement>.setAttribute("edgeMode", "<svgattr_edgeMode_value>");
<SVGElement>.setAttribute("elevation", "<svgattr_elevation_value>");
<SVGElement>.setAttribute("enable-background", "<svgattr_enable-background_value>");
<SVGElement>.setAttribute("end", "<svgattr_end_value>");
<SVGElement>.setAttribute("exponent", "<svgattr_exponent_value>");
<SVGElement>.setAttribute("externalResourcesRequired", "<svgattr_externalResourcesRequired_value>");
<SVGElement>.setAttribute("fill", <svg_url_fill>);
<SVGElement>.setAttribute("fill", "<svgattr_fill_value>");
<SVGElement>.setAttribute("fill-opacity", "<svgattr_fill-opacity_value>");
<SVGElement>.setAttribute("fill-rule", "<svgattr_fill-rule_value>");
<SVGElement>.setAttribute("filter", <svg_url_filter>);
<SVGElement>.setAttribute("filterPrimitiveUnits", "<svgattr_filterPrimitiveUnits_value>");
<SVGElement>.setAttribute("filterRes", "<svgattr_filterRes_value>");
<SVGElement>.setAttribute("filterUnits", "<svgattr_filterUnits_value>");
<SVGElement>.setAttribute("flood-color", "<svgattr_flood-color_value>");
<SVGElement>.setAttribute("flood-opacity", "<svgattr_flood-opacity_value>");
<SVGElement>.setAttribute("font-family", "<svgattr_font-family_value>");
<SVGElement>.setAttribute("font-rendering", "<svgattr_font-rendering_value>");
<SVGElement>.setAttribute("font-size", "<svgattr_font-size_value>");
<SVGElement>.setAttribute("font-stretch", "<svgattr_font-stretch_value>");
<SVGElement>.setAttribute("font-style", "<svgattr_font-style_value>");
<SVGElement>.setAttribute("font-variant", "<svgattr_font-variant_value>");
<SVGElement>.setAttribute("font-weight", "<svgattr_font-weight_value>");
<SVGElement>.setAttribute("fr", "<svgattr_fr_value>");
<SVGElement>.setAttribute("from", "<svgattr_from_value>");
<SVGElement>.setAttribute("fx", "<svgattr_fx_value>");
<SVGElement>.setAttribute("fy", "<svgattr_fy_value>");
<SVGElement>.setAttribute("g1", "<svgattr_g1_value>");
<SVGElement>.setAttribute("g2", "<svgattr_g2_value>");
<SVGElement>.setAttribute("glyph-name", "<svgattr_glyph-name_value>");
<SVGElement>.setAttribute("glyph-orientation-horizontal", "<svgattr_glyph-orientation-horizontal_value>");
<SVGElement>.setAttribute("glyph-orientation-vertical", "<svgattr_glyph-orientation-vertical_value>");
<SVGElement>.setAttribute("glyphRef", "<svgattr_glyphRef_value>");
<SVGElement>.setAttribute("gradientTransform", "<svgattr_gradientTransform_value>");
<SVGElement>.setAttribute("gradientUnits", "<svgattr_gradientUnits_value>");
<SVGElement>.setAttribute("hanging", "<svgattr_hanging_value>");
<SVGElement>.setAttribute("height", "<svgattr_height_value>");
<SVGElement>.setAttribute("horiz-adv-x", "<svgattr_horiz-adv-x_value>");
<SVGElement>.setAttribute("horiz-origin-x", "<svgattr_horiz-origin-x_value>");
<SVGElement>.setAttribute("href", "<svgattr_href_value>");
<SVGElement>.setAttribute("id", "<svgelementid>");
<SVGElement>.setAttribute("ideographic", "<svgattr_ideographic_value>");
<SVGElement>.setAttribute("in", "<svgattr_in_value>");
<SVGElement>.setAttribute("in2", "<svgattr_in2_value>");
<SVGElement>.setAttribute("intercept", "<svgattr_intercept_value>");
<SVGElement>.setAttribute("k", "<svgattr_k_value>");
<SVGElement>.setAttribute("k1", "<svgattr_k1_value>");
<SVGElement>.setAttribute("k2", "<svgattr_k2_value>");
<SVGElement>.setAttribute("k3", "<svgattr_k3_value>");
<SVGElement>.setAttribute("k4", "<svgattr_k4_value>");
<SVGElement>.setAttribute("kernelMatrix", "<svgattr_kernelMatrix_value>");
<SVGElement>.setAttribute("kernelUnitLength", "<svgattr_kernelUnitLength_value>");
<SVGElement>.setAttribute("keyPoints", "<svgattr_keyPoints_value>");
<SVGElement>.setAttribute("keySplines", "<svgattr_keySplines_value>");
<SVGElement>.setAttribute("keyTimes", "<svgattr_keyTimes_value>");
<SVGElement>.setAttribute("lang", "<svgattr_lang_value>");
<SVGElement>.setAttribute("lengthAdjust", "<svgattr_lengthAdjust_value>");
<SVGElement>.setAttribute("letter-spacing", "<svgattr_letter-spacing_value>");
<SVGElement>.setAttribute("lighting-color", "<svgattr_lighting-color_value>");
<SVGElement>.setAttribute("limitingConeAngle", "<svgattr_limitingConeAngle_value>");
<SVGElement>.setAttribute("line-width", "<svgattr_line-width_value>");
<SVGElement>.setAttribute("marker-end", <svg_url_marker>);
<SVGElement>.setAttribute("marker-mid", <svg_url_marker>);
<SVGElement>.setAttribute("marker-start", <svg_url_marker>);
<SVGElement>.setAttribute("markerHeight", "<svgattr_markerHeight_value>");
<SVGElement>.setAttribute("markerUnits", "<svgattr_markerUnits_value>");
<SVGElement>.setAttribute("markerWidth", "<svgattr_markerWidth_value>");
<SVGElement>.setAttribute("mask", <svg_url_mask>);
<SVGElement>.setAttribute("mask-type", "<svgattr_mask-type_value>");
<SVGElement>.setAttribute("maskContentUnits", "<svgattr_maskContentUnits_value>");
<SVGElement>.setAttribute("maskUnits", "<svgattr_maskUnits_value>");
<SVGElement>.setAttribute("mathematical", "<svgattr_mathematical_value>");
<SVGElement>.setAttribute("max", "<svgattr_max_value>");
<SVGElement>.setAttribute("min", "<svgattr_min_value>");
<SVGElement>.setAttribute("mode", "<svgattr_mode_value>");
<SVGElement>.setAttribute("name", "<svgattr_name_value>");
<SVGElement>.setAttribute("numOctaves", "<svgattr_numOctaves_value>");
<SVGElement>.setAttribute("offset", "<svgattr_offset_value>");
<SVGElement>.setAttribute("onactivate", "<svgattr_onactivate_value>");
<SVGElement>.setAttribute("onbegin", "<svgattr_onbegin_value>");
<SVGElement>.setAttribute("onclick", "<svgattr_onclick_value>");
<SVGElement>.setAttribute("onend", "<svgattr_onend_value>");
<SVGElement>.setAttribute("onerror", "<svgattr_onerror_value>");
<SVGElement>.setAttribute("onfocusin", "<svgattr_onfocusin_value>");
<SVGElement>.setAttribute("onfocusout", "<svgattr_onfocusout_value>");
<SVGElement>.setAttribute("onload", "<svgattr_onload_value>");
<SVGElement>.setAttribute("onmousedown", "<svgattr_onmousedown_value>");
<SVGElement>.setAttribute("onmousemove", "<svgattr_onmousemove_value>");
<SVGElement>.setAttribute("onmouseout", "<svgattr_onmouseout_value>");
<SVGElement>.setAttribute("onmouseover", "<svgattr_onmouseover_value>");
<SVGElement>.setAttribute("onmouseup", "<svgattr_onmouseup_value>");
<SVGElement>.setAttribute("onrepeat", "<svgattr_onrepeat_value>");
<SVGElement>.setAttribute("opacity", "<svgattr_opacity_value>");
<SVGElement>.setAttribute("operator", "<svgattr_operator_value>");
<SVGElement>.setAttribute("order", "<svgattr_order_value>");
<SVGElement>.setAttribute("orient", "<svgattr_orient_value>");
<SVGElement>.setAttribute("overflow", "<svgattr_overflow_value>");
<SVGElement>.setAttribute("panose-1", "<svgattr_panose-1_value>");
<SVGElement>.setAttribute("path", "<svgattr_path_value>");
<SVGElement>.setAttribute("pathLength", "<svgattr_pathLength_value>");
<SVGElement>.setAttribute("patternContentUnits", "<svgattr_patternContentUnits_value>");
<SVGElement>.setAttribute("patternTransform", "<svgattr_patternTransform_value>");
<SVGElement>.setAttribute("patternUnits", "<svgattr_patternUnits_value>");
<SVGElement>.setAttribute("pointer-events", "<svgattr_pointer-events_value>");
<SVGElement>.setAttribute("points", "<svgattr_points_value>");
<SVGElement>.setAttribute("pointsAtX", "<svgattr_pointsAtX_value>");
<SVGElement>.setAttribute("pointsAtY", "<svgattr_pointsAtY_value>");
<SVGElement>.setAttribute("pointsAtZ", "<svgattr_pointsAtZ_value>");
<SVGElement>.setAttribute("preserveAlpha", "<svgattr_preserveAlpha_value>");
<SVGElement>.setAttribute("preserveAspectRatio", "<svgattr_preserveAspectRatio_value>");
<SVGElement>.setAttribute("primitiveUnits", "<svgattr_primitiveUnits_value>");
<SVGElement>.setAttribute("r", "<svgattr_r_value>");
<SVGElement>.setAttribute("radius", "<svgattr_radius_value>");
<SVGElement>.setAttribute("refX", "<svgattr_refX_value>");
<SVGElement>.setAttribute("refY", "<svgattr_refY_value>");
<SVGElement>.setAttribute("repeatCount", "<svgattr_repeatCount_value>");
<SVGElement>.setAttribute("repeatDur", "<svgattr_repeatDur_value>");
<SVGElement>.setAttribute("requiredExtensions", "<svgattr_requiredExtensions_value>");
<SVGElement>.setAttribute("requiredFeatures", "<svgattr_requiredFeatures_value>");
<SVGElement>.setAttribute("restart", "<svgattr_restart_value>");
<SVGElement>.setAttribute("result", "<svgattr_result_value>");
<SVGElement>.setAttribute("role", "<svgattr_role_value>");
<SVGElement>.setAttribute("rotate", "<svgattr_rotate_value>");
<SVGElement>.setAttribute("rx", "<svgattr_rx_value>");
<SVGElement>.setAttribute("ry", "<svgattr_ry_value>");
<SVGElement>.setAttribute("scale", "<svgattr_scale_value>");
<SVGElement>.setAttribute("seed", "<svgattr_seed_value>");
<SVGElement>.setAttribute("shape-rendering", "<svgattr_shape-rendering_value>");
<SVGElement>.setAttribute("slope", "<svgattr_slope_value>");
<SVGElement>.setAttribute("specularConstant", "<svgattr_specularConstant_value>");
<SVGElement>.setAttribute("specularExponent", "<svgattr_specularExponent_value>");
<SVGElement>.setAttribute("spreadMethod", "<svgattr_spreadMethod_value>");
<SVGElement>.setAttribute("startOffset", "<svgattr_startOffset_value>");
<SVGElement>.setAttribute("stdDeviation", "<svgattr_stdDeviation_value>");
<SVGElement>.setAttribute("stitchTiles", "<svgattr_stitchTiles_value>");
<SVGElement>.setAttribute("stop-color", "<svgattr_stop-color_value>");
<SVGElement>.setAttribute("stop-offset", "<svgattr_stop-offset_value>");
<SVGElement>.setAttribute("stop-opacity", "<svgattr_stop-opacity_value>");
<SVGElement>.setAttribute("stroke", <svg_url_fill>);
<SVGElement>.setAttribute("stroke", "<svgattr_stroke_value>");
<SVGElement>.setAttribute("stroke-dasharray", "<svgattr_stroke-dasharray_value>");
<SVGElement>.setAttribute("stroke-dashoffset", "<svgattr_stroke-dashoffset_value>");
<SVGElement>.setAttribute("stroke-join", "<svgattr_stroke-join_value>");
<SVGElement>.setAttribute("stroke-linecap", "<svgattr_stroke-linecap_value>");
<SVGElement>.setAttribute("stroke-linejoin", "<svgattr_stroke-linejoin_value>");
<SVGElement>.setAttribute("stroke-miterlimit", "<svgattr_stroke-miterlimit_value>");
<SVGElement>.setAttribute("stroke-opacity", "<svgattr_stroke-opacity_value>");
<SVGElement>.setAttribute("stroke-width", "<svgattr_stroke-width_value>");
<SVGElement>.setAttribute("style", "<svgattr_style_value>");
<SVGElement>.setAttribute("surfaceScale", "<svgattr_surfaceScale_value>");
<SVGElement>.setAttribute("systemLanguage", "<svgattr_systemLanguage_value>");
<SVGElement>.setAttribute("tabindex", "<svgattr_tabindex_value>");
<SVGElement>.setAttribute("tableValues", "<svgattr_tableValues_value>");
<SVGElement>.setAttribute("target", "<svgattr_target_value>");
<SVGElement>.setAttribute("targetX", "<svgattr_targetX_value>");
<SVGElement>.setAttribute("targetY", "<svgattr_targetY_value>");
<SVGElement>.setAttribute("text-anchor", "<svgattr_text-anchor_value>");
<SVGElement>.setAttribute("text-decoration", "<svgattr_text-decoration_value>");
<SVGElement>.setAttribute("text-rendering", "<svgattr_text-rendering_value>");
<SVGElement>.setAttribute("textLength", "<svgattr_textLength_value>");
<SVGElement>.setAttribute("to", "<svgattr_to_value>");
<SVGElement>.setAttribute("transform", "<svgattr_transform_value>");
<SVGElement>.setAttribute("type", "<svgattr_type_value>");
<SVGElement>.setAttribute("underline-position", "<svgattr_underline-position_value>");
<SVGElement>.setAttribute("underline-thickness", "<svgattr_underline-thickness_value>");
<SVGElement>.setAttribute("unicode", "<svgattr_unicode_value>");
<SVGElement>.setAttribute("unicode-bidi", "<svgattr_unicode-bidi_value>");
<SVGElement>.setAttribute("unicode-range", "<svgattr_unicode-range_value>");
<SVGElement>.setAttribute("units-per-em", "<svgattr_units-per-em_value>");
<SVGElement>.setAttribute("values", "<svgattr_values_value>");
<SVGElement>.setAttribute("vector-effect", "<svgattr_vector-effect_value>");
<SVGElement>.setAttribute("version", "<svgattr_version_value>");
<SVGElement>.setAttribute("vert-origin-y", "<svgattr_vert-origin-y_value>");
<SVGElement>.setAttribute("viewBox", "<svgattr_viewBox_value>");
<SVGElement>.setAttribute("viewTarget", "<svgattr_viewTarget_value>");
<SVGElement>.setAttribute("viewbox", "<svgattr_viewbox_value>");
<SVGElement>.setAttribute("visibility", "<svgattr_visibility_value>");
<SVGElement>.setAttribute("width", "<svgattr_width_value>");
<SVGElement>.setAttribute("word-spacing", "<svgattr_word-spacing_value>");
<SVGElement>.setAttribute("writing-mode", "<svgattr_writing-mode_value>");
<SVGElement>.setAttribute("x", "<svgattr_x_value>");
<SVGElement>.setAttribute("x-height", "<svgattr_x-height_value>");
<SVGElement>.setAttribute("x1", "<svgattr_x1_value>");
<SVGElement>.setAttribute("x2", "<svgattr_x2_value>");
<SVGElement>.setAttribute("xChannelSelector", "<svgattr_xChannelSelector_value>");
<SVGElement>.setAttribute("y", "<svgattr_y_value>");
<SVGElement>.setAttribute("y1", "<svgattr_y1_value>");
<SVGElement>.setAttribute("y2", "<svgattr_y2_value>");
<SVGElement>.setAttribute("yChannelSelector", "<svgattr_yChannelSelector_value>");
<SVGElement>.setAttribute("z", "<svgattr_z_value>");
<SVGElement>.setAttribute("zoomAndPan", "<svgattr_zoomAndPan_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:actuate", "<svgattr_xlink_actuate_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", "<svgattr_xlink_href_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:show", "<svgattr_xlink_show_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:title", "<svgattr_xlink_title_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:type", "<svgattr_xlink_type_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:id", "<svgattr_xml_id_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:lang", "<svgattr_xml_lang_value>");
<SVGElement>.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "<svgattr_xml_space_value>");


<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;
<new CSSStyleDeclaration> = <SVGElement>.style;

################################################
#MathML
################################################

!extends MathMLElement GlobalEventHandlers
<new GlobalEventHandlers> = <MathMLElement>;

!extends MathMLElement EventTarget
#NodeList
<new MathMLElement> = <MathMLNodeList id=1>.item(<int min=0 max=100>%<MathMLNodeList id=1>.length);
<new long> = <MathMLNodeList>.length;

#Node
<new short> = <MathMLElement>.nodeType;
<new DOMString> = <MathMLElement>.nodeName;
<new DOMString> = <MathMLElement>.baseURI;
<new boolean> = <MathMLElement>.isConnected;
<new Document> = <MathMLElement>.ownerDocument;
<new MathMLElement> = <MathMLElement>.parentNode;
<new MathMLElement> = <MathMLElement>.parentElement;
<new boolean> = <MathMLElement>.hasChildNodes();
<new MathMLNodeList> = <MathMLElement>.childNodes;
<new MathMLElement> = <MathMLElement>.firstChild;
<new MathMLElement> = <MathMLElement>.lastChild;
<new MathMLElement> = <MathMLElement>.previousSibling;
<new MathMLElement> = <MathMLElement>.nextSibling;
<new MathMLElement> = <MathMLElement>.getRootNode();
<new MathMLElement> = <MathMLElement>.getRootNode(<GetRootNodeOptions>);
<new DOMString> = <MathMLElement>.nodeValue;
<MathMLElement>.nodeValue = <DOMString>;
<new DOMString> = <MathMLElement>.textContent;
<MathMLElement>.textContent = <DOMString>;
<MathMLElement>.normalize();
<new MathMLElement> = <MathMLElement>.cloneNode();
<new MathMLElement> = <MathMLElement>.cloneNode(<boolean>);
<new boolean> = <MathMLElement>.isEqualNode(<MathMLElement>);
<new boolean> = <MathMLElement>.isSameNode(<MathMLElement>);
<new short> = <MathMLElement>.compareDocumentPosition(<MathMLElement>);
<new boolean> = <MathMLElement>.contains(<MathMLElement>);
<new DOMString> = <MathMLElement>.lookupPrefix(<DOMString>);
<new DOMString> = <MathMLElement>.lookupNamespaceURI(<DOMString>);
<new boolean> = <MathMLElement>.isDefaultNamespace(<DOMString>);
<new MathMLElement> = <MathMLElement id=1>.insertBefore(<MathMLElement>,<MathMLElement id=1>.childNodes[<int min=0 max=100>%<MathMLElement id=1>.childNodes.length]);
<new MathMLElement> = <MathMLElement>.appendChild(<MathMLElement>);
<new MathMLElement> = <MathMLElement id=1>.replaceChild(<MathMLElement>,<MathMLElement id=1>.childNodes[<int min=0 max=100>%<MathMLElement id=1>.childNodes.length]);
<new MathMLElement> = <MathMLElement id=1>.removeChild(<MathMLElement id=1>.childNodes[<int min=0 max=100>%<MathMLElement id=1>.childNodes.length]);

#ChildNode
<MathMLElement>.before(<MathMLElement>);
<MathMLElement>.before(<DOMString>);
<MathMLElement>.after(<MathMLElement>);
<MathMLElement>.after(<DOMString>);
<MathMLElement>.replaceWith(<MathMLElement>);
<MathMLElement>.replaceWith(<DOMString>);
<MathMLElement>.remove();

#ParentNode
<new HTMLCollection> = <MathMLElement>.children;
<new MathMLElement> = <MathMLElement>.firstElementChild;
<new MathMLElement> = <MathMLElement>.lastElementChild;
<new long> = <MathMLElement>.childElementCount;
<MathMLElement>.prepend(<MathMLElement>);
<MathMLElement>.prepend(<DOMString>);
<MathMLElement>.append(<MathMLElement>);
<MathMLElement>.append(<DOMString>);
<new MathMLElement> = <MathMLElement>.querySelector("<selector>");
<new MathMLNodeList> = <MathMLElement>.querySelectorAll("<selector>");

#NonDocumentTypeChildNode
<new MathMLElement> = <MathMLElement>.previousElementSibling;
<new MathMLElement> = <MathMLElement>.nextElementSibling;

#Element
<new DOMString> = <MathMLElement>.namespaceURI;
<new DOMString> = <MathMLElement>.prefix;
<new DOMString> = <MathMLElement>.localName;
<new DOMString> = <MathMLElement>.tagName;
<new DOMString> = <MathMLElement>.id;
<MathMLElement>.id = <DOMString>;
<new DOMString> = <MathMLElement>.className;
<MathMLElement>.className = <DOMString>;
<new DOMTokenList> = <MathMLElement>.classList;
<MathMLElement>.setPointerCapture(<fuzzint>);
<MathMLElement>.releasePointerCapture(<fuzzint>);
<new EventHandler> = <MathMLElement>.ongotpointercapture;
<MathMLElement>.ongotpointercapture = <EventHandler>;
<new EventHandler> = <MathMLElement>.onlostpointercapture;
<MathMLElement>.onlostpointercapture = <EventHandler>;
<new boolean> = <MathMLElement>.hasPointerCapture(<fuzzint>);
<new boolean> = <MathMLElement>.hasAttributes();
<new NamedNodeMap> = <MathMLElement>.attributes;
<new DOMString> = <MathMLElement>.getAttribute(<string_attr>);
<new DOMString> = <MathMLElement>.getAttributeNS("http://www.w3.org/2000/svg",<string_attr>);
#<MathMLElement>.setAttribute(<DOMString>,<DOMString>);
#<MathMLElement>.setAttributeNS(<DOMString>,<DOMString>,<DOMString>);
<MathMLElement id=1>.removeAttribute(<MathMLElement id=1>.attributes[<int min=0 max=100>%<MathMLElement id=1>.attributes.length].name);
<MathMLElement id=1>.removeAttributeNS("http://www.w3.org/2000/svg",<MathMLElement id=1>.attributes[<int min=0 max=100>%<MathMLElement id=1>.attributes.length].name);
<new boolean> = <MathMLElement>.hasAttribute(<string_attr>);
<new boolean> = <MathMLElement>.hasAttributeNS("http://www.w3.org/2000/svg",<string_attr>);
<new Attr> = <MathMLElement>.getAttributeNode(<string_attr>);
<new Attr> = <MathMLElement>.getAttributeNodeNS("http://www.w3.org/2000/svg",<string_attr>);
<new Attr> = <MathMLElement>.setAttributeNode(<Attr>);
<new Attr> = <MathMLElement>.setAttributeNodeNS(<Attr>);
<new Attr> = <MathMLElement id=1>.removeAttributeNode(<MathMLElement id=1>.attributes[<int min=0 max=100>%<MathMLElement id=1>.attributes.length].name);
<new MathMLElement> = <MathMLElement>.closest(<DOMString>);
<new boolean> = <MathMLElement>.matches(<DOMString>);
<new boolean> = <MathMLElement>.webkitMatchesSelector(<DOMString>);
<new HTMLCollection> = <MathMLElement>.getElementsByTagName(<string_tag>);
<new HTMLCollection> = <MathMLElement>.getElementsByTagNameNS("http://www.w3.org/2000/svg",<string_tag>);
<new HTMLCollection> = <MathMLElement>.getElementsByClassName("<class>");
<new MathMLElement> = <MathMLElement>.insertAdjacentElement(<string_where>,<MathMLElement>);
<MathMLElement>.insertAdjacentText(<string_where>,<DOMString>);
<new htmlstring> = <MathMLElement>.innerHTML;
<MathMLElement>.innerHTML = <htmlstring>;
<new htmlstring> = <MathMLElement>.outerHTML;
<MathMLElement>.outerHTML = <htmlstring>;
<MathMLElement>.insertAdjacentHTML(<string_where>,<htmlstring>);
<new ShadowRoot> = <MathMLElement>.createShadowRoot();
<new ShadowRoot> = <MathMLElement>.attachShadow(<ShadowRootInit>);
<new NodeList> = <MathMLElement>.getDestinationInsertionPoints();
<new ShadowRoot> = <MathMLElement>.shadowRoot;
<new DOMString> = <MathMLElement>.slot;
<MathMLElement>.slot = <DOMString>;
<new HTMLSlotElement> = <MathMLElement>.assignedSlot;
<MathMLElement>.requestPointerLock();
<new ClientRectList> = <MathMLElement>.getClientRects();
<new ClientRect> = <MathMLElement>.getBoundingClientRect();
<MathMLElement>.scrollIntoView();
<MathMLElement>.scrollIntoView(<boolean>);
<MathMLElement>.scroll();
<MathMLElement>.scroll(<ScrollToOptions>);
<MathMLElement>.scroll(<double>,<double>);
<MathMLElement>.scrollTo();
<MathMLElement>.scrollTo(<ScrollToOptions>);
<MathMLElement>.scrollTo(<double>,<double>);
<MathMLElement>.scrollBy();
<MathMLElement>.scrollBy(<ScrollToOptions>);
<MathMLElement>.scrollBy(<double>,<double>);
<new double> = <MathMLElement>.scrollTop;
<MathMLElement>.scrollTop = <double>;
<new double> = <MathMLElement>.scrollLeft;
<MathMLElement>.scrollLeft = <double>;
<new long> = <MathMLElement>.scrollWidth;
<new long> = <MathMLElement>.scrollHeight;
<new long> = <MathMLElement>.clientTop;
<new long> = <MathMLElement>.clientLeft;
<new long> = <MathMLElement>.clientWidth;
<new long> = <MathMLElement>.clientHeight;
<MathMLElement>.setApplyScroll(<ScrollStateCallback>,<NativeScrollBehavior>);
<MathMLElement>.setDistributeScroll(<ScrollStateCallback>,<NativeScrollBehavior>);
<MathMLElement>.scrollIntoViewIfNeeded();
<MathMLElement>.scrollIntoViewIfNeeded(<boolean>);
<new DOMString> = <MathMLElement>.computedRole;
<new DOMString> = <MathMLElement>.computedName;
<new EventHandler> = <MathMLElement>.onbeforecopy;
<MathMLElement>.onbeforecopy = <EventHandler>;
<new EventHandler> = <MathMLElement>.onbeforecut;
<MathMLElement>.onbeforecut = <EventHandler>;
<new EventHandler> = <MathMLElement>.onbeforepaste;
<MathMLElement>.onbeforepaste = <EventHandler>;
<new EventHandler> = <MathMLElement>.oncopy;
<MathMLElement>.oncopy = <EventHandler>;
<new EventHandler> = <MathMLElement>.oncut;
<MathMLElement>.oncut = <EventHandler>;
<new EventHandler> = <MathMLElement>.onpaste;
<MathMLElement>.onpaste = <EventHandler>;
<new EventHandler> = <MathMLElement>.onsearch;
<MathMLElement>.onsearch = <EventHandler>;
<new EventHandler> = <MathMLElement>.onselectstart;
<MathMLElement>.onselectstart = <EventHandler>;
<new EventHandler> = <MathMLElement>.onwheel;
<MathMLElement>.onwheel = <EventHandler>;

<MathMLElement>.setAttribute("display", "<mathmlattr_math_display_value>");
<MathMLElement>.setAttribute("form", "<mathmlattr_form_value>");
<MathMLElement>.setAttribute("fence", "<boolean>");
<MathMLElement>.setAttribute("separator", "<boolean>");
<MathMLElement>.setAttribute("lspace", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("rspace", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("stretchy", "<boolean>");
<MathMLElement>.setAttribute("symmetric", "<boolean>");
<MathMLElement>.setAttribute("maxsize", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("minsize", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("largeop", "<boolean>");
<MathMLElement>.setAttribute("movablelimits", "<boolean>");
<MathMLElement>.setAttribute("mfrac_linethickness", "<mathmlattr_mfrac_linethickness_value>");
<MathMLElement>.setAttribute("width", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("height", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("depth", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("lspace", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("voffset", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("accent", "<boolean>");
<MathMLElement>.setAttribute("accentunder", "<boolean>");
<MathMLElement>.setAttribute("columnspan", "<colspan_value>");
<MathMLElement>.setAttribute("rowspan", "<rowspan_value>");
<MathMLElement>.setAttribute("actiontype", "<mathmlattr_maction_actiontype_value>");
<MathMLElement>.setAttribute("selection", "<mathmlattr_maction_selection_value>");
<MathMLElement>.setAttribute("encoding", "<encoding_value>");
<MathMLElement>.setAttribute("class", "<class>");
<MathMLElement>.setAttribute("dir", "<direction_value>");
<MathMLElement>.setAttribute("displaystyle", "<boolean>");
<MathMLElement>.setAttribute("mathbackground", "<color>");
<MathMLElement>.setAttribute("mathcolor", "<color>");
<MathMLElement>.setAttribute("mathsize", "<mathmlattr_lengthpercentage_value>");
<MathMLElement>.setAttribute("mathvariant", "<mathmlattr_mathvariant_value>");
<MathMLElement>.setAttribute("nonce", "<nonce_value>");
<MathMLElement>.setAttribute("scriptlevel", "<mathmlattr_scriptlevel_value>");
<MathMLElement>.setAttribute("style", "<style_value>");
<MathMLElement>.setAttribute("tabindex", "<tabindex_value>");

<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;
<new CSSStyleDeclaration> = <MathMLElement>.style;

<any>.prop = { toString:<eventhandler> };
<any>.toString = <eventhandler>;

setTimeout(<eventhandler>, <timeout_time>);

freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();
freememory();

!end lines

