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] {...}{.devel/lib/js/dom.nim#L1488" class="link-seesrc" target="_blank" >Edit


Window; id: int) {cstring): seq: seqSource
Edit


selectors: cstring)
selectors: cstringEdit



proc getSelection-seesrc" target="_blank" >Edit



proc}{.importcpp.}



  Source
Source
Edit



proc Source
Edit



proc "system.html FileReader; b: Blob)">readAsDataURL,FileReader,Blob

  
  
add
      
add,ClassList,cstringint) {...
proc querySelector(d{.
    importcpp(dspan>{cstring<
Edit.l/lib/js/dom.nim#L1521" class="link-seesrc" target="_blank" >Edit<)lass="Identifier">seq[Element] {...}
DataTransferItem = ref DataTransferItemObj


see DataTraan>, Copy = "copy", CopyLink = 
{.importcpp.}



  .}




  Source
Source
...}
DataTransferItem = ref (x, y: People
{.importcpp.}



 &nbs
proc containsEdit



proc moveByEdit


Event}{.Source
...}/a> = ref (xransferItem = ref (x, y: Peo>x, y: n: Node; (d: Document; textEdit



proc .}




  .}




 0 Source
Source
...}

  
.}




  d: Document; identifier: Source
Edit


move id="getSelect ntifier">Dataelect ntifier">Dataelect .}




 0 n: Node; (dclick
      
click,Element

  
  
resizeBy
      
ev: {...}{.int) {...}{.) {...}{.: MailReply, MailSend,
  LaunchCalculator, LaunchCalendar,.}




  {...
proc querySelector ==




  Source
Edit
MailReply, MailSend,
  LaunchCalculator}int) {...}{.ringLit">"copy", 
ArrowUp, End, Home, PageDown, Edit

proc back(w: toString