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

AnchorElement = ref AnchorObj

Blob = ref BlobObj

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

ClassList = ref ClassListObj

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

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"

DataTransferItem = ref DataTransferItemObj

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

Document = ref DocumentObj

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

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", Storage = "storage", Unload = "unload",
  Wheel = "wheel"

DomException = ref DOMExceptionObj

DomParser = ref object
  

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

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

Element = ref ElementObj

EmbedElement = ref EmbedObj

Event = ref EventObj

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

EventTarget = ref EventTargetObj

File = ref FileObj

FileReader = ref FileReaderObj

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

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

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

FormElement = ref FormObj

Frame = ref FrameObj

History = ref HistoryObj

HTMLSlotElement = ref HTMLSlotElementObj

ImageElement = ref ImageObj

InputElement = ref InputElementObj

Interval {.importc.} = ref object of RootObj

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

LinkElement = ref LinkObj

Location = ref LocationObj

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

MenuBar = LocationBar

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

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

MouseEvent = ref MouseEventObj

Navigator = ref NavigatorObj

Node = ref NodeObj

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

OptionElement = ref OptionObj

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

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

PersonalBar = LocationBar

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

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

RootNodeOptions = object of RootObj
  composed*: bool

ScrollBars = LocationBar

ScrollIntoViewOptions = object
  behavior*: cstring
  `block`*: cstring
  inline*: cstring

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

ShadowRoot = ref ShadowRootObj

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

SlotOptions = object of RootObj
  flatten*: bool

StatusBar = LocationBar

Storage {.importc.} = ref object

StorageEvent = ref StorageEventObj

Style = ref StyleObj

TextAreaElement = ref TextAreaElementObj

TimeOut {.importc.} = ref object of RootObj

ToolBar = LocationBar

Touch = ref TouchObj

TouchEvent = ref TouchEventObj

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

UIEvent = ref UIEventObj

ValidityState = ref ValidityStateObj

Window = ref WindowObj

document: Document

navigator: Navigator

screen: Screen

window: Window

DomApiVersion = 3

fileReaderDone = 2'u

fileReaderEmpty = 0'u

fileReaderLoading = 1'u

proc `$`(s: Selection): string {.importcpp, ...raises: [], tags: [].}

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

proc abort(f: FileReader) {.importcpp: "#.abort()", ...raises: [], tags: [].}

proc add(c: ClassList; class: cstring) {.importcpp, ...raises: [], tags: [].}

proc addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                      options: AddEventListenerOptions) {.importcpp, ...raises: [],
    tags: [].}

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

proc alert(w: Window; msg: cstring) {.importcpp, ...raises: [], tags: [].}

proc appendChild(n, child: Node) {.importcpp, ...raises: [], tags: [].}

proc appendData(n: Node; data: cstring) {.importcpp, ...raises: [], tags: [].}

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

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

proc attachShadow(n: Element): ShadowRoot {.importcpp, ...raises: [], tags: [].}

proc back(h: History) {.importcpp, ...raises: [], tags: [].}

proc back(w: Window) {.importcpp, ...raises: [], tags: [].}

proc blur(e: Element) {.importcpp, ...raises: [], tags: [].}

proc blur(w: Window) {.importcpp, ...raises: [], tags: [].}

proc cancelAnimationFrame(w: Window; id: int) {.importcpp, ...raises: [], tags: [].}

proc canShare(self: Navigator; data: cstring): bool {.importcpp, ...raises: [],
    tags: [].}

proc checked(n: Node): bool {.importcpp: "#.checked", nodecl, ...raises: [],
                              tags: [].}

proc checked=(n: Node; v: bool) {.importcpp: "#.checked = #", nodecl,
                                  ...raises: [], tags: [].}

proc checkValidity(e: FormElement): bool {.importcpp, ...raises: [], tags: [].}

proc checkValidity(e: InputElement): bool {.importcpp, ...raises: [], tags: [].}

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

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

proc clear(s: Storage) {.importcpp, ...raises: [], tags: [].}

proc clearData(dt: DataTransfer; format: cstring) {.importcpp, ...raises: [],
    tags: [].}

proc clearInterval(i: Interval) {.importc, nodecl, ...raises: [], tags: [].}

proc clearInterval(w: Window; interval: Interval) {.importcpp, ...raises: [],
    tags: [].}

proc clearTimeout(t: TimeOut) {.importc, nodecl, ...raises: [], tags: [].}

proc clearTimeout(w: Window; timeout: TimeOut) {.importcpp, ...raises: [], tags: [].}

proc click(e: Element) {.importcpp, ...raises: [], tags: [].}

proc clientHeight(): int {.importcpp: "(window.innerHeight || document.documentElement.clientHeight)@",
                           nodecl, ...raises: [], tags: [].}

proc clientWidth(): int {.importcpp: "(window.innerWidth || document.documentElement.clientWidth)@",
                          nodecl, ...raises: [], tags: [].}

proc cloneNode(n: Node; copyContent: bool): Node {.importcpp, ...raises: [],
    tags: [].}

proc close(w: Window) {.importcpp, ...raises: [], tags: [].}

proc compareDocumentPosition(n: Node; otherNode: Node): int {.importcpp,
    ...raises: [], tags: [].}

proc confirm(w: Window; msg: cstring): bool {.importcpp, ...raises: [], tags: [].}

proc contains(c: ClassList; class: cstring): bool {.importcpp, ...raises: [],
    tags: [].}

proc contains(n: Node): bool {.importcpp, ...raises: [], tags: [].}

proc createAttribute(d: Document; identifier: cstring): Node {.importcpp,
    ...raises: [], tags: [].}

proc createComment(d: Document; data: cstring): Node {.importcpp, ...raises: [],
    tags: [].}

proc createElement(d: Document; identifier: cstring): Element {.importcpp,
    ...raises: [], tags: [].}

proc createElementNS(d: Document; namespaceURI, qualifiedIdentifier: cstring): Element {.
    importcpp, ...raises: [], tags: [].}

proc createTextNode(d: Document; identifier: cstring): Node {.importcpp,
    ...raises: [], tags: [].}

proc decodeURI(uri: cstring): cstring {.importc, nodecl, ...raises: [], tags: [].}

proc decodeURIComponent(uri: cstring): cstring {.importc, nodecl, ...raises: [],
    tags: [].}

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

proc deleteFromDocument(s: Selection) {.importcpp, ...raises: [], tags: [].}

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

proc disableExternalCapture(w: Window) {.importcpp, ...raises: [], tags: [].}

proc dispatchEvent(et: EventTarget; ev: Event) {.importcpp, ...raises: [], tags: [].}

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

proc elementsFromPoint(n: DocumentOrShadowRoot; x, y: float): seq[Element] {.
    importcpp, ...raises: [], tags: [].}

proc enableExternalCapture(w: Window) {.importcpp, ...raises: [], tags: [].}

proc encodeURI(uri: cstring): cstring {.importc, nodecl, ...raises: [], tags: [].}

proc encodeURIComponent(uri: cstring): cstring {.importc, nodecl, ...raises: [],
    tags: [].}

proc error(f: FileReader): DomException {.importcpp: "#.error", nodecl,
    ...raises: [], tags: [].}

proc escape(uri: cstring): cstring {.importc, nodecl, ...raises: [], tags: [].}

proc find(w: Window; text: cstring; caseSensitive = false; backwards = false) {.
    importcpp, ...raises: [], tags: [].}

proc focus(e: Element) {.importcpp, ...raises: [], tags: [].}

proc focus(e: Node) {.importcpp, ...raises: [], tags: [].}

proc focus(w: Window) {.importcpp, ...raises: [], tags: [].}

proc forward(h: History) {.importcpp, ...raises: [], tags: [].}

proc forward(w: Window) {.importcpp, ...raises: [], tags: [].}

proc getAsFile(dti: DataTransferItem): File {.importcpp, ...raises: [], tags: [].}

proc getAttribute(n: Node; attr: cstring): cstring {.importcpp, ...raises: [],
    tags: [].}

proc getAttributeNode(n: Node; attr: cstring): Node {.importcpp, ...raises: [],
    tags: [].}

proc getBoundingClientRect(e: Node): BoundingRect {.
    importcpp: "getBoundingClientRect", nodecl, ...raises: [], tags: [].}

proc getComputedStyle(w: Window; e: Node; pe: Node = nil): Style {.importcpp,
    ...raises: [], tags: [].}

proc getData(dt: DataTransfer; format: cstring): cstring {.importcpp,
    ...raises: [], tags: [].}

proc getElementById(d: Document; id: cstring): Element {.importcpp, ...raises: [],
    tags: [].}

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

proc getElementsByClass(n: Node; name: cstring): seq[Node] {.
    importcpp: "#.getElementsByClassName(#)", nodecl, ...raises: [], tags: [].}

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

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

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

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

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

proc getItem(s: Storage; key: cstring): cstring {.importcpp, ...raises: [],
    tags: [].}

proc getModifierState(ev: KeyboardEvent; keyArg: cstring): bool {.importcpp,
    ...raises: [], tags: [].}

proc getModifierState(ev: MouseEvent; keyArg: cstring): bool {.importcpp,
    ...raises: [], tags: [].}

proc getPropertyPriority(s: Style; property: cstring): cstring {.importcpp,
    ...raises: [], tags: [].}

proc getPropertyValue(s: Style; property: cstring): cstring {.importcpp,
    ...raises: [], tags: [].}

proc getRangeAt(s: Selection; index: int): Range {.importcpp, ...raises: [],
    tags: [].}

proc getRootNode(n: Node; options: RootNodeOptions): Node {.importcpp,
    ...raises: [], tags: [].}

proc getSelection(d: Document): Selection {.importcpp, ...raises: [], tags: [].}

proc getSelection(n: DocumentOrShadowRoot): Selection {.importcpp, ...raises: [],
    tags: [].}

proc go(h: History; pagesToJump: int) {.importcpp, ...raises: [], tags: [].}

proc handleEvent(d: Document; event: Event) {.importcpp, ...raises: [], tags: [].}

proc handleEvent(e: Element; event: Event) {.importcpp, ...raises: [], tags: [].}

proc handleEvent(w: Window; e: Event) {.importcpp, ...raises: [], tags: [].}

proc hasAttribute(n: Node; attr: cstring): bool {.importcpp, ...raises: [],
    tags: [].}

proc hasChildNodes(n: Node): bool {.importcpp, ...raises: [], tags: [].}

proc hasItem(s: Storage; key: cstring): bool {.importcpp, ...raises: [], tags: [].}

proc home(w: Window) {.importcpp, ...raises: [], tags: [].}

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

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

proc identifiedTouch(list: TouchList): Touch {.importcpp, ...raises: [], tags: [].}

proc insertBefore(n, newNode, before: Node) {.importcpp, ...raises: [], tags: [].}

proc insertData(n: Node; position: int; data: cstring) {.importcpp, ...raises: [],
    tags: [].}

proc insertNode(range: Range; node: Node) {.importcpp, ...raises: [], tags: [].}

proc inViewport(el: Node): bool {....raises: [], tags: [].}

proc isDefaultNamespace(n: Node): bool {.importcpp, ...raises: [], tags: [].}

proc isEqualNode(n: Node): bool {.importcpp, ...raises: [], tags: [].}

proc isFinite(x: BiggestFloat): bool {.importc, nodecl, ...raises: [], tags: [].}

proc isNaN(x: BiggestFloat): bool {.importc, nodecl, ...raises: [], tags: [].}

proc isSameNode(n: Node): bool {.importcpp, ...raises: [], tags: [].}

proc item(list: TouchList; i: int): Touch {.importcpp, ...raises: [], tags: [].}

proc javaEnabled(h: Navigator): bool {.importcpp, ...raises: [], tags: [].}

proc len(x: Node): int {.importcpp: "#.childNodes.length", ...raises: [], tags: [].}

proc lookupNamespaceURI(n: Node): cstring {.importcpp, ...raises: [], tags: [].}

proc lookupPrefix(n: Node): cstring {.importcpp, ...raises: [], tags: [].}

proc message(ex: DomException): cstring {.importcpp: "#.message", nodecl,
    ...raises: [], tags: [].}

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

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

proc name(ex: DomException): cstring {.importcpp: "#.name", nodecl, ...raises: [],
                                       tags: [].}

proc newDomException(): DomException {.importcpp: "new DomException()",
                                       constructor, ...raises: [], tags: [].}

func newDomParser(): DomParser {.importcpp: "new DOMParser()", ...raises: [],
                                 tags: [].}

proc newEvent(name: cstring): Event {.importcpp: "new Event(@)", constructor,
                                      ...raises: [], tags: [].}

proc newFileReader(): FileReader {.importcpp: "new FileReader()", constructor,
                                   ...raises: [], tags: [].}

proc normalize(n: Node) {.importcpp, ...raises: [], tags: [].}

proc now(p: Performance): float {.importcpp, ...raises: [], tags: [].}

proc offsetHeight(e: Node): int {.importcpp: "#.offsetHeight", nodecl,
                                  ...raises: [], tags: [].}

proc offsetLeft(e: Node): int {.importcpp: "#.offsetLeft", nodecl, ...raises: [],
                                tags: [].}

proc offsetTop(e: Node): int {.importcpp: "#.offsetTop", nodecl, ...raises: [],
                               tags: [].}

proc offsetWidth(e: Node): int {.importcpp: "#.offsetWidth", nodecl, ...raises: [],
                                 tags: [].}

proc open(d: Document) {.importcpp, ...raises: [], tags: [].}

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

func parseFromString(this: DomParser; str: cstring; mimeType: cstring): Document {.
    importcpp, ...raises: [], tags: [].}

proc play(e: EmbedElement) {.importcpp, ...raises: [], tags: [].}

proc preventDefault(ev: Event) {.importcpp, ...raises: [], tags: [].}

proc print(w: Window) {.importcpp, ...raises: [], tags: [].}

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

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

proc querySelector(d: Document; selectors: cstring): Element {.importcpp,
    ...raises: [], tags: [].}

proc querySelector(n: Node; selectors: cstring): Element {.importcpp,
    ...raises: [], tags: [].}

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

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

proc readAsBinaryString(f: FileReader; b: Blob) {.
    importcpp: "#.readAsBinaryString(#)", ...raises: [], tags: [].}

proc readAsDataURL(f: FileReader; b: Blob) {.importcpp: "#.readAsDataURL(#)",
    ...raises: [], tags: [].}

proc readAsText(f: FileReader; b: Blob | File; encoding = cstring"UTF-8") {.
    importcpp: "#.readAsText(#, #)", ...raises: [], tags: [].}