dom.idl - mozsearch

mozilla-central/testing/web-platform/tests/interfaces/dom.idl

Enable keyboard shortcuts

Source code

File a bug in Core :: DOM: Core & HTML

Revision control

Copy as Markdown

Other Tools

// GENERATED CONTENT - DO NOT EDIT

// Content was automatically extracted by Reffy into webref

// (https://github.com/w3c/webref)

// Source: DOM Standard (https://dom.spec.whatwg.org/)

[Exposed=*]

interface Event {

  constructor(DOMString type, optional EventInit eventInitDict = {});

  readonly attribute DOMString type;

  readonly attribute EventTarget? target;

  readonly attribute EventTarget? srcElement; // legacy

  readonly attribute EventTarget? currentTarget;

  sequence<EventTarget> composedPath();

  const unsigned short NONE = 0;

  const unsigned short CAPTURING_PHASE = 1;

  const unsigned short AT_TARGET = 2;

  const unsigned short BUBBLING_PHASE = 3;

  readonly attribute unsigned short eventPhase;

  undefined stopPropagation();

           attribute boolean cancelBubble; // legacy alias of .stopPropagation()

  undefined stopImmediatePropagation();

  readonly attribute boolean bubbles;

  readonly attribute boolean cancelable;

           attribute boolean returnValue;  // legacy

  undefined preventDefault();

  readonly attribute boolean defaultPrevented;

  readonly attribute boolean composed;

  [LegacyUnforgeable] readonly attribute boolean isTrusted;

  readonly attribute DOMHighResTimeStamp timeStamp;

  undefined initEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false); // legacy

};

dictionary EventInit {

  boolean bubbles = false;

  boolean cancelable = false;

  boolean composed = false;

};

partial interface Window {

  [Replaceable] readonly attribute (Event or undefined) event; // legacy

};

[Exposed=*]

interface CustomEvent : Event {

  constructor(DOMString type, optional CustomEventInit eventInitDict = {});

  readonly attribute any detail;

  undefined initCustomEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional any detail = null); // legacy

};

dictionary CustomEventInit : EventInit {

  any detail = null;

};

[Exposed=*]

interface EventTarget {

  constructor();

  undefined addEventListener(DOMString type, EventListener? callback, optional (AddEventListenerOptions or boolean) options = {});

  undefined removeEventListener(DOMString type, EventListener? callback, optional (EventListenerOptions or boolean) options = {});

  boolean dispatchEvent(Event event);

};

callback interface EventListener {

  undefined handleEvent(Event event);

};

dictionary EventListenerOptions {

  boolean capture = false;

};

dictionary AddEventListenerOptions : EventListenerOptions {

  boolean passive;

  boolean once = false;

  AbortSignal signal;

};

[Exposed=*]

interface AbortController {

  constructor();

  [SameObject] readonly attribute AbortSignal signal;

  undefined abort(optional any reason);

};

[Exposed=*]

interface AbortSignal : EventTarget {

  [NewObject] static AbortSignal abort(optional any reason);

  [Exposed=(Window,Worker), NewObject] static AbortSignal timeout([EnforceRange] unsigned long long milliseconds);

  [NewObject] static AbortSignal _any(sequence<AbortSignal> signals);

  readonly attribute boolean aborted;

  readonly attribute any reason;

  undefined throwIfAborted();

  attribute EventHandler onabort;

};

interface mixin NonElementParentNode {

  Element? getElementById(DOMString elementId);

};

Document includes NonElementParentNode;

DocumentFragment includes NonElementParentNode;

interface mixin DocumentOrShadowRoot {

};

Document includes DocumentOrShadowRoot;

ShadowRoot includes DocumentOrShadowRoot;

interface mixin ParentNode {

  [SameObject] readonly attribute HTMLCollection children;

  readonly attribute Element? firstElementChild;

  readonly attribute Element? lastElementChild;

  readonly attribute unsigned long childElementCount;

  [CEReactions, Unscopable] undefined prepend((Node or DOMString)... nodes);

  [CEReactions, Unscopable] undefined append((Node or DOMString)... nodes);

  [CEReactions, Unscopable] undefined replaceChildren((Node or DOMString)... nodes);

  Element? querySelector(DOMString selectors);

  [NewObject] NodeList querySelectorAll(DOMString selectors);

};

Document includes ParentNode;

DocumentFragment includes ParentNode;

Element includes ParentNode;

interface mixin NonDocumentTypeChildNode {

  readonly attribute Element? previousElementSibling;

  readonly attribute Element? nextElementSibling;

};

Element includes NonDocumentTypeChildNode;

CharacterData includes NonDocumentTypeChildNode;

interface mixin ChildNode {

  [CEReactions, Unscopable] undefined before((Node or DOMString)... nodes);

  [CEReactions, Unscopable] undefined after((Node or DOMString)... nodes);

  [CEReactions, Unscopable] undefined replaceWith((Node or DOMString)... nodes);

  [CEReactions, Unscopable] undefined remove();

};

DocumentType includes ChildNode;

Element includes ChildNode;

CharacterData includes ChildNode;

interface mixin Slottable {

  readonly attribute HTMLSlotElement? assignedSlot;

};

Element includes Slottable;

Text includes Slottable;

[Exposed=Window]

interface NodeList {

  getter Node? item(unsigned long index);

  readonly attribute unsigned long length;

  iterable<Node>;

};

[Exposed=Window, LegacyUnenumerableNamedProperties]

interface HTMLCollection {

  readonly attribute unsigned long length;

  getter Element? item(unsigned long index);

  getter Element? namedItem(DOMString name);

};

[Exposed=Window]

interface MutationObserver {

  constructor(MutationCallback callback);

  undefined observe(Node target, optional MutationObserverInit options = {});

  undefined disconnect();

  sequence<MutationRecord> takeRecords();

};

callback MutationCallback = undefined (sequence<MutationRecord> mutations, MutationObserver observer);

dictionary MutationObserverInit {

  boolean childList = false;

  boolean attributes;

  boolean characterData;

  boolean subtree = false;

  boolean attributeOldValue;

  boolean characterDataOldValue;

  sequence<DOMString> attributeFilter;

};

[Exposed=Window]

interface MutationRecord {

  readonly attribute DOMString type;

  [SameObject] readonly attribute Node target;

  [SameObject] readonly attribute NodeList addedNodes;

  [SameObject] readonly attribute NodeList removedNodes;

  readonly attribute Node? previousSibling;

  readonly attribute Node? nextSibling;

  readonly attribute DOMString? attributeName;

  readonly attribute DOMString? attributeNamespace;

  readonly attribute DOMString? oldValue;

};

[Exposed=Window]

interface Node : EventTarget {

  const unsigned short ELEMENT_NODE = 1;

  const unsigned short ATTRIBUTE_NODE = 2;

  const unsigned short TEXT_NODE = 3;

  const unsigned short CDATA_SECTION_NODE = 4;

  const unsigned short ENTITY_REFERENCE_NODE = 5; // legacy

  const unsigned short ENTITY_NODE = 6; // legacy

  const unsigned short PROCESSING_INSTRUCTION_NODE = 7;

  const unsigned short COMMENT_NODE = 8;

  const unsigned short DOCUMENT_NODE = 9;

  const unsigned short DOCUMENT_TYPE_NODE = 10;

  const unsigned short DOCUMENT_FRAGMENT_NODE = 11;

  const unsigned short NOTATION_NODE = 12; // legacy

  readonly attribute unsigned short nodeType;

  readonly attribute DOMString nodeName;

  readonly attribute USVString baseURI;

  readonly attribute boolean isConnected;

  readonly attribute Document? ownerDocument;

  Node getRootNode(optional GetRootNodeOptions options = {});

  readonly attribute Node? parentNode;

  readonly attribute Element? parentElement;

  boolean hasChildNodes();

  [SameObject] readonly attribute NodeList childNodes;

  readonly attribute Node? firstChild;

  readonly attribute Node? lastChild;

  readonly attribute Node? previousSibling;

  readonly attribute Node? nextSibling;

  [CEReactions] attribute DOMString? nodeValue;

  [CEReactions] attribute DOMString? textContent;

  [CEReactions] undefined normalize();

  [CEReactions, NewObject] Node cloneNode(optional boolean deep = false);

  boolean isEqualNode(Node? otherNode);

  boolean isSameNode(Node? otherNode); // legacy alias of ===

  const unsigned short DOCUMENT_POSITION_DISCONNECTED = 0x01;

  const unsigned short DOCUMENT_POSITION_PRECEDING = 0x02;

  const unsigned short DOCUMENT_POSITION_FOLLOWING = 0x04;

  const unsigned short DOCUMENT_POSITION_CONTAINS = 0x08;

  const unsigned short DOCUMENT_POSITION_CONTAINED_BY = 0x10;

  const unsigned short DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;

  unsigned short compareDocumentPosition(Node other);

  boolean contains(Node? other);

  DOMString? lookupPrefix(DOMString? namespace);

  DOMString? lookupNamespaceURI(DOMString? prefix);

  boolean isDefaultNamespace(DOMString? namespace);

  [CEReactions] Node insertBefore(Node node, Node? child);

  [CEReactions] Node appendChild(Node node);

  [CEReactions] Node replaceChild(Node node, Node child);

  [CEReactions] Node removeChild(Node child);

};

dictionary GetRootNodeOptions {

  boolean composed = false;

};

[Exposed=Window]

interface Document : Node {

  constructor();

  [SameObject] readonly attribute DOMImplementation implementation;

  readonly attribute USVString URL;

  readonly attribute USVString documentURI;

  readonly attribute DOMString compatMode;

  readonly attribute DOMString characterSet;

  readonly attribute DOMString charset; // legacy alias of .characterSet

  readonly attribute DOMString inputEncoding; // legacy alias of .characterSet

  readonly attribute DOMString contentType;

  readonly attribute DocumentType? doctype;

  readonly attribute Element? documentElement;

  HTMLCollection getElementsByTagName(DOMString qualifiedName);

  HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);

  HTMLCollection getElementsByClassName(DOMString classNames);

  [CEReactions, NewObject] Element createElement(DOMString localName, optional (DOMString or ElementCreationOptions) options = {});

  [CEReactions, NewObject] Element createElementNS(DOMString? namespace, DOMString qualifiedName, optional (DOMString or ElementCreationOptions) options = {});

  [NewObject] DocumentFragment createDocumentFragment();

  [NewObject] Text createTextNode(DOMString data);

  [NewObject] CDATASection createCDATASection(DOMString data);

  [NewObject] Comment createComment(DOMString data);

  [NewObject] ProcessingInstruction createProcessingInstruction(DOMString target, DOMString data);

  [CEReactions, NewObject] Node importNode(Node node, optional boolean deep = false);

  [CEReactions] Node adoptNode(Node node);

  [NewObject] Attr createAttribute(DOMString localName);

  [NewObject] Attr createAttributeNS(DOMString? namespace, DOMString qualifiedName);

  [NewObject] Event createEvent(DOMString interface); // legacy

  [NewObject] Range createRange();

  // NodeFilter.SHOW_ALL = 0xFFFFFFFF

  [NewObject] NodeIterator createNodeIterator(Node root, optional unsigned long whatToShow = 0xFFFFFFFF, optional NodeFilter? filter = null);

  [NewObject] TreeWalker createTreeWalker(Node root, optional unsigned long whatToShow = 0xFFFFFFFF, optional NodeFilter? filter = null);

};

[Exposed=Window]

interface XMLDocument : Document {};

dictionary ElementCreationOptions {

  DOMString is;

};

[Exposed=Window]

interface DOMImplementation {

  [NewObject] DocumentType createDocumentType(DOMString qualifiedName, DOMString publicId, DOMString systemId);

  [NewObject] XMLDocument createDocument(DOMString? namespace, [LegacyNullToEmptyString] DOMString qualifiedName, optional DocumentType? doctype = null);

  [NewObject] Document createHTMLDocument(optional DOMString title);

  boolean hasFeature(); // useless; always returns true

};

[Exposed=Window]

interface DocumentType : Node {

  readonly attribute DOMString name;

  readonly attribute DOMString publicId;

  readonly attribute DOMString systemId;

};

[Exposed=Window]

interface DocumentFragment : Node {

  constructor();

};

[Exposed=Window]

interface ShadowRoot : DocumentFragment {

  readonly attribute ShadowRootMode mode;

  readonly attribute boolean delegatesFocus;

  readonly attribute SlotAssignmentMode slotAssignment;

  readonly attribute boolean clonable;

  readonly attribute Element host;

  attribute EventHandler onslotchange;

};

enum ShadowRootMode { "open", "closed" };

enum SlotAssignmentMode { "manual", "named" };

[Exposed=Window]

interface Element : Node {

  readonly attribute DOMString? namespaceURI;

  readonly attribute DOMString? prefix;

  readonly attribute DOMString localName;

  readonly attribute DOMString tagName;

  [CEReactions] attribute DOMString id;

  [CEReactions] attribute DOMString className;

  [SameObject, PutForwards=value] readonly attribute DOMTokenList classList;

  [CEReactions, Unscopable] attribute DOMString slot;

  boolean hasAttributes();

  [SameObject] readonly attribute NamedNodeMap attributes;

  sequence<DOMString> getAttributeNames();

  DOMString? getAttribute(DOMString qualifiedName);

  DOMString? getAttributeNS(DOMString? namespace, DOMString localName);

  [CEReactions] undefined setAttribute(DOMString qualifiedName, DOMString value);

  [CEReactions] undefined setAttributeNS(DOMString? namespace, DOMString qualifiedName, DOMString value);

  [CEReactions] undefined removeAttribute(DOMString qualifiedName);

  [CEReactions] undefined removeAttributeNS(DOMString? namespace, DOMString localName);

  [CEReactions] boolean toggleAttribute(DOMString qualifiedName, optional boolean force);

  boolean hasAttribute(DOMString qualifiedName);

  boolean hasAttributeNS(DOMString? namespace, DOMString localName);

  Attr? getAttributeNode(DOMString qualifiedName);

  Attr? getAttributeNodeNS(DOMString? namespace, DOMString localName);

  [CEReactions] Attr? setAttributeNode(Attr attr);

  [CEReactions] Attr? setAttributeNodeNS(Attr attr);

  [CEReactions] Attr removeAttributeNode(Attr attr);

  ShadowRoot attachShadow(ShadowRootInit init);

  readonly attribute ShadowRoot? shadowRoot;

  Element? closest(DOMString selectors);

  boolean matches(DOMString selectors);

  boolean webkitMatchesSelector(DOMString selectors); // legacy alias of .matches

  HTMLCollection getElementsByTagName(DOMString qualifiedName);

  HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);

  HTMLCollection getElementsByClassName(DOMString classNames);

  [CEReactions] Element? insertAdjacentElement(DOMString where, Element element); // legacy

  undefined insertAdjacentText(DOMString where, DOMString data); // legacy

};

dictionary ShadowRootInit {

  required ShadowRootMode mode;

  boolean delegatesFocus = false;

  SlotAssignmentMode slotAssignment = "named";

  boolean clonable = false;

};

[Exposed=Window,

 LegacyUnenumerableNamedProperties]

interface NamedNodeMap {

  readonly attribute unsigned long length;

  getter Attr? item(unsigned long index);

  getter Attr? getNamedItem(DOMString qualifiedName);

  Attr? getNamedItemNS(DOMString? namespace, DOMString localName);

  [CEReactions] Attr? setNamedItem(Attr attr);

  [CEReactions] Attr? setNamedItemNS(Attr attr);

  [CEReactions] Attr removeNamedItem(DOMString qualifiedName);

  [CEReactions] Attr removeNamedItemNS(DOMString? namespace, DOMString localName);

};

[Exposed=Window]

interface Attr : Node {

  readonly attribute DOMString? namespaceURI;

  readonly attribute DOMString? prefix;

  readonly attribute DOMString localName;

  readonly attribute DOMString name;

  [CEReactions] attribute DOMString value;

  readonly attribute Element? ownerElement;

  readonly attribute boolean specified; // useless; always returns true

};

[Exposed=Window]

interface CharacterData : Node {

  attribute [LegacyNullToEmptyString] DOMString data;

  readonly attribute unsigned long length;

  DOMString substringData(unsigned long offset, unsigned long count);

  undefined appendData(DOMString data);

  undefined insertData(unsigned long offset, DOMString data);

  undefined deleteData(unsigned long offset, unsigned long count);

  undefined replaceData(unsigned long offset, unsigned long count, DOMString data);

};

[Exposed=Window]

interface Text : CharacterData {

  constructor(optional DOMString data = "");

  [NewObject] Text splitText(unsigned long offset);

  readonly attribute DOMString wholeText;

};

[Exposed=Window]

interface CDATASection : Text {

};

[Exposed=Window]

interface ProcessingInstruction : CharacterData {

  readonly attribute DOMString target;

};

[Exposed=Window]

interface Comment : CharacterData {

  constructor(optional DOMString data = "");

};

[Exposed=Window]

interface AbstractRange {

  readonly attribute Node startContainer;

  readonly attribute unsigned long startOffset;

  readonly attribute Node endContainer;

  readonly attribute unsigned long endOffset;

  readonly attribute boolean collapsed;

};

dictionary StaticRangeInit {

  required Node startContainer;

  required unsigned long startOffset;

  required Node endContainer;

  required unsigned long endOffset;

};

[Exposed=Window]

interface StaticRange : AbstractRange {

  constructor(StaticRangeInit init);

};

[Exposed=Window]

interface Range : AbstractRange {

  constructor();

  readonly attribute Node commonAncestorContainer;

  undefined setStart(Node node, unsigned long offset);

  undefined setEnd(Node node, unsigned long offset);

  undefined setStartBefore(Node node);

  undefined setStartAfter(Node node);

  undefined setEndBefore(Node node);

  undefined setEndAfter(Node node);

  undefined collapse(optional boolean toStart = false);

  undefined selectNode(Node node);

  undefined selectNodeContents(Node node);

  const unsigned short START_TO_START = 0;

  const unsigned short START_TO_END = 1;

  const unsigned short END_TO_END = 2;

  const unsigned short END_TO_START = 3;

  short compareBoundaryPoints(unsigned short how, Range sourceRange);

  [CEReactions] undefined deleteContents();

  [CEReactions, NewObject] DocumentFragment extractContents();

  [CEReactions, NewObject] DocumentFragment cloneContents();

  [CEReactions] undefined insertNode(Node node);

  [CEReactions] undefined surroundContents(Node newParent);

  [NewObject] Range cloneRange();

  undefined detach();

  boolean isPointInRange(Node node, unsigned long offset);

  short comparePoint(Node node, unsigned long offset);

  boolean intersectsNode(Node node);

  stringifier;

};

[Exposed=Window]

interface NodeIterator {

  [SameObject] readonly attribute Node root;

  readonly attribute Node referenceNode;

  readonly attribute boolean pointerBeforeReferenceNode;

  readonly attribute unsigned long whatToShow;

  readonly attribute NodeFilter? filter;

  Node? nextNode();

  Node? previousNode();

  undefined detach();

};

[Exposed=Window]

interface TreeWalker {

  [SameObject] readonly attribute Node root;

  readonly attribute unsigned long whatToShow;

  readonly attribute NodeFilter? filter;

           attribute Node currentNode;

  Node? parentNode();

  Node? firstChild();

  Node? lastChild();

  Node? previousSibling();

  Node? nextSibling();

  Node? previousNode();

  Node? nextNode();

};

[Exposed=Window]

callback interface NodeFilter {

  // Constants for acceptNode()

  const unsigned short FILTER_ACCEPT = 1;

  const unsigned short FILTER_REJECT = 2;

  const unsigned short FILTER_SKIP = 3;

  // Constants for whatToShow

  const unsigned long SHOW_ALL = 0xFFFFFFFF;

  const unsigned long SHOW_ELEMENT = 0x1;

  const unsigned long SHOW_ATTRIBUTE = 0x2;

  const unsigned long SHOW_TEXT = 0x4;

  const unsigned long SHOW_CDATA_SECTION = 0x8;

  const unsigned long SHOW_ENTITY_REFERENCE = 0x10; // legacy

  const unsigned long SHOW_ENTITY = 0x20; // legacy

  const unsigned long SHOW_PROCESSING_INSTRUCTION = 0x40;

  const unsigned long SHOW_COMMENT = 0x80;

  const unsigned long SHOW_DOCUMENT = 0x100;

  const unsigned long SHOW_DOCUMENT_TYPE = 0x200;

  const unsigned long SHOW_DOCUMENT_FRAGMENT = 0x400;

  const unsigned long SHOW_NOTATION = 0x800; // legacy

  unsigned short acceptNode(Node node);

};

[Exposed=Window]

interface DOMTokenList {

  readonly attribute unsigned long length;

  getter DOMString? item(unsigned long index);

  boolean contains(DOMString token);

  [CEReactions] undefined add(DOMString... tokens);

  [CEReactions] undefined remove(DOMString... tokens);

  [CEReactions] boolean toggle(DOMString token, optional boolean force);

  [CEReactions] boolean replace(DOMString token, DOMString newToken);

  boolean supports(DOMString token);

  [CEReactions] stringifier attribute DOMString value;

  iterable<DOMString>;

};

[Exposed=Window]

interface XPathResult {

  const unsigned short ANY_TYPE = 0;

  const unsigned short NUMBER_TYPE = 1;

  const unsigned short STRING_TYPE = 2;

  const unsigned short BOOLEAN_TYPE = 3;

  const unsigned short UNORDERED_NODE_ITERATOR_TYPE = 4;

  const unsigned short ORDERED_NODE_ITERATOR_TYPE = 5;

  const unsigned short UNORDERED_NODE_SNAPSHOT_TYPE = 6;

  const unsigned short ORDERED_NODE_SNAPSHOT_TYPE = 7;

  const unsigned short ANY_UNORDERED_NODE_TYPE = 8;

  const unsigned short FIRST_ORDERED_NODE_TYPE = 9;

  readonly attribute unsigned short resultType;

  readonly attribute unrestricted double numberValue;

  readonly attribute DOMString stringValue;

  readonly attribute boolean booleanValue;

  readonly attribute Node? singleNodeValue;

  readonly attribute boolean invalidIteratorState;

  readonly attribute unsigned long snapshotLength;

  Node? iterateNext();

  Node? snapshotItem(unsigned long index);

};

[Exposed=Window]

interface XPathExpression {

  // XPathResult.ANY_TYPE = 0

  XPathResult evaluate(Node contextNode, optional unsigned short type = 0, optional XPathResult? result = null);

};

callback interface XPathNSResolver {

  DOMString? lookupNamespaceURI(DOMString? prefix);

};

interface mixin XPathEvaluatorBase {

  [NewObject] XPathExpression createExpression(DOMString expression, optional XPathNSResolver? resolver = null);

  Node createNSResolver(Node nodeResolver); // legacy

  // XPathResult.ANY_TYPE = 0

  XPathResult evaluate(DOMString expression, Node contextNode, optional XPathNSResolver? resolver = null, optional unsigned short type = 0, optional XPathResult? result = null);

};

Document includes XPathEvaluatorBase;

[Exposed=Window]

interface XPathEvaluator {

  constructor();

};

XPathEvaluator includes XPathEvaluatorBase;

[Exposed=Window]

interface XSLTProcessor {

  constructor();

  undefined importStylesheet(Node style);

  [CEReactions] DocumentFragment transformToFragment(Node source, Document output);

  [CEReactions] Document transformToDocument(Node source);

  undefined setParameter([LegacyNullToEmptyString] DOMString namespaceURI, DOMString localName, any value);

  any getParameter([LegacyNullToEmptyString] DOMString namespaceURI, DOMString localName);

  undefined removeParameter([LegacyNullToEmptyString] DOMString namespaceURI, DOMString localName);

  undefined clearParameters();

  undefined reset();

};