1// flow-typed signature: 2872ddd56ba4b4bfefacac38ebdc60872// flow-typed version: 3e51657e95/dom/flow_>=v0.261.x34/* Files */56declare class Blob {7  constructor(8    blobParts?: Array<any>,9    options?: {10      type?: string,11      endings?: string,12      ...13    }14  ): void;15  isClosed: boolean;16  size: number;17  type: string;18  close(): void;19  slice(start?: number, end?: number, contentType?: string): Blob;20  arrayBuffer(): Promise<ArrayBuffer>;21  text(): Promise<string>;22  stream(): ReadableStream;23}2425declare class FileReader extends EventTarget {26  +EMPTY: 0;27  +LOADING: 1;28  +DONE: 2;29  +error: null | DOMError;30  +readyState: 0 | 1 | 2;31  +result: null | string | ArrayBuffer;32  abort(): void;33  onabort: null | ((ev: ProgressEvent) => any);34  onerror: null | ((ev: ProgressEvent) => any);35  onload: null | ((ev: ProgressEvent) => any);36  onloadend: null | ((ev: ProgressEvent) => any);37  onloadstart: null | ((ev: ProgressEvent) => any);38  onprogress: null | ((ev: ProgressEvent) => any);39  readAsArrayBuffer(blob: Blob): void;40  readAsBinaryString(blob: Blob): void;41  readAsDataURL(blob: Blob): void;42  readAsText(blob: Blob, encoding?: string): void;43}4445declare type FilePropertyBag = {46  type?: string,47  lastModified?: number,48  ...49};50declare class File extends Blob {51  constructor(52    fileBits: $ReadOnlyArray<string | BufferDataSource | Blob>,53    filename: string,54    options?: FilePropertyBag55  ): void;56  lastModified: number;57  name: string;58}5960declare class FileList {61  @@iterator(): Iterator<File>;62  length: number;63  item(index: number): File;64  [index: number]: File;65}6667declare class DOMError {68  name: string;69}7071declare interface ShadowRoot extends DocumentFragment {72  +delegatesFocus: boolean;73  +host: Element;74  // flowlint unsafe-getters-setters:off75  get innerHTML(): string;76  set innerHTML(value: string | TrustedHTML): void;77  // flowlint unsafe-getters-setters:error78  +mode: ShadowRootMode;7980  // From DocumentOrShadowRoot Mixin.81  +styleSheets: StyleSheetList;82  adoptedStyleSheets: Array<CSSStyleSheet>;83}8485declare type ShadowRootMode = 'open' | 'closed';8687declare type ShadowRootInit = {88  delegatesFocus?: boolean,89  mode: ShadowRootMode,90  ...91};9293declare type ScrollToOptions = {94  top?: number,95  left?: number,96  behavior?: 'auto' | 'smooth',97  ...98};99100type EventHandler = (event: Event) => mixed;101type EventListener = {handleEvent: EventHandler, ...} | EventHandler;102type MouseEventHandler = (event: MouseEvent) => mixed;103type MouseEventListener =104  | {handleEvent: MouseEventHandler, ...}105  | MouseEventHandler;106type FocusEventHandler = (event: FocusEvent) => mixed;107type FocusEventListener =108  | {handleEvent: FocusEventHandler, ...}109  | FocusEventHandler;110type KeyboardEventHandler = (event: KeyboardEvent) => mixed;111type KeyboardEventListener =112  | {handleEvent: KeyboardEventHandler, ...}113  | KeyboardEventHandler;114type InputEventHandler = (event: InputEvent) => mixed;115type InputEventListener =116  | {handleEvent: InputEventHandler, ...}117  | InputEventHandler;118type TouchEventHandler = (event: TouchEvent) => mixed;119type TouchEventListener =120  | {handleEvent: TouchEventHandler, ...}121  | TouchEventHandler;122type WheelEventHandler = (event: WheelEvent) => mixed;123type WheelEventListener =124  | {handleEvent: WheelEventHandler, ...}125  | WheelEventHandler;126type AbortProgressEventHandler = (event: ProgressEvent) => mixed;127type AbortProgressEventListener =128  | {handleEvent: AbortProgressEventHandler, ...}129  | AbortProgressEventHandler;130type ProgressEventHandler = (event: ProgressEvent) => mixed;131type ProgressEventListener =132  | {handleEvent: ProgressEventHandler, ...}133  | ProgressEventHandler;134type DragEventHandler = (event: DragEvent) => mixed;135type DragEventListener =136  | {handleEvent: DragEventHandler, ...}137  | DragEventHandler;138type PointerEventHandler = (event: PointerEvent) => mixed;139type PointerEventListener =140  | {handleEvent: PointerEventHandler, ...}141  | PointerEventHandler;142type AnimationEventHandler = (event: AnimationEvent) => mixed;143type AnimationEventListener =144  | {handleEvent: AnimationEventHandler, ...}145  | AnimationEventHandler;146type ClipboardEventHandler = (event: ClipboardEvent) => mixed;147type ClipboardEventListener =148  | {handleEvent: ClipboardEventHandler, ...}149  | ClipboardEventHandler;150type TransitionEventHandler = (event: TransitionEvent) => mixed;151type TransitionEventListener =152  | {handleEvent: TransitionEventHandler, ...}153  | TransitionEventHandler;154type MessageEventHandler = (event: MessageEvent<>) => mixed;155type MessageEventListener =156  | {handleEvent: MessageEventHandler, ...}157  | MessageEventHandler;158type BeforeUnloadEventHandler = (event: BeforeUnloadEvent) => mixed;159type BeforeUnloadEventListener =160  | {handleEvent: BeforeUnloadEventHandler, ...}161  | BeforeUnloadEventHandler;162type StorageEventHandler = (event: StorageEvent) => mixed;163type StorageEventListener =164  | {handleEvent: StorageEventHandler, ...}165  | StorageEventHandler;166type SecurityPolicyViolationEventHandler = (167  event: SecurityPolicyViolationEvent168) => mixed;169type SecurityPolicyViolationEventListener =170  | {handleEvent: SecurityPolicyViolationEventHandler, ...}171  | SecurityPolicyViolationEventHandler;172type USBConnectionEventHandler = (event: USBConnectionEvent) => mixed;173type USBConnectionEventListener =174  | {handleEvent: USBConnectionEventHandler, ...}175  | USBConnectionEventHandler;176177type MediaKeySessionType = 'temporary' | 'persistent-license';178type MediaKeyStatus =179  | 'usable'180  | 'expired'181  | 'released'182  | 'output-restricted'183  | 'output-downscaled'184  | 'status-pending'185  | 'internal-error';186type MouseEventTypes =187  | 'contextmenu'188  | 'mousedown'189  | 'mouseenter'190  | 'mouseleave'191  | 'mousemove'192  | 'mouseout'193  | 'mouseover'194  | 'mouseup'195  | 'click'196  | 'dblclick';197type FocusEventTypes = 'blur' | 'focus' | 'focusin' | 'focusout';198type KeyboardEventTypes = 'keydown' | 'keyup' | 'keypress';199type InputEventTypes = 'input' | 'beforeinput';200type TouchEventTypes = 'touchstart' | 'touchmove' | 'touchend' | 'touchcancel';201type WheelEventTypes = 'wheel';202type AbortProgressEventTypes = 'abort';203type ProgressEventTypes =204  | 'abort'205  | 'error'206  | 'load'207  | 'loadend'208  | 'loadstart'209  | 'progress'210  | 'timeout';211type DragEventTypes =212  | 'drag'213  | 'dragend'214  | 'dragenter'215  | 'dragexit'216  | 'dragleave'217  | 'dragover'218  | 'dragstart'219  | 'drop';220type PointerEventTypes =221  | 'pointerover'222  | 'pointerenter'223  | 'pointerdown'224  | 'pointermove'225  | 'pointerup'226  | 'pointercancel'227  | 'pointerout'228  | 'pointerleave'229  | 'gotpointercapture'230  | 'lostpointercapture';231type AnimationEventTypes =232  | 'animationstart'233  | 'animationend'234  | 'animationiteration';235type ClipboardEventTypes = 'clipboardchange' | 'cut' | 'copy' | 'paste';236type TransitionEventTypes =237  | 'transitionrun'238  | 'transitionstart'239  | 'transitionend'240  | 'transitioncancel';241type MessageEventTypes = string;242type BeforeUnloadEventTypes = 'beforeunload';243type StorageEventTypes = 'storage';244type SecurityPolicyViolationEventTypes = 'securitypolicyviolation';245type USBConnectionEventTypes = 'connect' | 'disconnect';246type ToggleEventTypes = 'beforetoggle' | 'toggle';247type EventListenerOptionsOrUseCapture =248  | boolean249  | {250      capture?: boolean,251      once?: boolean,252      passive?: boolean,253      signal?: AbortSignal,254      ...255    };256257declare class EventTarget {258  addEventListener(259    type: MouseEventTypes,260    listener: MouseEventListener,261    optionsOrUseCapture?: EventListenerOptionsOrUseCapture262  ): void;263  addEventListener(264    type: FocusEventTypes,265    listener: FocusEventListener,266    optionsOrUseCapture?: EventListenerOptionsOrUseCapture267  ): void;268  addEventListener(269    type: KeyboardEventTypes,270    listener: KeyboardEventListener,271    optionsOrUseCapture?: EventListenerOptionsOrUseCapture272  ): void;273  addEventListener(274    type: InputEventTypes,275    listener: InputEventListener,276    optionsOrUseCapture?: EventListenerOptionsOrUseCapture277  ): void;278  addEventListener(279    type: TouchEventTypes,280    listener: TouchEventListener,281    optionsOrUseCapture?: EventListenerOptionsOrUseCapture282  ): void;283  addEventListener(284    type: WheelEventTypes,285    listener: WheelEventListener,286    optionsOrUseCapture?: EventListenerOptionsOrUseCapture287  ): void;288  addEventListener(289    type: AbortProgressEventTypes,290    listener: AbortProgressEventListener,291    optionsOrUseCapture?: EventListenerOptionsOrUseCapture292  ): void;293  addEventListener(294    type: ProgressEventTypes,295    listener: ProgressEventListener,296    optionsOrUseCapture?: EventListenerOptionsOrUseCapture297  ): void;298  addEventListener(299    type: DragEventTypes,300    listener: DragEventListener,301    optionsOrUseCapture?: EventListenerOptionsOrUseCapture302  ): void;303  addEventListener(304    type: PointerEventTypes,305    listener: PointerEventListener,306    optionsOrUseCapture?: EventListenerOptionsOrUseCapture307  ): void;308  addEventListener(309    type: AnimationEventTypes,310    listener: AnimationEventListener,311    optionsOrUseCapture?: EventListenerOptionsOrUseCapture312  ): void;313  addEventListener(314    type: ClipboardEventTypes,315    listener: ClipboardEventListener,316    optionsOrUseCapture?: EventListenerOptionsOrUseCapture317  ): void;318  addEventListener(319    type: TransitionEventTypes,320    listener: TransitionEventListener,321    optionsOrUseCapture?: EventListenerOptionsOrUseCapture322  ): void;323  addEventListener(324    type: MessageEventTypes,325    listener: MessageEventListener,326    optionsOrUseCapture?: EventListenerOptionsOrUseCapture327  ): void;328  addEventListener(329    type: BeforeUnloadEventTypes,330    listener: BeforeUnloadEventListener,331    optionsOrUseCapture?: EventListenerOptionsOrUseCapture332  ): void;333  addEventListener(334    type: StorageEventTypes,335    listener: StorageEventListener,336    optionsOrUseCapture?: EventListenerOptionsOrUseCapture337  ): void;338  addEventListener(339    type: SecurityPolicyViolationEventTypes,340    listener: SecurityPolicyViolationEventListener,341    optionsOrUseCapture?: EventListenerOptionsOrUseCapture342  ): void;343  addEventListener(344    type: USBConnectionEventTypes,345    listener: USBConnectionEventListener,346    optionsOrUseCapture?: EventListenerOptionsOrUseCapture347  ): void;348  addEventListener(349    type: string,350    listener: EventListener,351    optionsOrUseCapture?: EventListenerOptionsOrUseCapture352  ): void;353354  removeEventListener(355    type: MouseEventTypes,356    listener: MouseEventListener,357    optionsOrUseCapture?: EventListenerOptionsOrUseCapture358  ): void;359  removeEventListener(360    type: FocusEventTypes,361    listener: FocusEventListener,362    optionsOrUseCapture?: EventListenerOptionsOrUseCapture363  ): void;364  removeEventListener(365    type: KeyboardEventTypes,366    listener: KeyboardEventListener,367    optionsOrUseCapture?: EventListenerOptionsOrUseCapture368  ): void;369  removeEventListener(370    type: InputEventTypes,371    listener: InputEventListener,372    optionsOrUseCapture?: EventListenerOptionsOrUseCapture373  ): void;374  removeEventListener(375    type: TouchEventTypes,376    listener: TouchEventListener,377    optionsOrUseCapture?: EventListenerOptionsOrUseCapture378  ): void;379  removeEventListener(380    type: WheelEventTypes,381    listener: WheelEventListener,382    optionsOrUseCapture?: EventListenerOptionsOrUseCapture383  ): void;384  removeEventListener(385    type: AbortProgressEventTypes,386    listener: AbortProgressEventListener,387    optionsOrUseCapture?: EventListenerOptionsOrUseCapture388  ): void;389  removeEventListener(390    type: ProgressEventTypes,391    listener: ProgressEventListener,392    optionsOrUseCapture?: EventListenerOptionsOrUseCapture393  ): void;394  removeEventListener(395    type: DragEventTypes,396    listener: DragEventListener,397    optionsOrUseCapture?: EventListenerOptionsOrUseCapture398  ): void;399  removeEventListener(400    type: PointerEventTypes,401    listener: PointerEventListener,402    optionsOrUseCapture?: EventListenerOptionsOrUseCapture403  ): void;404  removeEventListener(405    type: AnimationEventTypes,406    listener: AnimationEventListener,407    optionsOrUseCapture?: EventListenerOptionsOrUseCapture408  ): void;409  removeEventListener(410    type: ClipboardEventTypes,411    listener: ClipboardEventListener,412    optionsOrUseCapture?: EventListenerOptionsOrUseCapture413  ): void;414  removeEventListener(415    type: TransitionEventTypes,416    listener: TransitionEventListener,417    optionsOrUseCapture?: EventListenerOptionsOrUseCapture418  ): void;419  removeEventListener(420    type: MessageEventTypes,421    listener: MessageEventListener,422    optionsOrUseCapture?: EventListenerOptionsOrUseCapture423  ): void;424  removeEventListener(425    type: BeforeUnloadEventTypes,426    listener: BeforeUnloadEventListener,427    optionsOrUseCapture?: EventListenerOptionsOrUseCapture428  ): void;429  removeEventListener(430    type: StorageEventTypes,431    listener: StorageEventListener,432    optionsOrUseCapture?: EventListenerOptionsOrUseCapture433  ): void;434  removeEventListener(435    type: SecurityPolicyViolationEventTypes,436    listener: SecurityPolicyViolationEventListener,437    optionsOrUseCapture?: EventListenerOptionsOrUseCapture438  ): void;439  removeEventListener(440    type: USBConnectionEventTypes,441    listener: USBConnectionEventListener,442    optionsOrUseCapture?: EventListenerOptionsOrUseCapture443  ): void;444  removeEventListener(445    type: string,446    listener: EventListener,447    optionsOrUseCapture?: EventListenerOptionsOrUseCapture448  ): void;449450  attachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void;451  attachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void;452  attachEvent?: (453    type: KeyboardEventTypes,454    listener: KeyboardEventListener455  ) => void;456  attachEvent?: (type: InputEventTypes, listener: InputEventListener) => void;457  attachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void;458  attachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void;459  attachEvent?: (460    type: AbortProgressEventTypes,461    listener: AbortProgressEventListener462  ) => void;463  attachEvent?: (464    type: ProgressEventTypes,465    listener: ProgressEventListener466  ) => void;467  attachEvent?: (type: DragEventTypes, listener: DragEventListener) => void;468  attachEvent?: (469    type: PointerEventTypes,470    listener: PointerEventListener471  ) => void;472  attachEvent?: (473    type: AnimationEventTypes,474    listener: AnimationEventListener475  ) => void;476  attachEvent?: (477    type: ClipboardEventTypes,478    listener: ClipboardEventListener479  ) => void;480  attachEvent?: (481    type: TransitionEventTypes,482    listener: TransitionEventListener483  ) => void;484  attachEvent?: (485    type: MessageEventTypes,486    listener: MessageEventListener487  ) => void;488  attachEvent?: (489    type: BeforeUnloadEventTypes,490    listener: BeforeUnloadEventListener491  ) => void;492  attachEvent?: (493    type: StorageEventTypes,494    listener: StorageEventListener495  ) => void;496  attachEvent?: (497    type: USBConnectionEventTypes,498    listener: USBConnectionEventListener499  ) => void;500  attachEvent?: (type: string, listener: EventListener) => void;501502  detachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void;503  detachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void;504  detachEvent?: (505    type: KeyboardEventTypes,506    listener: KeyboardEventListener507  ) => void;508  detachEvent?: (type: InputEventTypes, listener: InputEventListener) => void;509  detachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void;510  detachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void;511  detachEvent?: (512    type: AbortProgressEventTypes,513    listener: AbortProgressEventListener514  ) => void;515  detachEvent?: (516    type: ProgressEventTypes,517    listener: ProgressEventListener518  ) => void;519  detachEvent?: (type: DragEventTypes, listener: DragEventListener) => void;520  detachEvent?: (521    type: PointerEventTypes,522    listener: PointerEventListener523  ) => void;524  detachEvent?: (525    type: AnimationEventTypes,526    listener: AnimationEventListener527  ) => void;528  detachEvent?: (529    type: ClipboardEventTypes,530    listener: ClipboardEventListener531  ) => void;532  detachEvent?: (533    type: TransitionEventTypes,534    listener: TransitionEventListener535  ) => void;536  detachEvent?: (537    type: MessageEventTypes,538    listener: MessageEventListener539  ) => void;540  detachEvent?: (541    type: BeforeUnloadEventTypes,542    listener: BeforeUnloadEventListener543  ) => void;544  detachEvent?: (545    type: StorageEventTypes,546    listener: StorageEventListener547  ) => void;548  detachEvent?: (549    type: USBConnectionEventTypes,550    listener: USBConnectionEventListener551  ) => void;552  detachEvent?: (type: string, listener: EventListener) => void;553554  dispatchEvent(evt: Event): boolean;555556  // Deprecated557558  cancelBubble: boolean;559  initEvent(560    eventTypeArg: string,561    canBubbleArg: boolean,562    cancelableArg: boolean563  ): void;564}565566// https://dom.spec.whatwg.org/#dictdef-eventinit567type Event$Init = {568  bubbles?: boolean,569  cancelable?: boolean,570  composed?: boolean,571  /** Non-standard. See `composed` instead. */572  scoped?: boolean,573  ...574};575576// https://dom.spec.whatwg.org/#interface-event577declare class Event {578  constructor(type: string, eventInitDict?: Event$Init): void;579  /**580   * Returns the type of event, e.g. "click", "hashchange", or "submit".581   */582  +type: string;583  /**584   * Returns the object to which event is dispatched (its target).585   */586  +target: EventTarget; // TODO: nullable587  /** @deprecated */588  +srcElement: Element; // TODO: nullable589  /**590   * Returns the object whose event listener's callback is currently being invoked.591   */592  +currentTarget: EventTarget; // TODO: nullable593  /**594   * Returns the invocation target objects of event's path (objects on which595   * listeners will be invoked), except for any nodes in shadow trees of which596   * the shadow root's mode is "closed" that are not reachable from event's597   * currentTarget.598   */599  composedPath(): Array<EventTarget>;600601  +NONE: number;602  +AT_TARGET: number;603  +BUBBLING_PHASE: number;604  +CAPTURING_PHASE: number;605  /**606   * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET,607   * and BUBBLING_PHASE.608   */609  +eventPhase: number;610611  /**612   * When dispatched in a tree, invoking this method prevents event from reaching613   * any objects other than the current object.614   */615  stopPropagation(): void;616  /**617   * Invoking this method prevents event from reaching any registered event618   * listeners after the current one finishes running and, when dispatched in a619   * tree, also prevents event from reaching any other objects.620   */621  stopImmediatePropagation(): void;622623  /**624   * Returns true or false depending on how event was initialized. True if625   * event goes through its target's ancestors in reverse tree order, and626   * false otherwise.627   */628  +bubbles: boolean;629  /**630   * Returns true or false depending on how event was initialized. Its631   * return value does not always carry meaning, but true can indicate632   * that part of the operation during which event was dispatched, can633   * be canceled by invoking the preventDefault() method.634   */635  +cancelable: boolean;636  // returnValue: boolean; // legacy, and some subclasses still define it as a string!637  /**638   * If invoked when the cancelable attribute value is true, and while639   * executing a listener for the event with passive set to false, signals to640   * the operation that caused event to be dispatched that it needs to be641   * canceled.642   */643  preventDefault(): void;644  /**645   * Returns true if preventDefault() was invoked successfully to indicate646   * cancelation, and false otherwise.647   */648  +defaultPrevented: boolean;649  /**650   * Returns true or false depending on how event was initialized. True if651   * event invokes listeners past a ShadowRoot node that is the root of its652   * target, and false otherwise.653   */654  +composed: boolean;655656  /**657   * Returns true if event was dispatched by the user agent, and false otherwise.658   */659  +isTrusted: boolean;660  /**661   * Returns the event's timestamp as the number of milliseconds measured relative662   * to the time origin.663   */664  +timeStamp: number;665666  /** Non-standard. See Event.prototype.composedPath */667  +deepPath?: () => EventTarget[];668  /** Non-standard. See Event.prototype.composed */669  +scoped: boolean;670671  /**672   * @deprecated673   */674  initEvent(type: string, bubbles: boolean, cancelable: boolean): void;675}676677type CustomEvent$Init = {...Event$Init, detail?: any, ...};678679declare class CustomEvent extends Event {680  constructor(type: string, eventInitDict?: CustomEvent$Init): void;681  detail: any;682683  // deprecated684  initCustomEvent(685    type: string,686    bubbles: boolean,687    cancelable: boolean,688    detail: any689  ): CustomEvent;690}691692type UIEvent$Init = {...Event$Init, detail?: number, view?: any, ...};693694declare class UIEvent extends Event {695  constructor(typeArg: string, uiEventInit?: UIEvent$Init): void;696  detail: number;697  view: any;698}699700declare class CompositionEvent extends UIEvent {701  data: string | null;702  locale: string;703}704705type MouseEvent$MouseEventInit = {706  screenX?: number,707  screenY?: number,708  clientX?: number,709  clientY?: number,710  ctrlKey?: boolean,711  shiftKey?: boolean,712  altKey?: boolean,713  metaKey?: boolean,714  button?: number,715  buttons?: number,716  region?: string | null,717  relatedTarget?: EventTarget | null,718  ...719};720721declare class MouseEvent extends UIEvent {722  constructor(723    typeArg: string,724    mouseEventInit?: MouseEvent$MouseEventInit725  ): void;726  altKey: boolean;727  button: number;728  buttons: number;729  clientX: number;730  clientY: number;731  ctrlKey: boolean;732  metaKey: boolean;733  movementX: number;734  movementY: number;735  offsetX: number;736  offsetY: number;737  pageX: number;738  pageY: number;739  region: string | null;740  relatedTarget: EventTarget | null;741  screenX: number;742  screenY: number;743  shiftKey: boolean;744  x: number;745  y: number;746  getModifierState(keyArg: string): boolean;747}748749declare class FocusEvent extends UIEvent {750  relatedTarget: ?EventTarget;751}752753type WheelEvent$Init = {754  ...MouseEvent$MouseEventInit,755  deltaX?: number,756  deltaY?: number,757  deltaZ?: number,758  deltaMode?: 0x00 | 0x01 | 0x02,759  ...760};761762declare class WheelEvent extends MouseEvent {763  static +DOM_DELTA_PIXEL: 0x00;764  static +DOM_DELTA_LINE: 0x01;765  static +DOM_DELTA_PAGE: 0x02;766767  constructor(type: string, eventInitDict?: WheelEvent$Init): void;768  +deltaX: number;769  +deltaY: number;770  +deltaZ: number;771  +deltaMode: 0x00 | 0x01 | 0x02;772}773774declare class DragEvent extends MouseEvent {775  dataTransfer: ?DataTransfer; // readonly776}777778type PointerEvent$PointerEventInit = MouseEvent$MouseEventInit & {779  pointerId?: number,780  width?: number,781  height?: number,782  pressure?: number,783  tangentialPressure?: number,784  tiltX?: number,785  tiltY?: number,786  twist?: number,787  pointerType?: string,788  isPrimary?: boolean,789  ...790};791792declare class PointerEvent extends MouseEvent {793  constructor(794    typeArg: string,795    pointerEventInit?: PointerEvent$PointerEventInit796  ): void;797  pointerId: number;798  width: number;799  height: number;800  pressure: number;801  tangentialPressure: number;802  tiltX: number;803  tiltY: number;804  twist: number;805  pointerType: string;806  isPrimary: boolean;807}808809declare class ProgressEvent extends Event {810  lengthComputable: boolean;811  loaded: number;812  total: number;813814  // Deprecated815  initProgressEvent(816    typeArg: string,817    canBubbleArg: boolean,818    cancelableArg: boolean,819    lengthComputableArg: boolean,820    loadedArg: number,821    totalArg: number822  ): void;823}824825declare class PromiseRejectionEvent extends Event {826  promise: Promise<any>;827  reason: any;828}829830type PageTransitionEventInit = {831  ...Event$Init,832  persisted: boolean,833  ...834};835836// https://html.spec.whatwg.org/multipage/browsing-the-web.html#the-pagetransitionevent-interface837declare class PageTransitionEvent extends Event {838  constructor(type: string, init?: PageTransitionEventInit): void;839  +persisted: boolean;840}841842// used for websockets and postMessage, for example. See:843// https://www.w3.org/TR/2011/WD-websockets-20110419/844// and845// https://www.w3.org/TR/2008/WD-html5-20080610/comms.html846// and847// https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interfaces848declare class MessageEvent<Data = mixed> extends Event {849  data: Data;850  origin: string;851  lastEventId: string;852  source: WindowProxy;853}854855// https://w3c.github.io/uievents/#idl-keyboardeventinit856type KeyboardEvent$Init = {857  ...UIEvent$Init,858  /**859   * Initializes the `key` attribute of the KeyboardEvent object to the unicode860   * character string representing the meaning of a key after taking into861   * account all keyboard modifiers (such as shift-state). This value is the862   * final effective value of the key. If the key is not a printable character,863   * then it should be one of the key values defined in [UIEvents-Key](https://www.w3.org/TR/uievents-key/).864   *865   * NOTE: not `null`, this results in `evt.key === 'null'`!866   */867  key?: string | void,868  /**869   * Initializes the `code` attribute of the KeyboardEvent object to the unicode870   * character string representing the key that was pressed, ignoring any871   * keyboard modifications such as keyboard layout. This value should be one872   * of the code values defined in [UIEvents-Code](https://www.w3.org/TR/uievents-code/).873   *874   * NOTE: not `null`, this results in `evt.code === 'null'`!875   */876  code?: string | void,877  /**878   * Initializes the `location` attribute of the KeyboardEvent object to one of879   * the following location numerical constants:880   *881   *   DOM_KEY_LOCATION_STANDARD (numerical value 0)882   *   DOM_KEY_LOCATION_LEFT (numerical value 1)883   *   DOM_KEY_LOCATION_RIGHT (numerical value 2)884   *   DOM_KEY_LOCATION_NUMPAD (numerical value 3)885   */886  location?: number,887  /**888   * Initializes the `ctrlKey` attribute of the KeyboardEvent object to true if889   * the Control key modifier is to be considered active, false otherwise.890   */891  ctrlKey?: boolean,892  /**893   * Initializes the `shiftKey` attribute of the KeyboardEvent object to true if894   * the Shift key modifier is to be considered active, false otherwise.895   */896  shiftKey?: boolean,897  /**898   * Initializes the `altKey` attribute of the KeyboardEvent object to true if899   * the Alt (alternative) (or Option) key modifier is to be considered active,900   * false otherwise.901   */902  altKey?: boolean,903  /**904   * Initializes the `metaKey` attribute of the KeyboardEvent object to true if905   * the Meta key modifier is to be considered active, false otherwise.906   */907  metaKey?: boolean,908  /**909   * Initializes the `repeat` attribute of the KeyboardEvent object. This910   * attribute should be set to true if the the current KeyboardEvent is911   * considered part of a repeating sequence of similar events caused by the912   * long depression of any single key, false otherwise.913   */914  repeat?: boolean,915  /**916   * Initializes the `isComposing` attribute of the KeyboardEvent object. This917   * attribute should be set to true if the event being constructed occurs as918   * part of a composition sequence, false otherwise.919   */920  isComposing?: boolean,921  /**922   * Initializes the `charCode` attribute of the KeyboardEvent to the Unicode923   * code point for the event’s character.924   */925  charCode?: number,926  /**927   * Initializes the `keyCode` attribute of the KeyboardEvent to the system-928   * and implementation-dependent numerical code signifying the unmodified929   * identifier associated with the key pressed.930   */931  keyCode?: number,932  /** Initializes the `which` attribute */933  which?: number,934  ...935};936937// https://w3c.github.io/uievents/#idl-keyboardevent938declare class KeyboardEvent extends UIEvent {939  constructor(typeArg: string, init?: KeyboardEvent$Init): void;940941  /** `true` if the Alt (alternative) (or "Option") key modifier was active. */942  +altKey: boolean;943  /**944   * Holds a string that identifies the physical key being pressed. The value945   * is not affected by the current keyboard layout or modifier state, so a946   * particular key will always return the same value.947   */948  +code: string;949  /** `true` if the Control (control) key modifier was active. */950  +ctrlKey: boolean;951  /**952   * `true` if the key event occurs as part of a composition session, i.e.,953   * after a `compositionstart` event and before the corresponding954   * `compositionend` event.955   */956  +isComposing: boolean;957  /**958   * Holds a [key attribute value](https://www.w3.org/TR/uievents-key/#key-attribute-value)959   * corresponding to the key pressed. */960  +key: string;961  /** An indication of the logical location of the key on the device. */962  +location: number;963  /** `true` if the meta (Meta) key (or "Command") modifier was active. */964  +metaKey: boolean;965  /** `true` if the key has been pressed in a sustained manner. */966  +repeat: boolean;967  /** `true` if the shift (Shift) key modifier was active. */968  +shiftKey: boolean;969970  /**971   * Queries the state of a modifier using a key value.972   *973   * Returns `true` if it is a modifier key and the modifier is activated,974   * `false` otherwise.975   */976  getModifierState(keyArg?: string): boolean;977978  /**979   * Holds a character value, for keypress events which generate character980   * input. The value is the Unicode reference number (code point) of that981   * character (e.g. event.charCode = event.key.charCodeAt(0) for printable982   * characters). For keydown or keyup events, the value of charCode is 0.983   *984   * @deprecated You should use KeyboardEvent.key instead, if available.985   */986  +charCode: number;987  /**988   * Holds a system- and implementation-dependent numerical code signifying989   * the unmodified identifier associated with the key pressed. Unlike the990   * `key` attribute, the set of possible values are not normatively defined.991   * Typically, these value of the keyCode SHOULD represent the decimal992   * codepoint in ASCII or Windows 1252, but MAY be drawn from a different993   * appropriate character set. Implementations that are unable to identify994   * a key use the key value 0.995   *996   * @deprecated You should use KeyboardEvent.key instead, if available.997   */998  +keyCode: number;999  /**1000   * Holds a system- and implementation-dependent numerical code signifying1001   * the unmodified identifier associated with the key pressed. In most cases,1002   * the value is identical to keyCode.1003   *1004   * @deprecated You should use KeyboardEvent.key instead, if available.1005   */1006  +which: number;1007}10081009type InputEvent$Init = {1010  ...UIEvent$Init,1011  inputType?: string,1012  data?: string,1013  dataTransfer?: DataTransfer,1014  isComposing?: boolean,1015  ranges?: Array<any>, // TODO: StaticRange1016  ...1017};10181019declare class InputEvent extends UIEvent {1020  constructor(typeArg: string, inputEventInit: InputEvent$Init): void;1021  +data: string | null;1022  +dataTransfer: DataTransfer | null;1023  +inputType: string;1024  +isComposing: boolean;1025  getTargetRanges(): Array<any>; // TODO: StaticRange1026}10271028declare class AnimationEvent extends Event {1029  animationName: string;1030  elapsedTime: number;1031  pseudoElement: string;10321033  // deprecated10341035  initAnimationEvent: (1036    type: 'animationstart' | 'animationend' | 'animationiteration',1037    canBubble: boolean,1038    cancelable: boolean,1039    animationName: string,1040    elapsedTime: number1041  ) => void;1042}10431044// https://www.w3.org/TR/touch-events/#idl-def-Touch1045declare class Touch {1046  clientX: number;1047  clientY: number;1048  identifier: number;1049  pageX: number;1050  pageY: number;1051  screenX: number;1052  screenY: number;1053  target: EventTarget;1054}10551056// https://www.w3.org/TR/touch-events/#idl-def-TouchList1057// TouchList#item(index) will return null if n > #length. Should #item's1058// return type just been Touch?1059declare class TouchList {1060  @@iterator(): Iterator<Touch>;1061  length: number;1062  item(index: number): null | Touch;1063  [index: number]: Touch;1064}10651066// https://www.w3.org/TR/touch-events/#touchevent-interface1067declare class TouchEvent extends UIEvent {1068  altKey: boolean;1069  changedTouches: TouchList;1070  ctrlKey: boolean;1071  metaKey: boolean;1072  shiftKey: boolean;1073  targetTouches: TouchList;1074  touches: TouchList;1075}10761077// https://www.w3.org/TR/clipboard-apis/#typedefdef-clipboarditemdata1078// Raw string | Blob are allowed per https://webidl.spec.whatwg.org/#es-promise1079type ClipboardItemData = string | Blob | Promise<string | Blob>;10801081type PresentationStyle = 'attachment' | 'inline' | 'unspecified';10821083type ClipboardItemOptions = {1084  presentationStyle?: PresentationStyle,1085  ...1086};10871088declare class ClipboardItem {1089  +types: $ReadOnlyArray<string>;1090  getType(type: string): Promise<Blob>;1091  constructor(1092    items: {[type: string]: ClipboardItemData},1093    options?: ClipboardItemOptions1094  ): void;1095}10961097// https://w3c.github.io/clipboard-apis/ as of 15 May 20181098type ClipboardEvent$Init = {1099  ...Event$Init,1100  clipboardData: DataTransfer | null,1101  ...1102};11031104declare class ClipboardEvent extends Event {1105  constructor(type: ClipboardEventTypes, eventInit?: ClipboardEvent$Init): void;1106  +clipboardData: ?DataTransfer; // readonly1107}11081109// https://www.w3.org/TR/2017/WD-css-transitions-1-20171130/#interface-transitionevent1110type TransitionEvent$Init = {1111  ...Event$Init,1112  propertyName: string,1113  elapsedTime: number,1114  pseudoElement: string,1115  ...1116};11171118declare class TransitionEvent extends Event {1119  constructor(1120    type: TransitionEventTypes,1121    eventInit?: TransitionEvent$Init1122  ): void;11231124  +propertyName: string; // readonly1125  +elapsedTime: number; // readonly1126  +pseudoElement: string; // readonly1127}11281129declare class SecurityPolicyViolationEvent extends Event {1130  +documentURI: string;1131  +referrer: string;1132  +blockedURI: string;1133  +effectiveDirective: string;1134  +violatedDirective: string;1135  +originalPolicy: string;1136  +sourceFile: string;1137  +sample: string;1138  +disposition: 'enforce' | 'report';1139  +statusCode: number;1140  +lineNumber: number;1141  +columnNumber: number;1142}11431144// https://developer.mozilla.org/en-US/docs/Web/API/USBConnectionEvent1145declare class USBConnectionEvent extends Event {1146  device: USBDevice;1147}11481149// TODO: *Event11501151declare class AbortController {1152  constructor(): void;1153  +signal: AbortSignal;1154  abort(reason?: any): void;1155}11561157declare class AbortSignal extends EventTarget {1158  +aborted: boolean;1159  +reason: any;1160  abort(reason?: any): AbortSignal;1161  onabort: (event: Event) => mixed;1162  throwIfAborted(): void;1163  timeout(time: number): AbortSignal;1164}11651166declare class Node extends EventTarget {1167  baseURI: ?string;1168  childNodes: NodeList<Node>;1169  firstChild: ?Node;1170  +isConnected: boolean;1171  lastChild: ?Node;1172  nextSibling: ?Node;1173  nodeName: string;1174  nodeType: number;1175  nodeValue: string;1176  ownerDocument: Document;1177  parentElement: ?Element;1178  parentNode: ?Node;1179  previousSibling: ?Node;1180  rootNode: Node;1181  textContent: string;1182  appendChild<T: Node>(newChild: T): T;1183  cloneNode(deep?: boolean): this;1184  compareDocumentPosition(other: Node): number;1185  contains(other: ?Node): boolean;1186  getRootNode(options?: {composed: boolean, ...}): Node;1187  hasChildNodes(): boolean;1188  insertBefore<T: Node>(newChild: T, refChild?: ?Node): T;1189  isDefaultNamespace(namespaceURI: string): boolean;1190  isEqualNode(arg: Node): boolean;1191  isSameNode(other: Node): boolean;1192  lookupNamespaceURI(prefix: string): string;1193  lookupPrefix(namespaceURI: string): string;1194  normalize(): void;1195  removeChild<T: Node>(oldChild: T): T;1196  replaceChild<T: Node>(newChild: Node, oldChild: T): T;1197  replaceChildren(...nodes: $ReadOnlyArray<Node | string>): void;1198  static ATTRIBUTE_NODE: number;1199  static CDATA_SECTION_NODE: number;1200  static COMMENT_NODE: number;1201  static DOCUMENT_FRAGMENT_NODE: number;1202  static DOCUMENT_NODE: number;1203  static DOCUMENT_POSITION_CONTAINED_BY: number;1204  static DOCUMENT_POSITION_CONTAINS: number;1205  static DOCUMENT_POSITION_DISCONNECTED: number;1206  static DOCUMENT_POSITION_FOLLOWING: number;1207  static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;1208  static DOCUMENT_POSITION_PRECEDING: number;1209  static DOCUMENT_TYPE_NODE: number;1210  static ELEMENT_NODE: number;1211  static ENTITY_NODE: number;1212  static ENTITY_REFERENCE_NODE: number;1213  static NOTATION_NODE: number;1214  static PROCESSING_INSTRUCTION_NODE: number;1215  static TEXT_NODE: number;12161217  // Non-standard1218  innerText?: string;1219  outerText?: string;1220}12211222declare class NodeList<T> {1223  @@iterator(): Iterator<T>;1224  length: number;1225  item(index: number): T;1226  [index: number]: T;12271228  forEach<This>(1229    callbackfn: (this: This, value: T, index: number, list: NodeList<T>) => any,1230    thisArg: This1231  ): void;1232  entries(): Iterator<[number, T]>;1233  keys(): Iterator<number>;1234  values(): Iterator<T>;1235}12361237declare class NamedNodeMap {1238  @@iterator(): Iterator<Attr>;1239  length: number;1240  removeNamedItemNS(namespaceURI: string, localName: string): Attr;1241  item(index: number): Attr;1242  [index: number | string]: Attr;1243  removeNamedItem(name: string): Attr;1244  getNamedItem(name: string): Attr;1245  setNamedItem(arg: Attr): Attr;1246  getNamedItemNS(namespaceURI: string, localName: string): Attr;1247  setNamedItemNS(arg: Attr): Attr;1248}12491250declare class Attr extends Node {1251  isId: boolean;1252  specified: boolean;1253  ownerElement: Element | null;1254  value: string;1255  name: string;1256  namespaceURI: string | null;1257  prefix: string | null;1258  localName: string;1259}12601261declare class HTMLCollection<+Elem: Element> {1262  @@iterator(): Iterator<Elem>;1263  length: number;1264  item(nameOrIndex?: any, optionalIndex?: any): Elem | null;1265  namedItem(name: string): Elem | null;1266  // $FlowFixMe[incompatible-variance]1267  [index: number | string]: Elem;1268}12691270// from https://www.w3.org/TR/custom-elements/#extensions-to-document-interface-to-register1271// See also https://github.com/w3c/webcomponents/1272type ElementRegistrationOptions = {1273  +prototype?: {1274    // from https://www.w3.org/TR/custom-elements/#types-of-callbacks1275    // See also https://github.com/w3c/webcomponents/1276    +createdCallback?: () => mixed,1277    +attachedCallback?: () => mixed,1278    +detachedCallback?: () => mixed,1279    +attributeChangedCallback?: ((1280      // attribute is set1281      attributeLocalName: string,1282      oldAttributeValue: null,1283      newAttributeValue: string,1284      attributeNamespace: string1285    ) => mixed) &1286      // attribute is changed1287      ((1288        attributeLocalName: string,1289        oldAttributeValue: string,1290        newAttributeValue: string,1291        attributeNamespace: string1292      ) => mixed) &1293      // attribute is removed1294      ((1295        attributeLocalName: string,1296        oldAttributeValue: string,1297        newAttributeValue: null,1298        attributeNamespace: string1299      ) => mixed),1300    ...1301  },1302  +extends?: string,1303  ...1304};13051306type ElementCreationOptions = {is: string, ...};13071308declare class MutationRecord {1309  type: 'attributes' | 'characterData' | 'childList';1310  target: Node;1311  addedNodes: NodeList<Node>;1312  removedNodes: NodeList<Node>;1313  previousSibling: ?Node;1314  nextSibling: ?Node;1315  attributeName: ?string;1316  attributeNamespace: ?string;1317  oldValue: ?string;1318}13191320type MutationObserverInitRequired =1321  | {childList: true, ...}1322  | {attributes: true, ...}1323  | {characterData: true, ...};13241325declare type MutationObserverInit = MutationObserverInitRequired & {1326  subtree?: boolean,1327  attributeOldValue?: boolean,1328  characterDataOldValue?: boolean,1329  attributeFilter?: Array<string>,1330  ...1331};13321333declare class MutationObserver {1334  constructor(1335    callback: (arr: Array<MutationRecord>, observer: MutationObserver) => mixed1336  ): void;1337  observe(target: Node, options: MutationObserverInit): void;1338  takeRecords(): Array<MutationRecord>;1339  disconnect(): void;1340}13411342declare class Document extends Node {1343  +timeline: DocumentTimeline;1344  getAnimations(): Array<Animation>;1345  +URL: string;1346  adoptNode<T: Node>(source: T): T;1347  anchors: HTMLCollection<HTMLAnchorElement>;1348  applets: HTMLCollection<HTMLAppletElement>;1349  body: HTMLBodyElement | null;1350  +characterSet: string;1351  /**1352   * Legacy alias of `characterSet`1353   * @deprecated1354   */1355  +charset: string;1356  close(): void;1357  +contentType: string;1358  cookie: string;1359  createAttribute(name: string): Attr;1360  createAttributeNS(namespaceURI: string | null, qualifiedName: string): Attr;1361  createCDATASection(data: string): Text;1362  createComment(data: string): Comment;1363  createDocumentFragment(): DocumentFragment;1364  createElement<TName: $Keys<HTMLElementTagNameMap>>(1365    localName: TName,1366    options?: string | ElementCreationOptions1367  ): HTMLElementTagNameMap[TName];1368  createElementNS<TName: $Keys<HTMLElementTagNameMap>>(1369    namespaceURI: 'http://www.w3.org/1999/xhtml',1370    qualifiedName: TName,1371    options?: string | ElementCreationOptions1372  ): HTMLElementTagNameMap[TName];1373  createElementNS(1374    namespaceURI: string | null,1375    qualifiedName: string,1376    options?: string | ElementCreationOptions1377  ): Element;1378  createTextNode(data: string): Text;1379  currentScript: HTMLScriptElement | null;1380  dir: 'rtl' | 'ltr';1381  +doctype: DocumentType | null;1382  +documentElement: HTMLElement | null;1383  documentMode: number;1384  +documentURI: string;1385  domain: string | null;1386  embeds: HTMLCollection<HTMLEmbedElement>;1387  exitFullscreen(): Promise<void>;1388  queryCommandSupported(cmdID: string): boolean;1389  execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;1390  forms: HTMLCollection<HTMLFormElement>;1391  fullscreenElement: Element | null;1392  fullscreenEnabled: boolean;1393  getElementsByClassName(classNames: string): HTMLCollection<HTMLElement>;1394  getElementsByName(elementName: string): HTMLCollection<HTMLElement>;1395  getElementsByTagName<TName: $Keys<HTMLElementTagNameMap>>(1396    qualifiedName: TName1397  ): HTMLCollection<HTMLElementTagNameMap[TName]>;1398  getElementsByTagNameNS<TName: $Keys<HTMLElementTagNameMap>>(1399    namespaceURI: 'http://www.w3.org/1999/xhtml',1400    qualifiedName: TName1401  ): HTMLCollection<HTMLElementTagNameMap[TName]>;1402  getElementsByTagNameNS(1403    namespaceURI: string | null,1404    qualifiedName: string1405  ): HTMLCollection<Element>;1406  head: HTMLHeadElement | null;1407  images: HTMLCollection<HTMLImageElement>;1408  +implementation: DOMImplementation;1409  importNode<T: Node>(importedNode: T, deep: boolean): T;1410  /**1411   * Legacy alias of `characterSet`1412   * @deprecated1413   */1414  +inputEncoding: string;1415  lastModified: string;1416  links: HTMLCollection<HTMLLinkElement>;1417  media: string;1418  open(url?: string, name?: string, features?: string, replace?: boolean): any;1419  /** @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Document/prerendering} */1420  prerendering: boolean;1421  readyState: string;1422  referrer: string;1423  scripts: HTMLCollection<HTMLScriptElement>;1424  scrollingElement: HTMLElement | null;1425  title: string;1426  visibilityState: 'visible' | 'hidden' | 'prerender' | 'unloaded';1427  write(...content: Array<string | TrustedHTML>): void;1428  writeln(...content: Array<string | TrustedHTML>): void;1429  xmlEncoding: string;1430  xmlStandalone: boolean;1431  xmlVersion: string;14321433  registerElement(type: string, options?: ElementRegistrationOptions): any;1434  getSelection(): Selection | null;14351436  // 6.4.6 Focus management APIs1437  activeElement: HTMLElement | null;1438  hasFocus(): boolean;14391440  // extension1441  location: Location;1442  createEvent(eventInterface: 'CustomEvent'): CustomEvent;1443  createEvent(eventInterface: string): Event;1444  createRange(): Range;1445  elementFromPoint(x: number, y: number): HTMLElement | null;1446  elementsFromPoint(x: number, y: number): Array<HTMLElement>;1447  defaultView: any;1448  +compatMode: 'BackCompat' | 'CSS1Compat';1449  hidden: boolean;14501451  // Pointer Lock specification1452  exitPointerLock(): void;1453  pointerLockElement: Element | null;14541455  // from ParentNode interface1456  childElementCount: number;1457  children: HTMLCollection<HTMLElement>;1458  firstElementChild: ?Element;1459  lastElementChild: ?Element;1460  append(...nodes: Array<string | Node>): void;1461  prepend(...nodes: Array<string | Node>): void;14621463  querySelector<TSelector: $Keys<HTMLElementTagNameMap>>(1464    selector: TSelector1465  ): HTMLElementTagNameMap[TSelector] | null;1466  querySelectorAll<TSelector: $Keys<HTMLElementTagNameMap>>(1467    selector: TSelector1468  ): NodeList<HTMLElementTagNameMap[TSelector]>;1469  // Interface DocumentTraversal1470  // http://www.w3.org/TR/2000/REC-DOM-Level-2-Traversal-Range-20001113/traversal.html#Traversal-Document14711472  // Not all combinations of RootNodeT and whatToShow are logically possible.1473  // The bitmasks NodeFilter.SHOW_CDATA_SECTION,1474  // NodeFilter.SHOW_ENTITY_REFERENCE, NodeFilter.SHOW_ENTITY, and1475  // NodeFilter.SHOW_NOTATION are deprecated and do not correspond to types1476  // that Flow knows about.14771478  // NodeFilter.SHOW_ATTRIBUTE is also deprecated, but corresponds to the1479  // type Attr. While there is no reason to prefer it to Node.attributes,1480  // it does have meaning and can be typed: When (whatToShow &1481  // NodeFilter.SHOW_ATTRIBUTE === 1), RootNodeT must be Attr, and when1482  // RootNodeT is Attr, bitmasks other than NodeFilter.SHOW_ATTRIBUTE are1483  // meaningless.1484  createNodeIterator<RootNodeT: Attr>(1485    root: RootNodeT,1486    whatToShow: 2,1487    filter?: NodeFilterInterface1488  ): NodeIterator<RootNodeT, Attr>;1489  createTreeWalker<RootNodeT: Attr>(1490    root: RootNodeT,1491    whatToShow: 2,1492    filter?: NodeFilterInterface,1493    entityReferenceExpansion?: boolean1494  ): TreeWalker<RootNodeT, Attr>;14951496  // NodeFilter.SHOW_PROCESSING_INSTRUCTION is not implemented because Flow1497  // does not currently define a ProcessingInstruction class.14981499  // When (whatToShow & NodeFilter.SHOW_DOCUMENT === 1 || whatToShow &1500  // NodeFilter.SHOW_DOCUMENT_TYPE === 1), RootNodeT must be Document.1501  createNodeIterator<RootNodeT: Document>(1502    root: RootNodeT,1503    whatToShow: 256,1504    filter?: NodeFilterInterface1505  ): NodeIterator<RootNodeT, Document>;1506  createNodeIterator<RootNodeT: Document>(1507    root: RootNodeT,1508    whatToShow: 257,1509    filter?: NodeFilterInterface1510  ): NodeIterator<RootNodeT, Document | Element>;1511  createNodeIterator<RootNodeT: Document>(1512    root: RootNodeT,1513    whatToShow: 260,1514    filter?: NodeFilterInterface1515  ): NodeIterator<RootNodeT, Document | Text>;1516  createNodeIterator<RootNodeT: Document>(1517    root: RootNodeT,1518    whatToShow: 261,1519    filter?: NodeFilterInterface1520  ): NodeIterator<RootNodeT, Document | Element | Text>;1521  createNodeIterator<RootNodeT: Document>(1522    root: RootNodeT,1523    whatToShow: 384,1524    filter?: NodeFilterInterface1525  ): NodeIterator<RootNodeT, Document | Comment>;1526  createNodeIterator<RootNodeT: Document>(1527    root: RootNodeT,1528    whatToShow: 385,1529    filter?: NodeFilterInterface1530  ): NodeIterator<RootNodeT, Document | Element | Comment>;1531  createNodeIterator<RootNodeT: Document>(1532    root: RootNodeT,1533    whatToShow: 388,1534    filter?: NodeFilterInterface1535  ): NodeIterator<RootNodeT, Document | Text | Comment>;1536  createNodeIterator<RootNodeT: Document>(1537    root: RootNodeT,1538    whatToShow: 389,1539    filter?: NodeFilterInterface1540  ): NodeIterator<RootNodeT, Document | Element | Text | Comment>;1541  createNodeIterator<RootNodeT: Document>(1542    root: RootNodeT,1543    whatToShow: 512,1544    filter?: NodeFilterInterface1545  ): NodeIterator<RootNodeT, DocumentType>;1546  createNodeIterator<RootNodeT: Document>(1547    root: RootNodeT,1548    whatToShow: 513,1549    filter?: NodeFilterInterface1550  ): NodeIterator<RootNodeT, DocumentType | Element>;1551  createNodeIterator<RootNodeT: Document>(1552    root: RootNodeT,1553    whatToShow: 516,1554    filter?: NodeFilterInterface1555  ): NodeIterator<RootNodeT, DocumentType | Text>;1556  createNodeIterator<RootNodeT: Document>(1557    root: RootNodeT,1558    whatToShow: 517,1559    filter?: NodeFilterInterface1560  ): NodeIterator<RootNodeT, DocumentType | Element | Text>;1561  createNodeIterator<RootNodeT: Document>(1562    root: RootNodeT,1563    whatToShow: 640,1564    filter?: NodeFilterInterface1565  ): NodeIterator<RootNodeT, DocumentType | Comment>;1566  createNodeIterator<RootNodeT: Document>(1567    root: RootNodeT,1568    whatToShow: 641,1569    filter?: NodeFilterInterface1570  ): NodeIterator<RootNodeT, DocumentType | Element | Comment>;1571  createNodeIterator<RootNodeT: Document>(1572    root: RootNodeT,1573    whatToShow: 644,1574    filter?: NodeFilterInterface1575  ): NodeIterator<RootNodeT, DocumentType | Text | Comment>;1576  createNodeIterator<RootNodeT: Document>(1577    root: RootNodeT,1578    whatToShow: 645,1579    filter?: NodeFilterInterface1580  ): NodeIterator<RootNodeT, DocumentType | Element | Text | Comment>;1581  createNodeIterator<RootNodeT: Document>(1582    root: RootNodeT,1583    whatToShow: 768,1584    filter?: NodeFilterInterface1585  ): NodeIterator<RootNodeT, DocumentType | Document>;1586  createNodeIterator<RootNodeT: Document>(1587    root: RootNodeT,1588    whatToShow: 769,1589    filter?: NodeFilterInterface1590  ): NodeIterator<RootNodeT, DocumentType | Document | Element>;1591  createNodeIterator<RootNodeT: Document>(1592    root: RootNodeT,1593    whatToShow: 772,1594    filter?: NodeFilterInterface1595  ): NodeIterator<RootNodeT, DocumentType | Document | Text>;1596  createNodeIterator<RootNodeT: Document>(1597    root: RootNodeT,1598    whatToShow: 773,1599    filter?: NodeFilterInterface1600  ): NodeIterator<RootNodeT, DocumentType | Document | Element | Text>;1601  createNodeIterator<RootNodeT: Document>(1602    root: RootNodeT,1603    whatToShow: 896,1604    filter?: NodeFilterInterface1605  ): NodeIterator<RootNodeT, DocumentType | Document | Comment>;1606  createNodeIterator<RootNodeT: Document>(1607    root: RootNodeT,1608    whatToShow: 897,1609    filter?: NodeFilterInterface1610  ): NodeIterator<RootNodeT, DocumentType | Document | Element | Comment>;1611  createNodeIterator<RootNodeT: Document>(1612    root: RootNodeT,1613    whatToShow: 900,1614    filter?: NodeFilterInterface1615  ): NodeIterator<RootNodeT, DocumentType | Document | Text | Comment>;1616  createNodeIterator<RootNodeT: Document>(1617    root: RootNodeT,1618    whatToShow: 901,1619    filter?: NodeFilterInterface1620  ): NodeIterator<1621    RootNodeT,1622    DocumentType | Document | Element | Text | Comment,1623  >;1624  createTreeWalker<RootNodeT: Document>(1625    root: RootNodeT,1626    whatToShow: 256,1627    filter?: NodeFilterInterface,1628    entityReferenceExpansion?: boolean1629  ): TreeWalker<RootNodeT, Document>;1630  createTreeWalker<RootNodeT: Document>(1631    root: RootNodeT,1632    whatToShow: 257,1633    filter?: NodeFilterInterface,1634    entityReferenceExpansion?: boolean1635  ): TreeWalker<RootNodeT, Document | Element>;1636  createTreeWalker<RootNodeT: Document>(1637    root: RootNodeT,1638    whatToShow: 260,1639    filter?: NodeFilterInterface,1640    entityReferenceExpansion?: boolean1641  ): TreeWalker<RootNodeT, Document | Text>;1642  createTreeWalker<RootNodeT: Document>(1643    root: RootNodeT,1644    whatToShow: 261,1645    filter?: NodeFilterInterface,1646    entityReferenceExpansion?: boolean1647  ): TreeWalker<RootNodeT, Document | Element | Text>;1648  createTreeWalker<RootNodeT: Document>(1649    root: RootNodeT,1650    whatToShow: 384,1651    filter?: NodeFilterInterface,1652    entityReferenceExpansion?: boolean1653  ): TreeWalker<RootNodeT, Document | Comment>;1654  createTreeWalker<RootNodeT: Document>(1655    root: RootNodeT,1656    whatToShow: 385,1657    filter?: NodeFilterInterface,1658    entityReferenceExpansion?: boolean1659  ): TreeWalker<RootNodeT, Document | Element | Comment>;1660  createTreeWalker<RootNodeT: Document>(1661    root: RootNodeT,1662    whatToShow: 388,1663    filter?: NodeFilterInterface,1664    entityReferenceExpansion?: boolean1665  ): TreeWalker<RootNodeT, Document | Text | Comment>;1666  createTreeWalker<RootNodeT: Document>(1667    root: RootNodeT,1668    whatToShow: 389,1669    filter?: NodeFilterInterface,1670    entityReferenceExpansion?: boolean1671  ): TreeWalker<RootNodeT, Document | Element | Text | Comment>;1672  createTreeWalker<RootNodeT: Document>(1673    root: RootNodeT,1674    whatToShow: 512,1675    filter?: NodeFilterInterface,1676    entityReferenceExpansion?: boolean1677  ): TreeWalker<RootNodeT, DocumentType>;1678  createTreeWalker<RootNodeT: Document>(1679    root: RootNodeT,1680    whatToShow: 513,1681    filter?: NodeFilterInterface,1682    entityReferenceExpansion?: boolean1683  ): TreeWalker<RootNodeT, DocumentType | Element>;1684  createTreeWalker<RootNodeT: Document>(1685    root: RootNodeT,1686    whatToShow: 516,1687    filter?: NodeFilterInterface,1688    entityReferenceExpansion?: boolean1689  ): TreeWalker<RootNodeT, DocumentType | Text>;1690  createTreeWalker<RootNodeT: Document>(1691    root: RootNodeT,1692    whatToShow: 517,1693    filter?: NodeFilterInterface,1694    entityReferenceExpansion?: boolean1695  ): TreeWalker<RootNodeT, DocumentType | Element | Text>;1696  createTreeWalker<RootNodeT: Document>(1697    root: RootNodeT,1698    whatToShow: 640,1699    filter?: NodeFilterInterface,1700    entityReferenceExpansion?: boolean1701  ): TreeWalker<RootNodeT, DocumentType | Comment>;1702  createTreeWalker<RootNodeT: Document>(1703    root: RootNodeT,1704    whatToShow: 641,1705    filter?: NodeFilterInterface,1706    entityReferenceExpansion?: boolean1707  ): TreeWalker<RootNodeT, DocumentType | Element | Comment>;1708  createTreeWalker<RootNodeT: Document>(1709    root: RootNodeT,1710    whatToShow: 644,1711    filter?: NodeFilterInterface,1712    entityReferenceExpansion?: boolean1713  ): TreeWalker<RootNodeT, DocumentType | Text | Comment>;1714  createTreeWalker<RootNodeT: Document>(1715    root: RootNodeT,1716    whatToShow: 645,1717    filter?: NodeFilterInterface,1718    entityReferenceExpansion?: boolean1719  ): TreeWalker<RootNodeT, DocumentType | Element | Text | Comment>;1720  createTreeWalker<RootNodeT: Document>(1721    root: RootNodeT,1722    whatToShow: 768,1723    filter?: NodeFilterInterface,1724    entityReferenceExpansion?: boolean1725  ): TreeWalker<RootNodeT, DocumentType | Document>;1726  createTreeWalker<RootNodeT: Document>(1727    root: RootNodeT,1728    whatToShow: 769,1729    filter?: NodeFilterInterface,1730    entityReferenceExpansion?: boolean1731  ): TreeWalker<RootNodeT, DocumentType | Document | Element>;1732  createTreeWalker<RootNodeT: Document>(1733    root: RootNodeT,1734    whatToShow: 772,1735    filter?: NodeFilterInterface,1736    entityReferenceExpansion?: boolean1737  ): TreeWalker<RootNodeT, DocumentType | Document | Text>;1738  createTreeWalker<RootNodeT: Document>(1739    root: RootNodeT,1740    whatToShow: 773,1741    filter?: NodeFilterInterface,1742    entityReferenceExpansion?: boolean1743  ): TreeWalker<RootNodeT, DocumentType | Document | Element | Text>;1744  createTreeWalker<RootNodeT: Document>(1745    root: RootNodeT,1746    whatToShow: 896,1747    filter?: NodeFilterInterface,1748    entityReferenceExpansion?: boolean1749  ): TreeWalker<RootNodeT, DocumentType | Document | Comment>;1750  createTreeWalker<RootNodeT: Document>(1751    root: RootNodeT,1752    whatToShow: 897,1753    filter?: NodeFilterInterface,1754    entityReferenceExpansion?: boolean1755  ): TreeWalker<RootNodeT, DocumentType | Document | Element | Comment>;1756  createTreeWalker<RootNodeT: Document>(1757    root: RootNodeT,1758    whatToShow: 900,1759    filter?: NodeFilterInterface,1760    entityReferenceExpansion?: boolean1761  ): TreeWalker<RootNodeT, DocumentType | Document | Text | Comment>;1762  createTreeWalker<RootNodeT: Document>(1763    root: RootNodeT,1764    whatToShow: 901,1765    filter?: NodeFilterInterface,1766    entityReferenceExpansion?: boolean1767  ): TreeWalker<RootNodeT, DocumentType | Document | Element | Text | Comment>;17681769  // When (whatToShow & NodeFilter.SHOW_DOCUMENT_FRAGMENT === 1), RootNodeT1770  // must be a DocumentFragment.1771  createNodeIterator<RootNodeT: DocumentFragment>(1772    root: RootNodeT,1773    whatToShow: 1024,1774    filter?: NodeFilterInterface1775  ): NodeIterator<RootNodeT, DocumentFragment>;1776  createNodeIterator<RootNodeT: DocumentFragment>(1777    root: RootNodeT,1778    whatToShow: 1025,1779    filter?: NodeFilterInterface1780  ): NodeIterator<RootNodeT, DocumentFragment | Element>;1781  createNodeIterator<RootNodeT: DocumentFragment>(1782    root: RootNodeT,1783    whatToShow: 1028,1784    filter?: NodeFilterInterface1785  ): NodeIterator<RootNodeT, DocumentFragment | Text>;1786  createNodeIterator<RootNodeT: DocumentFragment>(1787    root: RootNodeT,1788    whatToShow: 1029,1789    filter?: NodeFilterInterface1790  ): NodeIterator<RootNodeT, DocumentFragment | Element | Text>;1791  createNodeIterator<RootNodeT: DocumentFragment>(1792    root: RootNodeT,1793    whatToShow: 1152,1794    filter?: NodeFilterInterface1795  ): NodeIterator<RootNodeT, DocumentFragment | Comment>;1796  createNodeIterator<RootNodeT: DocumentFragment>(1797    root: RootNodeT,1798    whatToShow: 1153,1799    filter?: NodeFilterInterface1800  ): NodeIterator<RootNodeT, DocumentFragment | Element | Comment>;1801  createNodeIterator<RootNodeT: DocumentFragment>(1802    root: RootNodeT,1803    whatToShow: 1156,1804    filter?: NodeFilterInterface1805  ): NodeIterator<RootNodeT, DocumentFragment | Text | Comment>;1806  createNodeIterator<RootNodeT: DocumentFragment>(1807    root: RootNodeT,1808    whatToShow: 1157,1809    filter?: NodeFilterInterface1810  ): NodeIterator<RootNodeT, DocumentFragment | Element | Text | Comment>;1811  createTreeWalker<RootNodeT: DocumentFragment>(1812    root: RootNodeT,1813    whatToShow: 1024,1814    filter?: NodeFilterInterface,1815    entityReferenceExpansion?: boolean1816  ): TreeWalker<RootNodeT, DocumentFragment>;1817  createTreeWalker<RootNodeT: DocumentFragment>(1818    root: RootNodeT,1819    whatToShow: 1025,1820    filter?: NodeFilterInterface,1821    entityReferenceExpansion?: boolean1822  ): TreeWalker<RootNodeT, DocumentFragment | Element>;1823  createTreeWalker<RootNodeT: DocumentFragment>(1824    root: RootNodeT,1825    whatToShow: 1028,1826    filter?: NodeFilterInterface,1827    entityReferenceExpansion?: boolean1828  ): TreeWalker<RootNodeT, DocumentFragment | Text>;1829  createTreeWalker<RootNodeT: DocumentFragment>(1830    root: RootNodeT,1831    whatToShow: 1029,1832    filter?: NodeFilterInterface,1833    entityReferenceExpansion?: boolean1834  ): TreeWalker<RootNodeT, DocumentFragment | Element | Text>;1835  createTreeWalker<RootNodeT: DocumentFragment>(1836    root: RootNodeT,1837    whatToShow: 1152,1838    filter?: NodeFilterInterface,1839    entityReferenceExpansion?: boolean1840  ): TreeWalker<RootNodeT, DocumentFragment | Comment>;1841  createTreeWalker<RootNodeT: DocumentFragment>(1842    root: RootNodeT,1843    whatToShow: 1153,1844    filter?: NodeFilterInterface,1845    entityReferenceExpansion?: boolean1846  ): TreeWalker<RootNodeT, DocumentFragment | Element | Comment>;1847  createTreeWalker<RootNodeT: DocumentFragment>(1848    root: RootNodeT,1849    whatToShow: 1156,1850    filter?: NodeFilterInterface,1851    entityReferenceExpansion?: boolean1852  ): TreeWalker<RootNodeT, DocumentFragment | Text | Comment>;1853  createTreeWalker<RootNodeT: DocumentFragment>(1854    root: RootNodeT,1855    whatToShow: 1157,1856    filter?: NodeFilterInterface,1857    entityReferenceExpansion?: boolean1858  ): TreeWalker<RootNodeT, DocumentFragment | Element | Text | Comment>;18591860  // In the general case, RootNodeT may be any Node and whatToShow may be1861  // NodeFilter.SHOW_ALL or any combination of NodeFilter.SHOW_ELEMENT,1862  // NodeFilter.SHOW_TEXT and/or NodeFilter.SHOW_COMMENT1863  createNodeIterator<RootNodeT: Node>(1864    root: RootNodeT,1865    whatToShow: 1,1866    filter?: NodeFilterInterface1867  ): NodeIterator<RootNodeT, Element>;1868  createNodeIterator<RootNodeT: Node>(1869    root: RootNodeT,1870    whatToShow: 4,1871    filter?: NodeFilterInterface1872  ): NodeIterator<RootNodeT, Text>;1873  createNodeIterator<RootNodeT: Node>(1874    root: RootNodeT,1875    whatToShow: 5,1876    filter?: NodeFilterInterface1877  ): NodeIterator<RootNodeT, Element | Text>;1878  createNodeIterator<RootNodeT: Node>(1879    root: RootNodeT,1880    whatToShow: 128,1881    filter?: NodeFilterInterface1882  ): NodeIterator<RootNodeT, Comment>;1883  createNodeIterator<RootNodeT: Node>(1884    root: RootNodeT,1885    whatToShow: 129,1886    filter?: NodeFilterInterface1887  ): NodeIterator<RootNodeT, Element | Comment>;1888  createNodeIterator<RootNodeT: Node>(1889    root: RootNodeT,1890    whatToShow: 132,1891    filter?: NodeFilterInterface1892  ): NodeIterator<RootNodeT, Text | Comment>;1893  createNodeIterator<RootNodeT: Node>(1894    root: RootNodeT,1895    whatToShow: 133,1896    filter?: NodeFilterInterface1897  ): NodeIterator<RootNodeT, Text | Element | Comment>;1898  createTreeWalker<RootNodeT: Node>(1899    root: RootNodeT,1900    whatToShow: 1,1901    filter?: NodeFilterInterface,1902    entityReferenceExpansion?: boolean1903  ): TreeWalker<RootNodeT, Element>;1904  createTreeWalker<RootNodeT: Node>(1905    root: RootNodeT,1906    whatToShow: 4,1907    filter?: NodeFilterInterface,1908    entityReferenceExpansion?: boolean1909  ): TreeWalker<RootNodeT, Text>;1910  createTreeWalker<RootNodeT: Node>(1911    root: RootNodeT,1912    whatToShow: 5,1913    filter?: NodeFilterInterface,1914    entityReferenceExpansion?: boolean1915  ): TreeWalker<RootNodeT, Element | Text>;1916  createTreeWalker<RootNodeT: Node>(1917    root: RootNodeT,1918    whatToShow: 128,1919    filter?: NodeFilterInterface,1920    entityReferenceExpansion?: boolean1921  ): TreeWalker<RootNodeT, Comment>;1922  createTreeWalker<RootNodeT: Node>(1923    root: RootNodeT,1924    whatToShow: 129,1925    filter?: NodeFilterInterface,1926    entityReferenceExpansion?: boolean1927  ): TreeWalker<RootNodeT, Element | Comment>;1928  createTreeWalker<RootNodeT: Node>(1929    root: RootNodeT,1930    whatToShow: 132,1931    filter?: NodeFilterInterface,1932    entityReferenceExpansion?: boolean1933  ): TreeWalker<RootNodeT, Text | Comment>;1934  createTreeWalker<RootNodeT: Node>(1935    root: RootNodeT,1936    whatToShow: 133,1937    filter?: NodeFilterInterface,1938    entityReferenceExpansion?: boolean1939  ): TreeWalker<RootNodeT, Text | Element | Comment>;19401941  // Catch all for when we don't know the value of `whatToShow`1942  // And for when whatToShow is not provided, it is assumed to be SHOW_ALL1943  createNodeIterator<RootNodeT: Node>(1944    root: RootNodeT,1945    whatToShow?: number,1946    filter?: NodeFilterInterface1947  ): NodeIterator<RootNodeT, Node>;1948  createTreeWalker<RootNodeT: Node>(1949    root: RootNodeT,1950    whatToShow?: number,1951    filter?: NodeFilterInterface,1952    entityReferenceExpansion?: boolean1953  ): TreeWalker<RootNodeT, Node>;19541955  // From NonElementParentNode Mixin.1956  getElementById(elementId: string): HTMLElement | null;19571958  // From DocumentOrShadowRoot Mixin.1959  +styleSheets: StyleSheetList;1960  adoptedStyleSheets: Array<CSSStyleSheet>;1961}19621963declare class DocumentFragment extends Node {1964  // from ParentNode interface1965  childElementCount: number;1966  children: HTMLCollection<HTMLElement>;1967  firstElementChild: ?Element;1968  lastElementChild: ?Element;1969  append(...nodes: Array<string | Node>): void;1970  prepend(...nodes: Array<string | Node>): void;19711972  querySelector(selector: string): HTMLElement | null;1973  querySelectorAll(selector: string): NodeList<HTMLElement>;19741975  // From NonElementParentNode Mixin.1976  getElementById(elementId: string): HTMLElement | null;1977}19781979declare class Selection {1980  anchorNode: Node | null;1981  anchorOffset: number;1982  focusNode: Node | null;1983  focusOffset: number;1984  isCollapsed: boolean;1985  rangeCount: number;1986  type: string;1987  addRange(range: Range): void;1988  getRangeAt(index: number): Range;1989  removeRange(range: Range): void;1990  removeAllRanges(): void;1991  collapse(parentNode: Node | null, offset?: number): void;1992  collapseToStart(): void;1993  collapseToEnd(): void;1994  containsNode(aNode: Node, aPartlyContained?: boolean): boolean;1995  deleteFromDocument(): void;1996  extend(parentNode: Node, offset?: number): void;1997  empty(): void;1998  selectAllChildren(parentNode: Node): void;1999  setPosition(aNode: Node | null, offset?: number): void;2000  setBaseAndExtent(