EventTarget = ref EventTargetObj

DomEvent {...}{.pure.} = enum
  Abort = "abort", BeforeInput = "beforeinput", Blur = "blur", Click = "click",
  CompositionEnd = "compositionend", CompositionStart = "compositionstart",
  CompositionUpdate = "compositionupdate", DblClick = "dblclick",
  Error = "error", Focus = "focus", FocusIn = "focusin", FocusOut = "focusout",
  Input = "input", KeyDown = "keydown", KeyPress = "keypress", KeyUp = "keyup",
  Load = "load", MouseDown = "mousedown", MouseEnter = "mouseenter",
  MouseLeave = "mouseleave", MouseMove = "mousemove", MouseOut = "mouseout",
  MouseOver = "mouseover", MouseUp = "mouseup", Resize = "resize",
  Scroll = "scroll", Select = "select", Unload = "unload", Wheel = "wheel"

PerformanceMemory {...}{.importc.} = ref object
  jsHeapSizeLimit*: float
  totalJSHeapSize*: float
  usedJSHeapSize*: float

PerformanceTiming {...}{.importc.} = ref object
  connectStart*: float
  domComplete*: float
  domContentLoadedEventEnd*: float
  domContentLoadedEventStart*: float
  domInteractive*: float
  domLoading*: float
  domainLookupEnd*: float
  domainLookupStart*: float
  fetchStart*: float
  loadEventEnd*: float
  loadEventStart*: float
  navigationStart*: float
  redirectEnd*: float
  redirectStart*: float
  requestStart*: float
  responseEnd*: float
  responseStart*: float
  secureConnectionStart*: float
  unloadEventEnd*: float
  unloadEventStart*: float

Performance {...}{.importc.} = ref object
  memory*: PerformanceMemory
  timing*: PerformanceTiming

Range {...}{.importc.} = ref object
  collapsed*: bool
  commonAncestorContainer*: Node
  endContainer*: Node
  endOffset*: int
  startContainer*: Node
  startOffset*: int

Selection {...}{.importc.} = ref object
  anchorNode*: Node
  anchorOffset*: int
  focusNode*: Node
  focusOffset*: int
  isCollapsed*: bool
  rangeCount*: int
  `type`*: cstring

LocalStorage {...}{.importc.} = ref object

Window = ref WindowObj

Frame = ref FrameObj

ClassList = ref ClassListObj

NodeType = enum
  ElementNode = 1, AttributeNode, TextNode, CDATANode, EntityRefNode,
  EntityNode, ProcessingInstructionNode, CommentNode, DocumentNode,
  DocumentTypeNode, DocumentFragmentNode, NotationNode

Node = ref NodeObj

Document = ref DocumentObj

Element = ref ElementObj

ValidityState = ref ValidityStateObj

Blob = ref BlobObj

File = ref FileObj

TextAreaElement = ref TextAreaElementObj

InputElement = ref InputElementObj

LinkElement = ref LinkObj

EmbedElement = ref EmbedObj

AnchorElement = ref AnchorObj

OptionElement = ref OptionObj

FormElement = ref FormObj

ImageElement = ref ImageObj

Style = ref StyleObj

EventPhase = enum
  None = 0, CapturingPhase, AtTarget, BubblingPhase

Event = ref EventObj

UIEvent = ref UIEventObj

KeyboardEvent = ref KeyboardEventObj

KeyboardEventKey {...}{.pure.} = enum
  Alt, AltGraph, CapsLock, Control, Fn, FnLock, Hyper, Meta, NumLock,
  ScrollLock, Shift, Super, Symbol, SymbolLock, ArrowDown, ArrowLeft,
  ArrowRight, ArrowUp, End, Home, PageDown, PageUp, Backspace, Clear, Copy,
  CrSel, Cut, Delete, EraseEof, ExSel, Insert, Paste, Redo, Undo, Accept, Again,
  Attn, Cancel, ContextMenu, Escape, Execute, Find, Finish, Help, Pause, Play,
  Props, Select, ZoomIn, ZoomOut, BrigtnessDown, BrigtnessUp, Eject, LogOff,
  Power, PowerOff, PrintScreen, Hibernate, Standby, WakeUp, AllCandidates,
  Alphanumeric, CodeInput, Compose, Convert, Dead, FinalMode, GroupFirst,
  GroupLast, GroupNext, GroupPrevious, ModeChange, NextCandidate, NonConvert,
  PreviousCandidate, Process, SingleCandidate, HangulMode, HanjaMode, JunjaMode,
  Eisu, Hankaku, Hiragana, HiraganaKatakana, KanaMode, KanjiMode, Katakana,
  Romaji, Zenkaku, ZenkakuHanaku, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11,
  F12, F13, F14, F15, F16, F17, F18, F19, F20, Soft1, Soft2, Soft3, Soft4,
  AppSwitch, Call, Camera, CameraFocus, EndCall, GoBack, GoHome, HeadsetHook,
  LastNumberRedial, Notification, MannerMode, VoiceDial, ChannelDown, ChannelUp,
  MediaFastForward, MediaPause, MediaPlay, MediaPlayPause, MediaRecord,
  MediaRewind, MediaStop, MediaTrackNext, MediaTrackPrevious, AudioBalanceLeft,
  AudioBalanceRight, AudioBassDown, AudioBassBoostDown, AudioBassBoostToggle,
  AudioBassBoostUp, AudioBassUp, AudioFaderFront, AudioFaderRear,
  AudioSurroundModeNext, AudioTrebleDown, AudioTrebleUp, AudioVolumeDown,
  AUdioVolumeMute, AudioVolumeUp, MicrophoneToggle, MicrophoneVolumeDown,
  MicrophoneVolumeMute, MicrophoneVolumeUp, TV, TV3DMode, TVAntennaCable,
  TVAudioDescription, TVAudioDescriptionMixDown, TVAudioDescriptionMixUp,
  TVContentsMenu, TVDataService, TVInput, TVInputComponent1, TVInputComponent2,
  TVInputComposite1, TVInputComposite2, TVInputHDMI1, TVInputHDMI2,
  TVInputHDMI3, TVInputHDMI4, TVInputVGA1, TVMediaContext, TVNetwork,
  TVNumberEntry, TVPower, TVRadioService, TVSatellite, TVSatelliteBS,
  TVSatelliteCS, TVSatelliteToggle, TVTerrestrialAnalog, TVTerrestrialDigital,
  TVTimer, AVRInput, AVRPower, ColorF0Red, ColorF1Green, ColorF2Yellow,
  ColorF3Blue, ColorF4Grey, ColorF5Brown, ClosedCaptionToggle, Dimmer,
  DisplaySwap, DVR, Exit, FavoriteClear0, FavoriteClear1, FavoriteClear2,
  FavoriteClear3, FavoriteRecall0, FavoriteRecall1, FavoriteRecall2,
  FavoriteRecall3, FavoriteStore0, FavoriteStore1, FavoriteStore2,
  FavoriteStore3, Guide, GuideNextDay, GuidePreviousDay, Info, InstantReplay,
  Link, ListProgram, LiveContent, Lock, MediaApps, MediaAudioTrack, MediaLast,
  MediaSkipBackward, MediaSkipForward, MediaStepBackward, MediaStepForward,
  MediaTopMenu, NavigateIn, NavigateNext, NavigateOut, NavigatePrevious,
  NextFavoriteChannel, NextUserProfile, OnDemand, Pairing, PinPDown, PinPMove,
  PinPUp, PlaySpeedDown, PlaySpeedReset, PlaySpeedUp, RandomToggle,
  RcLowBattery, RecordSpeedNext, RfBypass, ScanChannelsToggle, ScreenModeNext,
  Settings, SplitScreenToggle, STBInput, STBPower, Subtitle, Teletext,
  VideoModeNext, Wink, ZoomToggle, SpeechCorrectionList, SpeechInputToggle,
  Close, New, Open, Print, Save, SpellCheck, MailForward, MailReply, MailSend,
  LaunchCalculator, LaunchCalendar, LaunchContacts, LaunchMail,
  LaunchMediaPlayer, LaunchMusicPlayer, LaunchMyComputer, LaunchPhone,
  LaunchScreenSaver, LaunchSpreadsheet, LaunchWebBrowser, LaunchWebCam,
  LaunchWordProcessor, LaunchApplication1, LaunchApplication2,
  LaunchApplication3, LaunchApplication4, LaunchApplication5,
  LaunchApplication6, LaunchApplication7, LaunchApplication8,
  LaunchApplication9, LaunchApplication10, LaunchApplication11,
  LaunchApplication12, LaunchApplication13, LaunchApplication14,
  LaunchApplication15, LaunchApplication16, BrowserBack, BrowserFavorites,
  BrowserForward, BrowserHome, BrowserRefresh, BrowserSearch, BrowserStop,
  Key11, Key12, Separator

MouseButtons = enum
  NoButton = 0, PrimaryButton = 1, SecondaryButton = 2, AuxilaryButton = 4,
  FourthButton = 8, FifthButton = 16

MouseEvent = ref MouseEventObj

DataTransferItemKind {...}{.pure.} = enum
  File = "file", String = "string"

DataTransferItem = ref DataTransferItemObj

DataTransfer = ref DataTransferObj

DataTransferDropEffect {...}{.pure.} = enum
  None = "none", Copy = "copy", Link = "link", Move = "move"

DataTransferEffectAllowed {...}{.pure.} = enum
  None = "none", Copy = "copy", CopyLink = "copyLink", CopyMove = "copyMove",
  Link = "link", LinkMove = "linkMove", Move = "move", All = "all",
  Uninitialized = "uninitialized"

DragEventTypes = enum
  Drag = "drag", DragEnd = "dragend", DragEnter = "dragenter",
  DragExit = "dragexit", DragLeave = "dragleave", DragOver = "dragover",
  DragStart = "dragstart", Drop = "drop"

DragEvent {...}{.importc.} = object of MouseEvent
  dataTransfer*: DataTransfer

ClipboardEvent {...}{.importc.} = object of Event
  clipboardData*: DataTransfer

TouchList {...}{.importc.} = ref object of RootObj
  length*: int

Touch = ref TouchObj

TouchEvent = ref TouchEventObj

Location = ref LocationObj

History = ref HistoryObj

Navigator = ref NavigatorObj

Plugin {...}{.importc.} = object of RootObj
  description*: cstring
  filename*: cstring
  name*: cstring

MimeType {...}{.importc.} = object of RootObj
  description*: cstring
  enabledPlugin*: ref Plugin
  suffixes*: seq[cstring]
  `type`*: cstring

LocationBar {...}{.importc.} = object of RootObj
  visible*: bool

MenuBar = LocationBar

PersonalBar = LocationBar

ScrollBars = LocationBar

ToolBar = LocationBar

StatusBar = LocationBar

TimeOut {...}{.importc.} = ref object of RootObj

Interval {...}{.importc.} = object of RootObj

AddEventListenerOptions = object
  capture*: bool
  once*: bool
  passive*: bool

FontFaceSetReady {...}{.importc.} = ref object
  then*: proc (cb: proc ())

FontFaceSet {...}{.importc.} = ref object
  ready*: FontFaceSetReady
  onloadingdone*: proc (event: Event)

DomParser = ref object
  

DomException = ref DOMExceptionObj

FileReader = ref FileReaderObj

FileReaderState = distinct range[0'u16 .. 2'u16]

RootNodeOptions = object of RootObj
  composed*: bool

DocumentOrShadowRoot {...}{.importc.} = object of RootObj
  activeElement*: Element

ShadowRoot = ref ShadowRootObj

ShadowRootInit = object of RootObj
  mode*: cstring
  delegatesFocus*: bool

HTMLSlotElement = ref HTMLSlotElementObj

SlotOptions = object of RootObj
  flatten*: bool

BoundingRect {...}{.importc.} = object
  top*, bottom*, left*, right*, x*, y*, width*, height*: float

window: Window

navigator: Navigator

screen: Screen

document: Document

DomApiVersion = 3

fileReaderEmpty = 0'u

fileReaderLoading = 1'u

fileReaderDone = 2'u

proc id(n: Node): cstring {...}{.importcpp: "#.id", nodecl.}

proc id=(n: Node; x: cstring) {...}{.importcpp: "#.id = #", nodecl.}

proc class(n: Node): cstring {...}{.importcpp: "#.className", nodecl.}

proc class=(n: Node; v: cstring) {...}{.importcpp: "#.className = #", nodecl.}

proc value(n: Node): cstring {...}{.importcpp: "#.value", nodecl.}

proc value=(n: Node; v: cstring) {...}{.importcpp: "#.value = #", nodecl.}

proc disabled=(n: Node; v: bool) {...}{.importcpp: "#.disabled = #", nodecl.}

proc len(x: Node): int {...}{.importcpp: "#.childNodes.length".}

proc `[]`(x: Node; idx: int): Element {...}{.importcpp: "#.childNodes[#]".}

proc getElementById(id: cstring): Element {...}{.importc: "document.getElementById",
    nodecl.}

proc appendChild(n, child: Node) {...}{.importcpp.}

proc removeChild(n, child: Node) {...}{.importcpp.}

proc remove(child: Node) {...}{.importcpp.}

proc replaceChild(n, newNode, oldNode: Node) {...}{.importcpp.}

proc insertBefore(n, newNode, before: Node) {...}{.importcpp.}

proc getElementById(d: Document; id: cstring): Element {...}{.importcpp.}

proc createElement(d: Document; identifier: cstring): Element {...}{.importcpp.}

proc createTextNode(d: Document; identifier: cstring): Node {...}{.importcpp.}

proc createComment(d: Document; data: cstring): Node {...}{.importcpp.}

proc setTimeout(action: proc (); ms: int): TimeOut {...}{.importc, nodecl.}

proc clearTimeout(t: TimeOut) {...}{.importc, nodecl.}

proc addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                      useCapture: bool = false) {...}{.importcpp.}

proc addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                      options: AddEventListenerOptions) {...}{.importcpp.}

proc dispatchEvent(et: EventTarget; ev: Event) {...}{.importcpp.}

proc removeEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event)) {...}{.
    importcpp.}

proc alert(w: Window; msg: cstring) {...}{.importcpp.}

proc back(w: Window) {...}{.importcpp.}

proc blur(w: Window) {...}{.importcpp.}

proc clearInterval(w: Window; interval: ref Interval) {...}{.importcpp.}

proc clearTimeout(w: Window; timeout: ref TimeOut) {...}{.importcpp.}

proc close(w: Window) {...}{.importcpp.}

proc confirm(w: Window; msg: cstring): bool {...}{.importcpp.}

proc disableExternalCapture(w: Window) {...}{.importcpp.}

proc enableExternalCapture(w: Window) {...}{.importcpp.}

proc find(w: Window; text: cstring; caseSensitive = false; backwards = false) {...}{.
    importcpp.}

proc focus(w: Window) {...}{.importcpp.}

proc forward(w: Window) {...}{.importcpp.}

proc getComputedStyle(w: Window; e: Node; pe: Node = nil): Style {...}{.importcpp.}

proc handleEvent(w: Window; e: Event) {...}{.importcpp.}

proc home(w: Window) {...}{.importcpp.}

proc moveBy(w: Window; x, y: int) {...}{.importcpp.}

proc moveTo(w: Window; x, y: int) {...}{.importcpp.}

proc open(w: Window; uri, windowname: cstring; properties: cstring = nil): Window {...}{.
    importcpp.}

proc print(w: Window) {...}{.importcpp.}

proc prompt(w: Window; text, default: cstring): cstring {...}{.importcpp.}

proc resizeBy(w: Window; x, y: int) {...}{.importcpp.}

proc resizeTo(w: Window; x, y: int) {...}{.importcpp.}

proc routeEvent(w: Window; event: Event) {...}{.importcpp.}

proc scrollBy(w: Window; x, y: int) {...}{.importcpp.}

proc scrollTo(w: Window; x, y: int) {...}{.importcpp.}

proc setInterval(w: Window; code: cstring; pause: int): ref Interval {...}{.importcpp.}

proc setInterval(w: Window; function: proc (); pause: int): ref Interval {...}{.
    importcpp.}

proc setTimeout(w: Window; code: cstring; pause: int): ref TimeOut {...}{.importcpp.}

proc setTimeout(w: Window; function: proc (); pause: int): ref Interval {...}{.
    importcpp.}

proc stop(w: Window) {...}{.importcpp.}

proc requestAnimationFrame(w: Window; function: proc (time: float)): int {...}{.
    importcpp.}

proc cancelAnimationFrame(w: Window; id: int) {...}{.importcpp.}

proc appendData(n: Node; data: cstring) {...}{.importcpp.}

proc cloneNode(n: Node; copyContent: bool): Node {...}{.importcpp.}

proc deleteData(n: Node; start, len: int) {...}{.importcpp.}

proc focus(e: Node) {...}{.importcpp.}

proc getAttribute(n: Node; attr: cstring): cstring {...}{.importcpp.}

proc getAttributeNode(n: Node; attr: cstring): Node {...}{.importcpp.}

proc hasAttribute(n: Node; attr: cstring): bool {...}{.importcpp.}

proc hasChildNodes(n: Node): bool {...}{.importcpp.}

proc normalize(n: Node) {...}{.importcpp.}

proc insertData(n: Node; position: int; data: cstring) {...}{.importcpp.}

proc removeAttribute(n: Node; attr: cstring) {...}{.importcpp.}

proc removeAttributeNode(n, attr: Node) {...}{.importcpp.}

proc replaceData(n: Node; start, len: int; text: cstring) {...}{.importcpp.}

proc scrollIntoView(n: Node) {...}{.importcpp.}

proc setAttribute(n: Node; name, value: cstring) {...}{.importcpp.}

proc setAttributeNode(n: Node; attr: Node) {...}{.importcpp.}

proc querySelector(n: Node; selectors: cstring): Element {...}{.importcpp.}

proc querySelectorAll(n: Node; selectors: cstring): seq[Element] {...}{.importcpp.}

proc compareDocumentPosition(n: Node; otherNode: Node): int {...}{.importcpp.}

proc lookupPrefix(n: Node): cstring {...}{.importcpp.}

proc lookupNamespaceURI(n: Node): cstring {...}{.importcpp.}

proc isDefaultNamespace(n: Node): bool {...}{.importcpp.}

proc contains(n: Node): bool {...}{.importcpp.}

proc isEqualNode(n: Node): bool {...}{.importcpp.}

proc isSameNode(n: Node): bool {...}{.importcpp.}

proc getRootNode(n: Node; options: RootNodeOptions): Node {...}{.importcpp.}

proc getSelection(n: DocumentOrShadowRoot): Selection {...}{.importcpp.}

proc elementFromPoint(n: DocumentOrShadowRoot; x, y: float): Element {...}{.importcpp.}

proc attachShadow(n: Element): ShadowRoot {...}{.importcpp.}

proc assignedNodes(n: HTMLSlotElement; options: SlotOptions): seq[Node] {...}{.
    importcpp.}

proc assignedElements(n: HTMLSlotElement; options: SlotOptions): seq[Element] {...}{.
    importcpp.}

proc createAttribute(d: Document; identifier: cstring): Node {...}{.importcpp.}

proc getElementsByName(d: Document; name: cstring): seq[Element] {...}{.importcpp.}

proc getElementsByTagName(d: Document; name: cstring): seq[Element] {...}{.importcpp.}

proc getElementsByClassName(d: Document; name: cstring): seq[Element] {...}{.
    importcpp.}

proc insertNode(range: Range; node: Node) {...}{.importcpp.}

proc getSelection(d: Document): Selection {...}{.importcpp.}

proc handleEvent(d: Document; event: Event) {...}{.importcpp.}

proc open(d: Document) {...}{.importcpp.}

proc routeEvent(d: Document; event: Event) {...}{.importcpp.}

proc write(d: Document; text: cstring) {...}{.importcpp.}

proc writeln(d: Document; text: cstring) {...}{.importcpp.}

proc querySelector(d: Document; selectors: cstring): Element {...}{.importcpp.}

proc querySelectorAll(d: Document; selectors: cstring): seq[Element] {...}{.importcpp.}

proc blur(e: Element) {...}{.importcpp.}

proc click(e: Element) {...}{.importcpp.}

proc focus(e: Element) {...}{.importcpp.}

proc handleEvent(e: Element; event: Event) {...}{.importcpp.}

proc select(e: Element) {...}{.importcpp.}

proc getElementsByTagName(e: Element; name: cstring): seq[Element] {...}{.importcpp.}

proc getElementsByClassName(e: Element; name: cstring): seq[Element] {...}{.importcpp.}

proc reset(f: FormElement) {...}{.importcpp.}

proc submit(f: FormElement) {...}{.importcpp.}

proc checkValidity(e: FormElement): bool {...}{.importcpp.}

proc reportValidity(e: FormElement): bool {...}{.importcpp.}

proc play(e: EmbedElement) {...}{.importcpp.}

proc stop(e: EmbedElement) {...}{.importcpp.}

proc reload(loc: Location) {...}{.importcpp.}

proc replace(loc: Location; s: cstring) {...}{.importcpp.}

proc back(h: History) {...}{.importcpp.}

proc forward(h: History) {...}{.importcpp.}

proc go(h: History; pagesToJump: int) {...}{.importcpp.}

proc pushState[T](h: History; stateObject: T; title, url: cstring) {...}{.importcpp.}

proc javaEnabled(h: Navigator): bool {...}{.importcpp.}

proc canShare(self: Navigator; data: cstring): bool {...}{.importcpp.}

proc sendBeacon(self: Navigator; url, data: cstring): bool {...}{.importcpp.}

proc vibrate(self: Navigator; pattern: cint): bool {...}{.importcpp.}

proc vibrate(self: Navigator; pattern: openArray[cint]): bool {...}{.importcpp.}

proc registerProtocolHandler(self: Navigator; scheme, url, title: cstring) {...}{.
    importcpp.}

proc add(c: ClassList; class: cstring) {...}{.importcpp.}

proc remove(c: ClassList; class: cstring) {...}{.importcpp.}

proc contains(c: ClassList; class: cstring): bool {...}{.importcpp.}

proc toggle(c: ClassList; class: cstring) {...}{.importcpp.}

proc getPropertyValue(s: Style; property: cstring): cstring {...}{.importcpp.}

proc removeProperty(s: Style; property: cstring) {...}{.importcpp.}

proc setProperty(s: Style; property, value: cstring; priority = "") {...}{.importcpp.}

proc getPropertyPriority(s: Style; property: cstring): cstring {...}{.importcpp.}

proc preventDefault(ev: Event) {...}{.importcpp.}

proc stopImmediatePropagation(ev: Event) {...}{.importcpp.}

proc stopPropagation(ev: Event) {...}{.importcpp.}

proc getModifierState(ev: KeyboardEvent; keyArg: cstring): bool {...}{.importcpp.}

proc getModifierState(ev: MouseEvent; keyArg: cstring): bool {...}{.importcpp.}

proc identifiedTouch(list: TouchList): Touch {...}{.importcpp.}

proc item(list: TouchList; i: int): Touch {...}{.importcpp.}

proc clearData(dt: DataTransfer; format: cstring) {...}{.importcpp.}

proc getData(dt: DataTransfer; format: cstring): cstring {...}{.importcpp.}

proc setData(dt: DataTransfer; format: cstring; data: cstring) {...}{.importcpp.}

proc setDragImage(dt: DataTransfer; img: Element; xOffset: int64; yOffset: int64) {...}{.
    importcpp.}

proc getAsFile(dti: DataTransferItem): File {...}{.importcpp.}

proc setSelectionRange(e: InputElement; selectionStart: int; selectionEnd: int;
                       selectionDirection: cstring = "none") {...}{.importcpp.}

proc setRangeText(e: InputElement; replacement: cstring; startindex: int = 0;
                  endindex: int = 0; selectionMode: cstring = "preserve") {...}{.
    importcpp.}