flow/lib/dom.js at 0.92.1 · dominictobias/flow

Repository navigation

560<
8
/div>

/**

* Copyright (c) Facebook, Inc. and its affiliates.

* This source code is licensed under the MIT license found in the

* LICENSE file in the root directory of this source tree.

/* Files */

declare class Blob {

constructor(blobParts?: Array<any>, options?: {

type?: string;

endings?: string;

}): void;

isClosed: bool;

size: number;

type: string;

close(): void;

slice(start?: number, end?: number, contentType?: string): Blob;

}

declare class FileReader extends EventTarget {

abort(): void;

DONE: number;

EMPTY: number;

error: DOMError;

LOADING: number;

onabort: (ev: any) => any;

onerror: (ev: any) => any;

onload: (ev: any) => any;

onloadend: (ev: any) => any;

onloadstart: (ev: any) => any;

onprogress: (ev: any) => any;

readAsArrayBuffer(blob: Blob): void;

readAsBinaryString(blob: Blob): void;

readAsDataURL(blob: Blob): void;

readAsText(blob: Blob, encoding?: string): void;

readyState: 0 | 1 | 2;

result: string | ArrayBuffer;

}

declare type FilePropertyBag = {

type?: string,

lastModified?: number,

};

declare class File extends Blob {

constructor(

fileBits: $ReadOnlyArray<string | BufferDataSource | Blob>,

filename: string,

options?: FilePropertyBag,

): void;

lastModified: number;

}

declare class FileList {

@@iterator(): Iterator<File>;

length: number;

item(index: number): File;

[index: number]: File;

}

/* DataTransfer */

declare class DataTransfer {

clearData(format?: string): void;

getData(format: string): string;

setData(format: string, data: string): void;

setDragImage(image: Element, x: number, y: number): void;

dropEffect: string;

effectAllowed: string;

files: FileList; // readonly

items: DataTransferItemList; // readonly

types: Array<string>; // readonly

}

declare class DataTransferItemList {

@@iterator(): Iterator<DataTransferItem>;

length: number; // readonly

[index: number]: DataTransferItem;

add(data: string, type: string): ?DataTransferItem;

add(data: File): ?DataTransferItem;

remove(index: number): void;

clear(): void;

};

declare class DataTransferItem {

kind: string; // readonly

type: string; // readonly

getAsString(_callback: ?(data: string) => mixed): void;

< 10BC8 /div>

getAsFile(): ?File;

};

/* DOM */

declare type DOMStringMap = {

[key:string]: string;

}

declare class DOMError {

}

declare type ElementDefinitionOptions = {

extends?: string;

}

declare interface CustomElementRegistry {

define(name: string, ctor: Class<Element>, options?: ElementDefinitionOptions): void;

get(name: string): any;

whenDefined(name: string): Promise<void>;

}

declare interface ShadowRoot extends DocumentFragment {

host: Element;

innerHTML: string;

}

declare type ShadowRootMode = 'open'|'closed';

declare type ShadowRootInit = {

delegatesFocus?: boolean;

mode: ShadowRootMode;

}

type EventHandler = (event: Event) => mixed

type EventListener = {handleEvent: EventHandler} | EventHandler

type MouseEventHandler = (event: MouseEvent) => mixed

type MouseEventListener = {handleEvent: MouseEventHandler} | MouseEventHandler

type FocusEventHandler = (event: FocusEvent) => mixed

type FocusEventListener = {handleEvent: FocusEventHandler} | FocusEventHandler

type KeyboardEventHandler = (event: KeyboardEvent) => mixed

type KeyboardEventListener = {handleEvent: KeyboardEventHandler} | KeyboardEventHandler

type InputEventHandler = (event: InputEvent) => mixed

type InputEventListener = {handleEvent: InputEventHandler} | InputEventHandler

type TouchEventHandler = (event: TouchEvent) => mixed

type TouchEventListener = {handleEvent: TouchEventHandler} | TouchEventHandler

type WheelEventHandler = (event: WheelEvent) => mixed

type WheelEventListener = {handleEvent: WheelEventHandler} | WheelEventHandler

type AbortProgressEventHandler = (event: ProgressEvent) => mixed

type AbortProgressEventListener = {handleEvent: AbortProgressEventHandler} | AbortProgressEventHandler

type ProgressEventHandler = (event: ProgressEvent) => mixed

type ProgressEventListener = {handleEvent: ProgressEventHandler} | ProgressEventHandler

type DragEventHandler = (event: DragEvent) => mixed

type DragEventListener = {handleEvent: DragEventHandler} | DragEventHandler

type PointerEventHandler = (event: PointerEvent) => mixed

type PointerEventListener = {handleEvent: PointerEventHandler} | PointerEventHandler

type AnimationEventHandler = (event: AnimationEvent) => mixed

type AnimationEventListener = {handleEvent: AnimationEventHandler} | AnimationEventHandler

type ClipboardEventHandler = (event: ClipboardEvent) => mixed

type ClipboardEventListener = {handleEvent: ClipboardEventHandler} | ClipboardEventHandler

type TransitionEventHandler = (event: TransitionEvent) => mixed

type TransitionEventListener = {handleEvent: TransitionEventHandler} | TransitionEventHandler

type MessageEventHandler = (event: MessageEvent) => mixed

type MessageEventListener = {handleEvent: MessageEventHandler} | MessageEventHandler

type FocusEventTypes = 'blur' | 'focus' | 'focusin' | 'focusout';

type KeyboardEventTypes = 'keydown' | 'keyup' | 'keypress';

type InputEventTypes = 'input' | 'beforeinput'

type TouchEventTypes = 'touchstart' | 'touchmove' | 'touchend' | 'touchcancel';

type WheelEventTypes = 'wheel';

type AbortProgressEventTypes = 'abort';

type AnimationEventTypes = 'animationstart' | 'animationend' | 'animationiteration';

type ClipboardEventTypes = 'clipboardchange' | 'cut' | 'copy' | 'paste';

type TransitionEventTypes = 'transitionrun' | 'transitionstart' | 'transitionend' | 'transitioncancel';

type MessageEventTypes = 'message';

type EventListenerOptionsOrUseCapture = boolean | {

capture?: boolean,

once?: boolean,

passive?: boolean

};

declare class EventTarget {

addEventListener(type: MouseEventTypes, listener: MouseEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: FocusEventTypes, listener: FocusEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: KeyboardEventTypes, listener: KeyboardEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: InputEventTypes, listener: InputEventHandler, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: TouchEventTypes, listener: TouchEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: WheelEventTypes, listener: WheelEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: AbortProgressEventTypes, listener: AbortProgressEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: ProgressEventTypes, listener: ProgressEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: DragEventTypes, listener: DragEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: PointerEventTypes, listener: PointerEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: AnimationEventTypes, listener: AnimationEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: ClipboardEventTypes, listener: ClipboardEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: TransitionEventTypes, listener: TransitionEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: MessageEventTypes, listener: MessageEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

addEventListener(type: string, listener: EventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: MouseEventTypes, listener: MouseEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: FocusEventTypes, listener: FocusEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: KeyboardEventTypes, listener: KeyboardEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: TouchEventTypes, listener: TouchEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: WheelEventTypes, listener: WheelEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: AbortProgressEventTypes, listener: AbortProgressEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: ProgressEventTypes, listener: ProgressEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: DragEventTypes, listener: DragEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: PointerEventTypes, listener: PointerEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: AnimationEventTypes, listener: AnimationEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: ClipboardEventTypes, listener: ClipboardEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: TransitionEventTypes, listener: TransitionEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: MessageEventTypes, listener: MessageEventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

removeEventListener(type: string, listener: EventListener, optionsOrUseCapture?: EventListenerOptionsOrUseCapture): void;

attachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void;

attachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void;

attachEvent?: (type: KeyboardEventTypes, listener: KeyboardEventListener) => void;

attachEvent?: (type: InputEventTypes, listener: InputEventHandler) => void;

attachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void;

attachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void;

attachEvent?: (type: AbortProgressEventTypes, listener: AbortProgressEventListener) => void;

attachEvent?: (type: ProgressEventTypes, listener: ProgressEventListener) => void;

attachEvent?: (type: DragEventTypes, listener: DragEventListener) => void;

attachEvent?: (type: PointerEventTypes, listener: PointerEventListener) => void;

attachEvent?: (type: AnimationEventTypes, listener: AnimationEventListener) => void;

attachEvent?: (type: ClipboardEventTypes, listener: ClipboardEventListener) => void;

attachEvent?: (type: TransitionEventTypes, listener: TransitionEventListener) => void;

attachEvent?: (type: MessageEventTypes, listener: MessageEventListener) => void;

attachEvent?: (type: string, listener: EventListener) => void;

detachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void;

detachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void;

detachEvent?: (type: KeyboardEventTypes, listener: KeyboardEventListener) => void;

detachEvent?: (type: InputEventTypes, listener: InputEventListener) => void;

detachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void;

detachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void;

detachEvent?: (type: AbortProgressEventTypes, listener: AbortProgressEventListener) => void;

detachEvent?: (type: ProgressEventTypes, listener: ProgressEventListener) => void;

detachEvent?: (type: DragEventTypes, listener: DragEventListener) => void;

detachEvent?: (type: PointerEventTypes, listener: PointerEventListener) => void;

detachEvent?: (type: AnimationEventTypes, listener: AnimationEventListener) => void;

detachEvent?: (type: ClipboardEventTypes, listener: ClipboardEventListener) => void;

detachEvent?: (type: TransitionEventTypes, listener: TransitionEventListener) => void;

detachEvent?: (type: MessageEventTypes, listener: MessageEventListener) => void;

detachEvent?: (type: string, listener: EventListener) => void;

dispatchEvent(evt: Event): boolean;

// Deprecated

cancelBubble: boolean;

initEvent(eventTypeArg: string, canBubbleArg: boolean, cancelableArg: boolean): void;

}

type Event$Init = {

bubbles?: boolean,

cancelable?: boolean,

composed?: boolean,

scoped?: boolean

}

declare class Event {

constructor(type: string, eventInitDict?: Event$Init): void;

bubbles: boolean;

cancelable: boolean;

currentTarget: EventTarget;

deepPath?: () => EventTarget[];

defaultPrevented: boolean;

eventPhase: number;

isTrusted: boolean;

scoped: boolean;

srcElement: Element;

target: EventTarget;

timeStamp: number;

type: string;

preventDefault(): void;

stopImmediatePropagation(): void;

stopPropagation(): void;

AT_TARGET: number;

BUBBLING_PHASE: number;

CAPTURING_PHASE: number;

// deprecated

initEvent(

type: string,

bubbles: boolean,

cancelable: boolean

): void;

}

type CustomEvent$Init = Event$Init & {

detail?: any;

}

declare class CustomEvent extends Event {

constructor(type: string, eventInitDict?: CustomEvent$Init): void;

detail: any;

// deprecated

initCustomEvent(

type: string,

bubbles: boolean,

cancelable: boolean,

detail: any

): CustomEvent;

}

declare class UIEvent extends Event {

detail: number;

view: any;

}

type MouseEvent$MouseEventInit = {

screenX?: number,

screenY?: number,

clientX?: number,

clientY?: number,

ctrlKey?: boolean,

shiftKey?: boolean,

altKey?: boolean,

metaKey?: boolean,

button?: number,

buttons?: number,

region?: string | null,

relatedTarget?: EventTarget | null,

};

declare class MouseEvent extends UIEvent {

constructor(

typeArg: string,

mouseEventInit?: MouseEvent$MouseEventInit,

): void;

altKey: boolean;

button: number;

buttons: number;

clientX: number;

clientY: number;

ctrlKey: boolean;

metaKey: boolean;

movementX: number;

movementY: number;

offsetX: number;

offsetY: number;

pageX: number;

pageY: number;

region: string | null;

relatedTarget: EventTarget | null;

screenX: number;

screenY: number;

shiftKey: boolean;

x: number;

y: number;

getModifierState(keyArg: string): boolean;

}

declare class FocusEvent extends UIEvent {

relatedTarget: ?EventTarget;

}

declare class WheelEvent extends MouseEvent {

deltaX: number; // readonly

deltaY: number; // readonly

deltaZ: number; // readonly

deltaMode: 0x00 | 0x01 | 0x02; // readonly

}

declare class DragEvent extends MouseEvent {

dataTransfer: ?DataTransfer; // readonly

}

type PointerEvent$PointerEventInit = MouseEvent$MouseEventInit & {

pointerId?: number;

width?: number;

height?: number;

pressure?: number;

tangentialPressure?: number;

tiltX?: number;

tiltY?: number;

twist?: number;

pointerType?: string;

isPrimary?: boolean;

};

declare class PointerEvent extends MouseEvent {

constructor(

typeArg: string,

pointerEventInit?: PointerEvent$PointerEventInit,

): void;

pointerId: number;

width: number;

height: number;

pressure: number;

tangentialPressure: number;

tiltX: number;

tiltY: number;

twist: number;

pointerType: string;

isPrimary: boolean;

}

declare class ProgressEvent extends Event {

lengthComputable: boolean;

loaded: number;

total: number;

// Deprecated

initProgressEvent(

typeArg: string,

canBubbleArg: boolean,

cancelableArg: boolean,

lengthComputableArg: boolean,

loadedArg: number,

totalArg: number

): void;

}

declare class PromiseRejectionEvent extends Event {

promise: Promise<any>;

reason: any;

}

// used for websockets and postMessage, for example. See:

// http://www.w3.org/TR/2011/WD-websockets-20110419/

// and

// http://www.w3.org/TR/2008/WD-html5-20080610/comms.html

// and

// https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interfaces

declare class MessageEvent extends Event {

data: mixed;

origin: string;

lastEventId: string;

source: WindowProxy;

}

declare class KeyboardEvent extends UIEvent {

altKey: boolean;

code: string;

ctrlKey: boolean;

isComposing: boolean;

key: string;

location: number;

metaKey: boolean;

repeat: boolean;

shiftKey: boolean;

getModifierState(keyArg?: string): boolean;

// Deprecated

charCode: number;

keyCode: number;

which: number;

}

declare class InputEvent extends UIEvent {

data: string | null;

isComposing: boolean;

}

declare class AnimationEvent extends Event {

animationName: string;

elapsedTime: number;

pseudoElement: string;

// deprecated

initAnimationEvent: (

type: 'animationstart' | 'animationend' | 'animationiteration',

canBubble: boolean,

cancelable: boolean,

animationName: string,

elapsedTime: number

) => void;

}

// https://html.spec.whatwg.org/multipage/web-messaging.html#broadcasting-to-other-browsing-contexts

declare class BroadcastChannel {

onmessage: ?(event: MessageEvent) => void;

onmessageerror: ?(event: MessageEvent) => void;

constructor(name: string): void;

postMessage(msg: mixed): void;

close(): void;

}

// https://www.w3.org/TR/touch-events/#idl-def-Touch

declare class Touch {

clientX: number,

clientY: number,

identifier: number,

pageX: number,

pageY: number,

screenX: number,

screenY: number,

target: EventTarget,

}

// https://www.w3.org/TR/touch-events/#idl-def-TouchList

// TouchList#item(index) will return null if n > #length. Should #item's

// return type just been Touch?

declare class TouchList {

@@iterator(): Iterator<Touch>;

length: number,

item(index: number): null | Touch,

[index: number]: Touch,

}

// https://www.w3.org/TR/touch-events/#touchevent-interface

declare class TouchEvent extends UIEvent {

altKey: boolean,

changedTouches: TouchList,

ctrlKey: boolean,

metaKey: boolean,

shiftKey: boolean,

targetTouches: TouchList,

touches: TouchList,

}

// https://www.w3.org/TR/webstorage/#the-storageevent-interface

declare class StorageEvent extends Event {

key: ?string,

oldValue: ?string,

newValue: ?string,

url: string,

storageArea: ?Storage,

}

// https://w3c.github.io/clipboard-apis/ as of 15 May 2018

type ClipboardEvent$Init = Event$Init & {

clipboardData: DataTransfer | null;

};

declare class ClipboardEvent extends Event {

constructor(type: ClipboardEventTypes, eventInit?: ClipboardEvent$Init): void;

+clipboardData: ?DataTransfer; // readonly

}

// https://www.w3.org/TR/2017/WD-css-transitions-1-20171130/#interface-transitionevent

type TransitionEvent$Init = Event$Init & {

propertyName: string;

elapsedTime: number;

pseudoElement: string;

};

declare class TransitionEvent extends Event {

constructor(type: TransitionEventTypes, eventInit?: TransitionEvent$Init): void;

+propertyName: string; // readonly

+elapsedTime: number; // readonly

+pseudoElement: string; // readonly

}

// TODO: *Event

declare class Node extends EventTarget {

baseURI: ?string;

childNodes: NodeList<Node>;

firstChild: ?Node;

+isConnected: boolean;

lastChild: ?Node;

nextSibling: ?Node;

nodeName: string;

nodeType: number;

nodeValue: string;

ownerDocument: Document;

parentElement: ?Element;

parentNode: ?Node;

previousSibling: ?Node;

rootNode: Node;

textContent: string;

appendChild<T: Node>(newChild: T): T;

cloneNode(deep?: boolean): this;

compareDocumentPosition(other: Node): number;

contains(other: ?Node): boolean;

getRootNode(options?: {composed: boolean}): Node;

hasChildNodes(): boolean;

insertBefore<T: Node>(newChild: T, refChild?: ?Node): T;

isDefaultNamespace(namespaceURI: string): boolean;

isEqualNode(arg: Node): boolean;

isSameNode(other: Node): boolean;

lookupNamespaceURI(prefix: string): string;

lookupPrefix(namespaceURI: string): string;

normalize(): void;

removeChild<T: Node>(oldChild: T): T;

replaceChild<T: Node>(newChild: Node, oldChild: T): T;

static ATTRIBUTE_NODE: number;

static CDATA_SECTION_NODE: number;

static COMMENT_NODE: number;

static DOCUMENT_FRAGMENT_NODE: number;

static DOCUMENT_NODE: number;

static DOCUMENT_POSITION_CONTAINED_BY: number;

static DOCUMENT_POSITION_CONTAINS: number;

static DOCUMENT_POSITION_DISCONNECTED: number;

static DOCUMENT_POSITION_FOLLOWING: number;

static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;

static DOCUMENT_POSITION_PRECEDING: number;

static DOCUMENT_TYPE_NODE: number;

static ELEMENT_NODE: number;

static ENTITY_NODE: number;

static ENTITY_REFERENCE_NODE: number;

static NOTATION_NODE: number;

static PROCESSING_INSTRUCTION_NODE: number;

static TEXT_NODE: number;

// Non-standard

innerText?: string;

outerText?: string;

}

declare class NodeList<T> {

@@iterator(): Iterator<T>;

length: number;

item(index: number): T;

[index: number]: T;

forEach(callbackfn: (value: T, index: number, list: NodeList<T>) => any, thisArg?: any): void;

entries(): Iterator<[number, T]>;

keys(): Iterator<number>;

values(): Iterator<T>;

}

declare class NamedNodeMap {

@@iterator(): Iterator<Attr>;

length: number;

removeNamedItemNS(namespaceURI: string, localName: string): Attr;

item(index: number): Attr;

[index: number]: Attr;

removeNamedItem(name: string): Attr;

getNamedItem(name: string): Attr;

setNamedItem(arg: Attr): Attr;

getNamedItemNS(namespaceURI: string, localName: string): Attr;

setNamedItemNS(arg: Attr): Attr;

}

declare class Attr extends Node {

isId: boolean;

specified: boolean;

ownerElement: Element | null;

value: string;

namespaceURI: string | null;

prefix: string | null;

localName: string;

}

declare class HTMLCollection<Elem: HTMLElement> {

@@iterator(): Iterator<Elem>;

length: number;

item(nameOrIndex?: any, optionalIndex?: any): Elem | null;

namedItem(name: string): Elem | null;

[index: number | string]: Elem;

}

// from https://www.w3.org/TR/custom-elements/#extensions-to-document-interface-to-register

type ElementRegistrationOptions = {

+prototype?: {

// from https://www.w3.org/TR/custom-elements/#types-of-callbacks

+createdCallback?: () => mixed;

+attachedCallback?: () => mixed;

+detachedCallback?: () => mixed;

+attributeChangedCallback?:

// attribute is set

((

attributeLocalName: string,

oldAttributeValue: null,

newAttributeValue: string,

attributeNamespace: string

) => mixed) &

// attribute is changed

((

attributeLocalName: string,

oldAttributeValue: string,

newAttributeValue: string,

attributeNamespace: string

) => mixed) &

// attribute is removed

((

attributeLocalName: string,

oldAttributeValue: string,

newAttributeValue: null,

attributeNamespace: string

) => mixed);

};

+extends?: string;

}

declare class Document extends Node {

URL: string;

adoptNode<T: Node>(source: T): T;

anchors: HTMLCollection<HTMLAnchorElement>;

applets: HTMLCollection<HTMLAppletElement>;

body: HTMLBodyElement | null;

characterSet: string;

close(): void;

cookie: string;

createAttribute(name: string): Attr;

createAttributeNS(namespaceURI: string | null, qualifiedName: string): Attr;

createCDATASection(data: string): Text;

createComment(data: string): Comment;

createDocumentFragment(): DocumentFragment;

createElement(tagName: 'a'): HTMLAnchorElement;

createElement(tagName: 'area'): HTMLAreaElement;

createElement(tagName: 'audio'): HTMLAudioElement;

createElement(tagName: 'blockquote'): HTMLQuoteElement;

createElement(tagName: 'body'): HTMLBodyElement;

createElement(tagName: 'br'): HTMLBRElement;

createElement(tagName: 'button'): HTMLButtonElement;

createElement(tagName: 'canvas'): HTMLCanvasElement;

createElement(tagName: 'col'): HTMLTableColElement;

createElement(tagName: 'colgroup'): HTMLTableColElement;

createElement(tagName: 'data'): HTMLDataElement;

createElement(tagName: 'datalist'): HTMLDataListElement;

createElement(tagName: 'del'): HTMLModElement;

createElement(tagName: 'details'): HTMLDetailsElement;

createElement(tagName: 'dialog'): HTMLDialogElement;

createElement(tagName: 'div'): HTMLDivElement;

createElement(tagName: 'dl'): HTMLDListElement;

createElement(tagName: 'embed'): HTMLEmbedElement;

createElement(tagName: 'fieldset'): HTMLFieldSetElement;

createElement(tagName: 'form'): HTMLFormElement;

createElement(tagName: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'): HTMLHeadingElement;

createElement(tagName: 'head'): HTMLHeadElement;

createElement(tagName: 'hr'): HTMLHRElement;

createElement(tagName: 'html'): HTMLHtmlElement;

createElement(tagName: 'iframe'): HTMLIFrameElement;

createElement(tagName: 'img'): HTMLImageElement;

createElement(tagName: 'input'): HTMLInputElement;

createElement(tagName: 'ins'): HTMLModElement;

createElement(tagName: 'label'): HTMLLabelElement;

createElement(tagName: 'legend'): HTMLLegendElement;

createElement(tagName: 'li'): HTMLLIElement;

createElement(tagName: 'link'): HTMLLinkElement;

createElement(tagName: 'map'): HTMLMapElement;

createElement(tagName: 'meta'): HTMLMetaElement;

createElement(tagName: 'meter'): HTMLMeterElement;

createElement(tagName: 'object'): HTMLObjectElement;

createElement(tagName: 'ol'): HTMLOListElement;

createElement(tagName: 'optgroup'): HTMLOptGroupElement;

createElement(tagName: 'option'): HTMLOptionElement;

createElement(tagName: 'p'): HTMLParagraphElement;

createElement(tagName: 'param'): HTMLParamElement;

createElement(tagName: 'picture'): HTMLPictureElement;

createElement(tagName: 'pre'): HTMLPreElement;

createElement(tagName: 'progress'): HTMLProgressElement;

createElement(tagName: 'q'): HTMLQuoteElement;

createElement(tagName: 'script'): HTMLScriptElement;

createElement(tagName: 'select'): HTMLSelectElement;

createElement(tagName: 'source'): HTMLSourceElement;

createElement(tagName: 'span'): HTMLSpanElement;

createElement(tagName: 'style'): HTMLStyleElement;

createElement(tagName: 'textarea'): HTMLTextAreaElement;

createElement(tagName: 'time'): HTMLTimeElement;

createElement(tagName: 'title'): HTMLTitleElement;

createElement(tagName: 'track'): HTMLTrackElement;

createElement(tagName: 'video'): HTMLVideoElement;

createElement(tagName: 'table'): HTMLTableElement;

createElement(tagName: 'caption'): HTMLTableCaptionElement;

createElement(tagName: 'thead' | 'tfoot' | 'tbody'): HTMLTableSectionElement;

createElement(tagName: 'tr'): HTMLTableRowElement;

createElement(tagName: 'td' | 'th'): HTMLTableCellElement;

createElement(tagName: 'template'): HTMLTemplateElement;

createElement(tagName: 'ul'): HTMLUListElement;

createElement(tagName: string): HTMLElement;

createElementNS(namespaceURI: string | null, qualifiedName: string): Element;

createTextNode(data: string): Text;

currentScript: HTMLScriptElement | null;

doctype: DocumentType | null;

documentElement: HTMLElement | null;

documentMode: number;

domain: string | null;

embeds: HTMLCollection<HTMLEmbedElement>;

queryCommandSupported(cmdID: string): boolean;

execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;

forms: HTMLCollection<HTMLFormElement>;

getElementById(elementId: string): HTMLElement | null;

getElementsByClassName(classNames: string): HTMLCollection<HTMLElement>;

getElementsByName(elementName: string): HTMLCollection<HTMLElement>;

getElementsByTagName(name: 'a'): HTMLCollection<HTMLAnchorElement>;

getElementsByTagName(name: 'area'): HTMLCollection<HTMLAreaElement>;

getElementsByTagName(name: 'audio'): HTMLCollection<HTMLAudioElement>;

getElementsByTagName(name: 'blockquote'): HTMLCollection<HTMLQuoteElement>;

getElementsByTagName(name: 'body'): HTMLCollection<HTMLBodyElement>;

getElementsByTagName(name: 'br'): HTMLCollection<HTMLBRElement>;

getElementsByTagName(name: 'button'): HTMLCollection<HTMLButtonElement>;

getElementsByTagName(name: 'canvas'): HTMLCollection<HTMLCanvasElement>;

getElementsByTagName(name: 'col'): HTMLCollection<HTMLTableColElement>;

getElementsByTagName(name: 'colgroup'): HTMLCollection<HTMLTableColElement>;

getElementsByTagName(name: 'data'): HTMLCollection<HTMLDataElement>;

getElementsByTagName(name: 'datalist'): HTMLCollection<HTMLDataListElement>;

getElementsByTagName(name: 'del'): HTMLCollection<HTMLModElement>;

getElementsByTagName(name: 'details'): HTMLCollection<HTMLDetailsElement>;

getElementsByTagName(name: 'dialog'): HTMLCollection<HTMLDialogElement>;

getElementsByTagName(name: 'div'): HTMLCollection<HTMLDivElement>;

getElementsByTagName(name: 'dl'): HTMLCollection<HTMLDListElement>;

getElementsByTagName(name: 'embed'): HTMLCollection<HTMLEmbedElement>;

getElementsByTagName(name: 'fieldset'): HTMLCollection<HTMLFieldSetElement>;

getElementsByTagName(name: 'form'): HTMLCollection<HTMLFormElement>;

getElementsByTagName(name: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'): HTMLCollection<HTMLHeadingElement>;

getElementsByTagName(name: 'head'): HTMLCollection<HTMLHeadElement>;

getElementsByTagName(name: 'hr'): HTMLCollection<HTMLHRElement>;

getElementsByTagName(name: 'html'): HTMLCollection<HTMLHtmlElement>;

getElementsByTagName(name: 'iframe'): HTMLCollection<HTMLIFrameElement>;

getElementsByTagName(name: 'img'): HTMLCollection<HTMLImageElement>;

getElementsByTagName(name: 'input'): HTMLCollection<HTMLInputElement>;

getElementsByTagName(name: 'ins'): HTMLCollection<HTMLModElement>;

getElementsByTagName(name: 'label'): HTMLCollection<HTMLLabelElement>;

getElementsByTagName(name: 'legend'): HTMLCollection<HTMLLegendElement>;

getElementsByTagName(name: 'li'): HTMLCollection<HTMLLIElement>;

getElementsByTagName(name: 'link'): HTMLCollection<HTMLLinkElement>;

getElementsByTagName(name: 'map'): HTMLCollection<HTMLMapElement>;

getElementsByTagName(name: 'meta'): HTMLCollection<HTMLMetaElement>;

getElementsByTagName(name: 'meter'): HTMLCollection<HTMLMeterElement>;

getElementsByTagName(name: 'object'): HTMLCollection<HTMLObjectElement>;

getElementsByTagName(name: 'ol'): HTMLCollection<HTMLOListElement>;

getElementsByTagName(name: 'option'): HTMLCollection<HTMLOptionElement>;

getElementsByTagName(name: 'optgroup'): HTMLCollection<HTMLOptGroupElement>;

getElementsByTagName(name: 'p'): HTMLCollection<HTMLParagraphElement>;

getElementsByTagName(name: 'param'): HTMLCollection<HTMLParamElement>;

getElementsByTagName(name: 'picture'): HTMLCollection<HTMLPictureElement>;

getElementsByTagName(name: 'pre'): HTMLCollection<HTMLPreElement>;

getElementsByTagName(name: 'progress'): HTMLCollection<HTMLProgressElement>;

getElementsByTagName(name: 'q'): HTMLCollection<HTMLQuoteElement>;

getElementsByTagName(name: 'script'): HTMLCollection<HTMLScriptElement>;

getElementsByTagName(name: 'select'): HTMLCollection<HTMLSelectElement>;

getElementsByTagName(name: 'source'): HTMLCollection<HTMLSourceElement>;

getElementsByTagName(name: 'span'): HTMLCollection<HTMLSpanElement>;

getElementsByTagName(name: 'style'): HTMLCollection<HTMLStyleElement>;

getElementsByTagName(name: 'textarea'): HTMLCollection<HTMLTextAreaElement>;

getElementsByTagName(name: 'time'): HTMLCollection<HTMLTimeElement>;

getElementsByTagName(name: 'title'): HTMLCollection<HTMLTitleElement>;

getElementsByTagName(name: 'track'): HTMLCollection<HTMLTrackElement>;

getElementsByTagName(name: 'video'): HTMLCollection<HTMLVideoElement>;

getElementsByTagName(name: 'table'): HTMLCollection<HTMLTableElement>;

getElementsByTagName(name: 'caption'): HTMLCollection<HTMLTableCaptionElement>;

getElementsByTagName(name: 'thead' | 'tfoot' | 'tbody'): HTMLCollection<HTMLTableSectionElement>;

getElementsByTagName(name: 'tr'): HTMLCollection<HTMLTableRowElement>;

getElementsByTagName(name: 'td' | 'th'): HTMLCollection<HTMLTableCellElement>;

getElementsByTagName(name: 'template'): HTMLCollection<HTMLTemplateElement>;

getElementsByTagName(name: 'ul'): HTMLCollection<HTMLUListElement>;

getElementsByTagName(name: string): HTMLCollection<HTMLElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'a'): HTMLCollection<HTMLAnchorElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'area'): HTMLCollection<HTMLAreaElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'audio'): HTMLCollection<HTMLAudioElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'blockquote'): HTMLCollection<HTMLQuoteElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'body'): HTMLCollection<HTMLBodyElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'br'): HTMLCollection<HTMLBRElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'button'): HTMLCollection<HTMLButtonElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'canvas'): HTMLCollection<HTMLCanvasElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'col'): HTMLCollection<HTMLTableColElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'colgroup'): HTMLCollection<HTMLTableColElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'data'): HTMLCollection<HTMLDataElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'datalist'): HTMLCollection<HTMLDataListElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'del'): HTMLCollection<HTMLModElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'details'): HTMLCollection<HTMLDetailsElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'dialog'): HTMLCollection<HTMLDialogElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'div'): HTMLCollection<HTMLDivElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'dl'): HTMLCollection<HTMLDListElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'embed'): HTMLCollection<HTMLEmbedElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'fieldset'): HTMLCollection<HTMLFieldSetElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'form'): HTMLCollection<HTMLFormElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'): HTMLCollection<HTMLHeadingElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'head'): HTMLCollection<HTMLHeadElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'hr'): HTMLCollection<HTMLHRElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'html'): HTMLCollection<HTMLHtmlElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'iframe'): HTMLCollection<HTMLIFrameElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'img'): HTMLCollection<HTMLImageElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'input'): HTMLCollection<HTMLInputElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'ins'): HTMLCollection<HTMLModElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'label'): HTMLCollection<HTMLLabelElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'legend'): HTMLCollection<HTMLLegendElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'li'): HTMLCollection<HTMLLIElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'link'): HTMLCollection<HTMLLinkElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'map'): HTMLCollection<HTMLMapElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'meta'): HTMLCollection<HTMLMetaElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'meter'): HTMLCollection<HTMLMeterElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'object'): HTMLCollection<HTMLObjectElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'ol'): HTMLCollection<HTMLOListElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'option'): HTMLCollection<HTMLOptionElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'optgroup'): HTMLCollection<HTMLOptGroupElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'p'): HTMLCollection<HTMLParagraphElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'param'): HTMLCollection<HTMLParamElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'picture'): HTMLCollection<HTMLPictureElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'pre'): HTMLCollection<HTMLPreElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'progress'): HTMLCollection<HTMLProgressElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'q'): HTMLCollection<HTMLQuoteElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'script'): HTMLCollection<HTMLScriptElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'select'): HTMLCollection<HTMLSelectElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'source'): HTMLCollection<HTMLSourceElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'span'): HTMLCollection<HTMLSpanElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'style'): HTMLCollection<HTMLStyleElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'textarea'): HTMLCollection<HTMLTextAreaElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'time'): HTMLCollection<HTMLTimeElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'title'): HTMLCollection<HTMLTitleElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'track'): HTMLCollection<HTMLTrackElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'video'): HTMLCollection<HTMLVideoElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'table'): HTMLCollection<HTMLTableElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'caption'): HTMLCollection<HTMLTableCaptionElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'thead' | 'tfoot' | 'tbody'): HTMLCollection<HTMLTableSectionElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'tr'): HTMLCollection<HTMLTableRowElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'td' | 'th'): HTMLCollection<HTMLTableCellElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'template'): HTMLCollection<HTMLTemplateElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: 'ul'): HTMLCollection<HTMLUListElement>;

getElementsByTagNameNS(namespaceURI: string | null, localName: string): HTMLCollection<HTMLElement>;

head: HTMLElement | null;

images: HTMLCollection<HTMLImageElement>;

implementation: DOMImplementation;

importNode<T: Node>(importedNode: T, deep: boolean): T;

inputEncoding: string;

lastModified: string;

links: HTMLCollection<HTMLLinkElement>;

media: string;

open(url?: string, name?: string, features?: string, replace?: boolean): any;

readyState: string;

referrer: string;

scripts: HTMLCollection<HTMLScriptElement>;

scrollingElement: HTMLElement | null;

styleSheets: StyleSheetList;

title: string;

visibilityState: 'visible' | 'hidden' | 'prerender' | 'unloaded';

write(...content: Array<string>): void;

writeln(...content: Array<string>): void;

xmlEncoding: string;

xmlStandalone: boolean;

xmlVersion: string;

registerElement(type: string, options?: ElementRegistrationOptions): any;

getSelection(): Selection | null;

// 6.4.6 Focus management APIs

activeElement: HTMLElement | null;

hasFocus(): boolean;

// extension

location: Location;

createEvent(eventInterface: 'CustomEvent'): CustomEvent;

createEvent(eventInterface: string): Event;

createRange(): Range;

elementFromPoint(x: number, y: number): HTMLElement | null;

defaultView: any;

compatMode: 'BackCompat' | 'CSS1Compat';

hidden: boolean;

// from ParentNode interface

childElementCount: number;

children: HTMLCollection<HTMLElement>;

firstElementChild: ?Element;

lastElementChild: ?Element;

append(...nodes: Array<string | Node>): void;

prepend(...nodes: Array<string | Node>): void;

querySelector(selector: 'a'): HTMLAnchorElement | null;

querySelector(selector: 'area'): HTMLAreaElement | null;

querySelector(selector: 'audio'): HTMLAudioElement | null;

querySelector(selector: 'blockquote'): HTMLQuoteElement | null;

querySelector(selector: 'body'): HTMLBodyElement | null;

querySelector(selector: 'br'): HTMLBRElement | null;

querySelector(selector: 'button'): HTMLButtonElement | null;

querySelector(selector: 'canvas'): HTMLCanvasElement | null;

querySelector(selector: 'col'): HTMLTableColElement | null;

querySelector(selector: 'colgroup'): HTMLTableColElement | null;

querySelector(selector: 'data'): HTMLDataElement | null;

querySelector(selector: 'datalist'): HTMLDataListElement | null;

querySelector(selector: 'del'): HTMLModElement | null;

querySelector(selector: 'details'): HTMLDetailsElement | null;

querySelector(selector: 'dialog'): HTMLDialogElement | null;

querySelector(selector: 'div'): HTMLDivElement | null;

querySelector(selector: 'dl'): HTMLDListElement | null;

querySelector(selector: 'embed'): HTMLEmbedElement | null;

querySelector(selector: 'fieldset'): HTMLFieldSetElement | null;

querySelector(selector: 'form'): HTMLFormElement | null;

querySelector(selector: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'): HTMLHeadingElement;

querySelector(selector: 'head'): HTMLHeadElement | null;

querySelector(selector: 'hr'): HTMLHRElement | null;

querySelector(selector: 'html'): HTMLHtmlElement | null;

querySelector(selector: 'iframe'): HTMLIFrameElement | null;

querySelector(selector: 'img'): HTMLImageElement | null;

querySelector(selector: 'ins'): HTMLModElement | null;

querySelector(selector: 'input'): HTMLInputElement | null;

querySelector(selector: 'label'): HTMLLabelElement | null;

querySelector(selector: 'legend'): HTMLLegendElement | null;

querySelector(selector: 'li'): HTMLLIElement | null;

querySelector(selector: 'link'): HTMLLinkElement | null;

querySelector(selector: 'map'): HTMLMapElement | null;

querySelector(selector: 'meta'): HTMLMetaElement | null;

querySelector(selector: 'meter'): HTMLMeterElement | null;

querySelector(selector: 'object'): HTMLObjectElement | null;

querySelector(selector: 'ol'): HTMLOListElement | null;

querySelector(selector: 'option'): HTMLOptionElement | null;

querySelector(selector: 'optgroup'): HTMLOptGroupElement | null;

querySelector(selector: 'p'): HTMLParagraphElement | null;

querySelector(selector: 'param'): HTMLParamElement | null;

querySelector(selector: 'picture'): HTMLPictureElement | null;

querySelector(selector: 'pre'): HTMLPreElement | null;

querySelector(selector: 'progress'): HTMLProgressElement | null;

querySelector(selector: 'q'): HTMLQuoteElement | null;

querySelector(selector: 'script'): HTMLScriptElement | null;

querySelector(selector: 'select'): HTMLSelectElement | null;

querySelector(selector: 'source'): HTMLSourceElement | null;

querySelector(selector: 'span'): HTMLSpanElement | null;

querySelector(selector: 'style'): HTMLStyleElement | null;

querySelector(selector: 'textarea'): HTMLTextAreaElement | null;

querySelector(selector: 'time'): HTMLTimeElement | null;

querySelector(selector: 'title'): HTMLTitleElement | null;

querySelector(selector: 'track'): HTMLTrackElement | null;

querySelector(selector: 'video'): HTMLVideoElement | null;

querySelector(selector: 'table'): HTMLTableElement | null;

querySelector(selector: 'caption'): HTMLTableCaptionElement | null;

View remainder of file in raw view

FilesExpand file tree

dom.js

Latest commit

History

dom.js

File metadata and controls