pas2js/rtl/web.pas

{
    This file is part of the Pas2JS run time library.
    Copyright (c) 2017 by Mattias Gaertner

    See the file COPYING.FPC, included in this distribution,
    for details about the copyright.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 **********************************************************************}

{$mode objfpc}
{$modeswitch externalclass}

unit Web;

interface

uses Types, JS;

Type
  // Forward definitions
  TJSWindow = class;
  TJSDOMTokenList = class;
  TJSXPathResult = CLass;
  TJSNodeList = class;
  TJSDocument = class;
  TJSElement = class;
  TJSCSSStyleSheet = Class;
  TJSNodeFilter = Class;
  TJSIDBObjectStore = Class;
  TIDBDatabase = class;
  TJSIDBRequest = class;
  TJSIDBRequest = class;
  TJSEventTarget = class;
  TJSMouseEvent = Class;
  TJSWheelEvent = Class;
  TJSKeyBoardEvent = class;
  TJSPointerEvent = Class;
  TJSUIEvent = class;
  TJSTouchEvent = Class;

  TJSAttr = class external name 'Attr'
  Private
    fLocalName : String; external name 'localName';
    fNameSpaceURI : String external name 'namespaceURI';
    fPrefix : string; external name 'prefix';
    fName : string; external name 'name';
  public
    value : JSValue;
    property localName : String Read fLocalName;
    property namespaceURI : string Read fNameSpaceURI;
    property prefix : string read fPrefix;
    property name : string Read fName;
  end;


  { TEventListenerEvent }

  TEventListenerEvent = class external name 'EventListener_Event'
  private
    FTarget: TJSEventTarget; external name 'target';
  public
    Property target: TJSEventTarget Read FTarget;
  end;

  TJSEventHandler = reference to function(Event: TEventListenerEvent): boolean;

  TJSEventTarget = class external name 'EventTarget'
  public
    procedure addEventListener(aname : string; aListener : TJSEventHandler);
    procedure addEventListener(aname : string; aListener : JSValue);
    function dispatchEvent(event : JSValue) : Boolean;
    procedure removeEventListener(aname : string; aListener : TJSEventHandler);
    procedure removeEventListener(aname : string; aListener : JSValue);
  end;

  TJSNode = class external name 'Node' (TJSEventTarget)
  Private
    FBaseURI : String; external name 'baseURI';
    FChildNodes: TJSNodeList; external name 'childNodes';
    FFirstChild : TJSNode; external name 'firstChild';
    FNextSibling : TJSNode; external name 'nextSibling';
    FNodeName : String; external name 'nodeName';
    FNodeType : NativeInt; external name 'nodeType';
    FOwnerDocument : TJSDocument; external name 'ownerDocument';
    FParentElement : TJSElement; external name 'parentElement';
    FParentNode : TJSNode; external name 'parentNode';
    FPreviousSibling : TJSNode; external name 'previousSibling';
  Public 
    Const
      ELEMENT_NODE 	=1;
      TEXT_NODE 	=3;
      PROCESSING_INSTRUCTION_NODE = 	7;
      COMMENT_NODE 	=8;
      DOCUMENT_NODE 	=9;
      DOCUMENT_TYPE_NODE 	= 10;
      DOCUMENT_FRAGMENT_NODE  = 11;

      DOCUMENT_POSITION_DISCONNECTED 	= 1;
      DOCUMENT_POSITION_PRECEDING 	= 2;
      DOCUMENT_POSITION_FOLLOWING 	= 4;
      DOCUMENT_POSITION_CONTAINS 	= 8;
      DOCUMENT_POSITION_CONTAINED_BY 	= 16;
      DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32;
  Public  
    nodeValue: string;
    innerText : string;
    textContent : string;
    function appendChild(aChild : TJSNode) : TJSNode;
    function cloneNode(deep:  boolean): TJSNode;
    function compareDocumentPosition(aNode : TJSNode) : NativeInt;
    function contains(aNode : TJSNode) : boolean;
    function hasChildNodes : boolean;
    function insertBefore(newNode, referenceNode : TJSNode) : TJSNode;
    function isDefaultNameSpace(aNameSpaceURI : String) : Boolean;
    function isEqualNode(aNode : TJSNode) : boolean;
    function isSameNode(aNode : TJSNode) : boolean;
    function lookupNamespaceURI(aPrefix : string) : string;
    function lookupPrefix(aPrefix : string) : string;
    procedure normalize;
    function removeChild(aChild: TJSNode) : TJSNode;
    function replaceChild(aNewChild, aOldChild : TJSNode) : TJSNode;
    property baseURI : string read FBaseURI;
    property childNodes : TJSNodeList read FChildNodes;
    property firstChild : TJSNode Read FFirstChild;
    property nextSibling : TJSNode Read FNextSibling;
    property nodeName : String Read FNodeName;
    property nodeType : NativeInt Read FNodeType;
    property ownerDocument : TJSDocument read FOwnerDocument;    
    property parentElement : TJSElement read FParentElement;
    property parentNode : TJSNode read FParentNode;
    property previousSibling : TJSNode Read FPreviousSibling;
  end;

  TJSNodeListCallBack = procedure (currentValue : TJSNode; currentIndex: NativeInt; list : TJSNodeList);
  TJSNodeListEvent = procedure (currentValue : TJSNode; currentIndex: NativeInt; list : TJSNodeList) of object;
  
  TJSNodeList = class external name 'NodeList'
  Private
    FLength : NativeInt; external name 'length';
  Public
    procedure forEach(const aCallBack : TJSNodeListCallBack);
    procedure forEach(const aCallBack : TJSNodeListEvent);
    function item(aIndex : NativeInt) : TJSNode;
    Property length : NativeInt Read FLength;
    Property Nodes [aIndex : NativeInt] : TJSNode Read item; default;
  end;
  
  TJSNamedNodeMap = class external name 'NamedNodeMap'
  Public
    function getNamedItem(aName : string) : TJSAttr;
    Property Attrs[aIndex : String] : TJSattr Read getNamedItem; default;
  end;
  
  TJSHTMLCollection = class external name 'HTMLCollection'
  Private
    FLength : NativeInt; external name 'length';
  public
    Function item(aIndex : Integer) : TJSNode;
    Function namedItem(aName : string) : TJSNode;
    property Items[aIndex : Integer] : TJSNode Read item; default;
    property NamedItems[aName : String] : TJSNode Read namedItem; 
    Property length : NativeInt Read FLength;
  end;  
  
  TJSDOMString = String;

  TDOMTokenlistCallBack = Procedure (Current : JSValue; currentIndex : NativeInt; list : TJSDOMTokenList);
  
  // Interface
  TJSDOMTokenList = class external name 'DOMTokenList'
  Private
    FLength : NativeInt; external name 'length';
  public
    Procedure add(aToken : TJSDOMString); varargs;
    Procedure remove(aToken : TJSDOMString); varargs;
    function item(aIndex : NativeInt) : String;
    function contains(aToken : TJSDOMString) : Boolean;
    Procedure replace(aOldToken, ANewToken : TJSDOMString);
    function supports(aToken : TJSDOMString) : Boolean;
    function toggle(aToken : TJSDOMString) : Boolean;
    // entries,keys, values
    procedure forEach(const callback: TDOMTokenlistCallBack);
    property length : NativeInt read FLength;
  end;

  TJSDOMRect = class external name 'DOMRect'
  public
    left,top,right,bottom,x,y,width,height : double;
    {$IFDEF FIREFOX}
    constructor New;
    {$ENDIF}
  end;
  TJSClientRect = record
    left,top,right,bottom : double;
    {$IFDEF FIREFOX}
    width, height: double;
    {$ENDIF}
  end;
  
  TJSClientRectArray = array of TJSClientRect;
  
  TJSElement = class external name 'Element' (TJSNode)
  Private
    FAttributes : TJSNamedNodeMap; external name 'attributes';
    FChildElementCount : NativeInt; external name 'childElementCount';
    FChildren : TJSHTMLCollection; external name 'children';
    FClassList : TJSDOMTokenList; external name 'classList';
    FCLientHeight : NativeInt; external name 'clientHeight';
    FCLientLeft : NativeInt; external name 'clientLeft';
    FCLientTop : NativeInt; external name 'clientTop';
    FCLientWidth : NativeInt; external name 'clientWidth';
    FFirstElementChild : TJSElement; external name 'firstElementChild';
    FLastElementChild : TJSElement; external name 'lastElementChild';
    FLocalName : string; external name 'localName';
    FNameSpaceURI : String; external name 'namespaceURI';
    FNextElementSibling : TJSElement; external name 'nextElementSibling';
    FPreviousElementSibling : TJSElement; external name 'previousElementSibling';
    FPrefix : String; external name 'prefix';
    FScrollHeight : NativeInt; external name 'scrollHeight';
{$IFDEF FIREFOX}
    FScrollLeftMax : NativeInt; external name 'scrollLeftMax';
    FScrollTopMax : NativeInt; external name 'scrollTopMax';
{$endif}
    FScrollWidth : NativeInt; external name 'scrollWidth';
    FTagName : string; external name 'tagName';
  Public
    name : string;
    className : string;
    id : string;
    innerHTML : String;
    outerHTML : string;
    scrollLeft : NativeInt;
    scrollTop : NativeInt;
    procedure append(aText : String); overload;
    procedure append(aNode : TJSElement); overload;
    procedure append(aText : String; aNode : TJSElement); varargs; overload;
    procedure append(aNode1,aNode2: TJSElement); varargs; overload;
    function getAttribute(aName : string) : string;
    function getAttributeNode(aName : string) : TJSAttr;
    function getAttributeNodeNS(aNameSpace, aName : string) : TJSAttr;
    function getAttributeNS(aNameSpace, aName : string) : string;
    function getBoundingClientRect : TJSDOMRect;
    function getClientRects : TJSClientRectArray;
    function getElementsByClassName(aClassName: string) : TJSHTMLCollection;
    function getElementsByTagNameNS(aNameSpace, aTagName : String): TJSHTMLCollection;
    function getElementsByTagName(aTagName : String): TJSHTMLCollection;
    function hasAttribute(aName : String) : Boolean;
    function hasAttributeNS(aNameSpace,aName : String) : Boolean;
    function hasAttributes : Boolean;
    function insertAdjacentElement(aPosition : string; aElement : TJSElement) : TJSElement;
    procedure insertAdjacentHTML(aPosition,aHTML : string);
    procedure insertAdjacentText(aPosition,aText : string);
    function matches(aSelectorString : String) : Boolean;
    function querySelector(aSelectors : String) : TJSElement;
    function querySelectorAll(aSelectors : String) : TJSNodeList;
    procedure releasePointerCapture(evID : JSValue);
    procedure removeAttribute(aName: string);
    procedure removeAttributeNS(aNameSpace,aName: string);
    function removeAttributeNode(aAttr : TJSAttr) : TJSAttr;
    procedure setAttribute(aName : string; AValue : String);
    function setAttributeNode(aNode: TJSAttr) : TJSAttr;
    function setAttributeNodeNS(aNode: TJSAttr) : TJSAttr;
    procedure setAttributeNS(aNameSpace,aName : string; AValue : String);
    procedure setCapture(retargetToElement : Boolean);
    procedure setPointerCapture(pointerID : JSValue);
    procedure requestFullScreen;    
    Property attributes : TJSNamedNodeMap read FAttributes;
    Property childElementCount : NativeInt Read FChildElementCount;
    Property children : TJSHTMLCollection Read FChildren;
    Property classList : TJSDOMTokenList read FClassList;
    property clientHeight : NativeInt read FClientHeight;
    property clientLeft : NativeInt read FClientLeft;
    property clientTop : NativeInt read FClientTop;
    property clientWidth : NativeInt read FClientWidth;
    property firstElementChild : TJSElement Read FFirstElementChild;
    property lastElementChild : TJSElement Read FLastElementChild;
    property localName : string Read FLocalName;
    property namespaceURI : String read FNameSpaceURI;
    property nextElementSibling : TJSElement Read FNextElementSibling;
    property previousElementSibling : TJSElement Read FPreviousElementSibling;
    property prefix : String read FPrefix;
    property scrollHeight : NativeInt Read FScrollHeight;
{$IFDEF FIREFOX}
    property scrollLeftMax  : NativeInt Read FScrollLeftMax;
    property scrollTopMax  : NativeInt Read FScrollTopMax;
{$ENDIF}
    property scrollWidth : NativeInt Read FScrollWidth;
    property tagName : String read FTagName;
    Property Attrs[aName : string] : String read getAttribute write setAttribute; default;
  end;
   
  TJSElementCreationOptions = record
    named : string;
  end;
 
  TJSDocumentType = class external name 'DocumentType' (TJSNode)
  private
    FName : String; external name 'name';
    FPublicID : String; external name 'publicId';
    FSystemID : String; external name 'systemId';
  public
    property name : String read FName;
    property publicId : String Read FPublicID;
    property systemId : String read FSystemID;
  end;

  TJSDOMImplementation  = class external name 'DocumentImplementation'
  Public  
    function createDocument(aNamespaceURI, aQualifiedNameStr : String; aDocumentType : TJSDocumentType) : TJSDocument;
    function createDocumentType(aQualifiedNameStr,aPublicId,aSystemId : String) : TJSDocumentType;
    function createHTMLDocument(aTitle : String) : TJSDocument;
  end;

  TJSLocation = class external name 'Location'
  Private
    FOrigin : string;
  Public
    hash : string;
    host : string;
    hostname : string;
    href : string;
    password : string;
    pathname : string;
    port : string;
    protocol : string;
    search : string;
    username : string;
    procedure assign(aURL : String);
    procedure reload(aForce : Boolean);
    procedure replace(aURL : String);
    function toString : String;
    property origin : string read FOrigin;
  end;
  
  TJSStyleSheet = class external name 'StyleSheet' (TJSEventTarget)
  Private
    FHRef : String; external name 'href';
    FOwnerNode : TJSNode; external name 'ownerNode';
    FParentStyleSheet : TJSStyleSheet; external name 'parentStyleSheet';
    FTitle : String; external name 'title';
    FType : String; external name 'type';
  Public
    disabled : String;
    Property href : String read FHRef;
    property ownerNode : TJSNode Read FOwnerNode;
    property parentStyleSheet : TJSStyleSheet read FParentStyleSheet;
    property title : string Read FTitle;
    property _type : String read FType;
  end;


  TJSCSSRule = class external name 'CSSRule'
  Private
    FCSSText : String; external name 'cssText';
    FParentStyleSheet : TJSCSSStyleSheet; external name 'parentStyleSheet';
    FparentRule : TJSCSSRule; external name 'parentRule';
  Public
    property cssText : String Read FCSSText;
    property parentRule : TJSCSSRule read FparentRule;
    property parentStyleSheet : TJSCSSStyleSheet Read FParentStyleSheet;
  end;
  
  TJSCSSRuleList = Class external name 'CSSRuleList'
  Private
    FLength : NativeInt; external name 'length';
  Public
    function item(index : NativeInt) : TJSCSSRule;
    property length : NativeInt Read FLength;
    Property items[aIndex : NativeInt] : TJSCSSRule read item; default;
  end;
  
  
  TJSCSSStyleSheet = class external name 'CSSStyleSheet' (TJSStyleSheet)
  Private
    FCSSRules : TJSCSSRuleList; external name 'cssRules';
  Public
    procedure deleteRule(aIndex : NativeInt);
    function insertRule(aRule : String; aIndex : NativeInt) : NativeInt;
    Property cssRules : TJSCSSRuleList read FCSSRules;
  end;

  TJSStyleSheetList = Class external name 'StyleSheetList'
  Private
    FLength : NativeInt; external name 'length';
  Public
    function item(index : NativeInt) : TJSStyleSheet;
    property length : NativeInt Read FLength;
    Property items[aIndex : NativeInt] : TJSStyleSheet read item; default;
  end;

  { TJSDocumentFragment }

  TJSDocumentFragment = Class external name 'DocumentFragment' (TJSNode)
  private
    FchildElementCount: Integer; external name 'childElementCount';
    Fchildren: TJSHTMLCollection; external name 'children';
    FfirstElementChild: TJSElement; external name 'firstElementChild';
    FlastElementChild: TJSElement; external name 'lastElementChild';
  public
    constructor new;
    function querySelector(aSelector : String) : TJSElement;
    function querySelectorAll(aSelector : String) : TJSNodeList;
    property childElementCount : Integer read FchildElementCount;
    property children : TJSHTMLCollection read Fchildren;
    property firstElementChild : TJSElement read FfirstElementChild;
    property lastElementChild : TJSElement read FlastElementChild;
  end;

  TJSEventInit = record
    bubbles : boolean;
    cancelable : boolean;
    scoped : boolean;
    composed : boolean;
  end;

  TJSEvent = class external name 'Event'
  Private
    FBubbles : Boolean; external name 'bubbles';
    FCancelable : Boolean; external name 'cancelable';
    FComposed : Boolean; external name 'composed';
    FCurrentTarget : TJSElement; external name 'currentTarget';
    FdefaultPrevented : Boolean; external name 'defaultPrevented';
    FEventPhase : NativeInt; external name 'eventPhase';
    FTarget : TJSElement; external name 'target';
    FTimeStamp : NativeInt; external name 'timestamp';
    FType : String; external name 'type';
    FIsTrusted : Boolean; external name 'isTrusted';
  Public
    Const
      NONE = 0;
      CAPTURING_PHASE = 1;
      AT_TARGET  = 2;
      BUBBLING_PHASE = 3;
  public    
    cancelBubble : Boolean;
    constructor new (aType : String; const aInit : TJSEventInit); overload;
    procedure preventDefault;
    procedure stopImmediatePropagation;
    procedure stopPropagation;
    Property bubbles : Boolean Read FBubbles;
    Property cancelable : Boolean Read FCancelable;
    Property composed : Boolean Read FComposed;
    property currentTarget : TJSElement Read FCurrentTarget;
    property defaultPrevented : Boolean Read FdefaultPrevented;
    property eventPhase : NativeInt Read FEventPhase;
    property target : TJSElement Read FTarget;
    Property timestamp : NativeInt Read FTimeStamp;
    property _type : string read FType;
    property isTrusted : Boolean Read FIsTrusted;
  end;


  TJSXPathExpression = class external name 'XPathExpression'
  Public
    function evaluate(contextNode : TJSNode; aType : NativeInt; aResult : TJSXPathResult) : TJSXPathResult;
    function evaluateWithContext(contextNode : TJSNode; aPosition, aSize, aType : NativeInt; aResult : TJSXPathResult) : TJSXPathResult;
  end;

  TJSXPathNSResolver = class external name 'XPathNSResolver'
  Public
    function lookupNamespaceURI(prefix : string) : string;
  end;

  { TJSCharacterData }

  TJSCharacterData = class external name 'CharacterData' (TJSNode)
  private
    FnextElementSibling: TJSElement; external name 'nextElementSibling';
    FpreviousElementSibling: TJSElement; external name 'previousElementSibling';
  public
    property nextElementSibling : TJSElement read FnextElementSibling;
    property previousElementSibling : TJSElement read FpreviousElementSibling;
  end;

  TJSProcessingInstruction = class external name 'ProcessingInstruction' (TJSCharacterData);

  { TJSRange }

  TJSRange = class external name 'Range'
  private
    FCollapsed: boolean; external name 'collapsed';
    FcommonAncestorContainer: TJSNode; external name 'commonAncestorContainer';
    FendContainer: TJSNode; external name 'endContainer';
    FEndOffset: NativeInt; external name 'endOffset';
    FstartContainer: TJSNode; external name 'startContainer';
    FstartOffset: NativeInt; external name 'startOffset';
  Public
    const
      END_TO_END     = 0;
      END_TO_START   = 1;
      START_TO_END   = 2;
      START_TO_START = 3;
  Public
    constructor new;
    function cloneContents : TJSDocumentFragment;
    function cloneRange : TJSRange;
    procedure collapse;
    function compareBoundaryPoints(aHow : NativeInt) : NativeInt;
    function createContextualFragment(aTagstring : String) : TJSDocumentFragment;
    procedure deleteContents;
    procedure detach;
    function extractContents : TJSDocumentFragment;
    procedure insertNode(aNode : TJSNode);
    procedure selectNode(aNode : TJSNode);
    procedure selectNodeContents(aNode : TJSNode);
    procedure setEnd(aEndNode : TJSNode; aEndOffset : NativeInt); 
    procedure setEndAfter(aEndNode : TJSNode);
    procedure setEndBefore(aEndNode : TJSNode);
    procedure setStart(aStartNode : TJSNode; aStartOffset : NativeInt); 
    procedure setStartAfter(aStartNode : TJSNode);
    procedure setStartBefore(aStartNode : TJSNode);
    procedure surroundContents(aNode : TJSNode);
    function toString : string;
    property collapsed : boolean read FCollapsed;
    property commonAncestorContainer : TJSNode read FcommonAncestorContainer ;
    property endContainer : TJSNode read FendContainer;
    property endOffset : NativeInt Read FEndOffset;
    property startContainer : TJSNode read FstartContainer;
    property startOffset : NativeInt Read FstartOffset;
  end;


  { TJSTreeWalker }

  TJSTreeWalker = class external name 'TreeWalker'
  private
    FCurrentNode: TJSNode; external name 'currentNode';
    FexpandEntityReference: Boolean; external name 'expandEntityReference';
    FFilter: TJSNodeFilter; external name 'filter';
    FRoot: TJSNode; external name 'root';
    FWhatToShow: NativeInt; external name 'whatToShow';
  Public
    function firstChild : TJSNode;
    function lastChild : TJSNode;
    function nextNode : TJSNode;
    function nextSibling : TJSNode;
    function parentNode : TJSNode;
    function previousNode : TJSNode;
    function previousSibling : TJSNode;

    property root : TJSNode read FRoot;
    property whatToShow : NativeInt read FWhatToShow;
    property filter : TJSNodeFilter Read FFilter;
    property expandEntityReference : Boolean Read FexpandEntityReference;
    property currentNode : TJSNode Read FCurrentNode;
  end;

  TJSNodeFilter = class external name 'NodeFilter'
    const
      SHOW_ALL                    = -1;
      SHOW_ATTRIBUTE              = 2;
      SHOW_CDATA_SECTION          = 8;
      SHOW_COMMENT                = 128;
      SHOW_DOCUMENT               = 256;
      SHOW_DOCUMENT_FRAGMENT      = 1024;
      SHOW_DOCUMENT_TYPE          = 512;
      SHOW_ELEMENT                = 1;
      SHOW_ENTITY                 = 32;
      SHOW_ENTITY_REFERENCE       = 16;
      SHOW_NOTATION               = 2048;
      SHOW_PROCESSING_INSTRUCTION = 64;
      SHOW_TEXT                   = 4;
    function acceptNode (aNode : TJSNode) : NativeInt;
  end;

  TJSXPathResult = class external name 'XPathResult'
  private
    FBooleanValue : Boolean; external name 'booleanValue';
    FNumberValue : Double; external name 'numberValue';
    FResultType : NativeInt; external name 'resultType';
    FSingleNodeValue : TJSNode;  external name 'singleNodeValue';
    FSnaphotLength : NativeInt; external name 'snapshotLength';
    FStringValue : String; external name 'stringValue';
  public  
    Function iterateNext : TJSNode;
    Function snapshotItem(Index: NativeInt) : TJSNode;
    Property booleanValue : Boolean Read FBooleanValue;
    Property numberValue : Double Read FNumberValue;
    property resultType : NativeInt Read FResultType;
    Property singleNodeValue : TJSNode Read FSingleNodeValue;
    property snapshotLength : NativeInt read FSnaphotLength;
    property stringValue : String Read FStringValue;
  end;

  TJSSelection = class external name 'Selection'
  Private
    FanchorNode : TJSNode ; external name 'anchorNode';
    FanchorOffset : NativeInt ; external name 'anchorOffset';
    FfocusNode : TJSNode ; external name 'focusNode';
    FfocusOffset : NativeInt ; external name 'focusOffset';
    FisCollapsed : Boolean ; external name 'isCollapsed';
    FrangeCount : NativeInt ; external name 'rangeCount';
    Ftype : String ; external name 'type';
  Public
    function getRangeAt(aIndex : NativeInt) : TJSRange;
    procedure collapse(aParentNode : TJSNode; Offset : NativeInt);
    procedure extend(aParentNode : TJSNode; Offset : NativeInt);
    procedure collapseToStart;
    procedure collapseToEnd;
    procedure selectAllChildren(aParentNode : TJSNode);
    procedure addRange(aRange : TJSRange);
    procedure removeRange(aRange : TJSRange);
    procedure removeAllRanges;
    procedure deleteFromDocument;
    function containsNode(aNode : TJSNode; aPartlyContained : Boolean) : Boolean;
    procedure setBaseAndExtent(aAnchorNode : TJSNode; aAnchorOffset : NativeInt; aFocusNode : TJSNode; aFocusOffset : NativeInt);
    function toString : String;
    property anchorNode : TJSNode read FAnchorNode;
    property anchorOffset : NativeInt read FAnchorOffset;
    property focusNode : TJSNode read FFocusNode;
    property focusOffset : NativeInt read FFocusOffset;
    property isCollapsed : Boolean read FIsCollapsed;
    property rangeCount : NativeInt read FRangeCount;
    property _type : String Read FType;
  end;
  TJSNameSpaceMapperCallback = function (aNameSpace : string ) : String;

  TJSHTMLFile = class;
  TJSHTMLFileList = Class;

  { TJSDataTransferItem }

  TJSDataTransferItemCallBack = reference to Procedure(aData : String);

  TJSDataTransferItem = class external name 'DataTransferItem'
  private
    FKind: String; external name 'kind';
    FType: string; external name 'type';
  Public
    function getAsFile : TJSHTMLFile;
    Procedure getAsString(aCallBack : TJSDataTransferItemCallBack);
    property Kind : String read FKind;
    property _Type : string read FType;
  end;

  TJSDataTransferItemList = class external name 'DataTransferItemList'
  private
    FLength: NativeInt; external name 'length';
    function getitem(aIndex : nativeInt) : TJSDataTransferItem ; external name '[]';
  Public
    Function add(aData : string; AType: string) : TJSDataTransferItem; overload;
    Function add(aFile : TJSHTMLFile) : TJSDataTransferItem; overload;
    Procedure clear;
    procedure remove(aIndex : integer);
    property length : NativeInt read FLength;
    property Items[aIndex : NativeInt] : TJSDataTransferItem Read getitem; default;
  end;

  { TDataTransfer }

  TJSDataTransfer = class external name 'DataTransfer'
  private
    FFiles: TJSHTMLFileList; external name 'files';
    FItems: TJSDataTransferItemList; external name 'items';
    FTypes: TJSStringDynArray; external name 'types';
  Public
    dropEffect : string;
    effectAllowed : string;
    Procedure clearData; overload;
    Procedure clearData(aFormat : string); overload;
    function getData(aFormat : string) : String;
    procedure setData(aFormat : String; aData : String);
    procedure setDragImage(aImage: TJSElement; xOffset,yOffset : integer);
    property files : TJSHTMLFileList Read FFiles;
    property items : TJSDataTransferItemList read FItems;
    property types : TJSStringDynArray read FTypes;
  end;

  { TJSDragEvent }

  TJSDragEvent = class external name 'DragEvent' (TJSEvent)
  Private
    FDataTransfer: TJSDataTransfer; external name 'dataTransfer';
    FrelatedTarget : TJSEventTarget external name 'relatedTarget';
    FscreenX : NativeInt external name 'screenX';
    FscreenY : NativeInt external name 'screenY';
    FclientX : NativeInt external name 'clientX';
    FclientY : NativeInt external name 'clientY';
    Fbutton : NativeInt external name 'button';
    Fbuttons : NativeInt external name 'buttons';
    FctrlKey : Boolean external name 'ctrlKey';
    FshiftKey : Boolean external name 'shiftKey';
    FaltKey  : Boolean external name 'altKey';
    FmetaKey  : Boolean external name 'metaKey';
  Public
    Property relatedTarget : TJSEventTarget Read FRelatedTarget;
    Property screenX : NativeInt Read FScreenX;
    Property screenY : NativeInt Read FScreenY;
    Property clientX : NativeInt Read FClientX;
    Property clientY : NativeInt Read FClientY;
    Property button : NativeInt Read FButton;
    Property buttons : NativeInt Read FButtons;
    Property ctrlKey : Boolean Read FctrlKey;
    Property shiftKey : Boolean Read FshiftKey;
    Property altKey  : Boolean Read FaltKey;
    Property metaKey  : Boolean Read FmetaKey;
    property dataTransfer : TJSDataTransfer Read FDataTransfer;
  end;
  TJSDragDropEventHandler = reference to function(aEvent: TJSDragEvent) : Boolean;
  THTMLClickEventHandler = reference to function(aEvent : TJSMouseEvent) : boolean;
  { Various events }

{$IFNDEF FIREFOX}
  TJSFocusEvent = TJSEvent;
{$ELSE}
  TJSFocusEvent = Class(TJSEvent)
  private
    FrelatedTarget : TJSElement external name 'relatedTarget';
  public
    property relatedTarget : TJSElement Read FrelatedTarget;
  end;
{$ENDIF}
  TJSAnimationEvent = Class(TJSEvent);
  TJSLoadEvent = Class(TJSEvent);

  TJSErrorEvent = class external name 'ErrorEvent' (TJSEvent)
  Private
    Fmessage : String external name 'message';
    Ffilename : string external name 'filename';
    Flineno : integer external name 'lineno';
    Fcolno : integer external name 'colno';
    Ferror : TJSObject external name 'error';
  Public
    Property message : String read FMessage;
    property filename : string Read FFileName;
    property lineno : integer read FLineNo;
    Property colno : integer read FColNo;
    Property error : TJSObject read FError;
  end;

  TJsPageTransitionEvent = class(TJSEvent)
  end;

  TJSHashChangeEvent = class external name 'HashChangeEvent' (TJSEvent)
  Private
    FnewURL : String external name 'newURL';
    FoldURL : String external name 'oldURL';
  public
    property newURL : String Read FNewURL;
    property oldURL : String Read FOldURL;
  end;

  TJSPopStateEvent = class external name 'PopStateEvent'  (TJSEvent)
  Private
    FState : JSValue; external name 'state';
  Public
    property state : JSValue read FState;
  end;

  TJSStorageEvent = class external name 'StorageEvent' (TJSEvent)
  private
    Fkey : String external name 'key';
    FoldValue : String external name 'oldValue';
    FnewValue : String external name 'newValue';
    Furl : String external name 'url';
    FstorageArea : String external name 'storageArea';
  public
    Property key : String Read FKey;
    Property oldValue : String Read FOldValue;
    Property newValue : String Read FNewValue;
    Property url : String Read FURL;
    Property storageArea : String Read FstorageArea;
  end;

  { TJSProgressEvent }

  TJSProgressEvent = class external name 'ProgressEvent' (TJSEvent)
  Private
    FlengthComputable : Boolean external name 'lengthComputable';
    Floaded : NativeUINT external name 'loaded';
    FTotal : NativeUINT external name 'Total';
  Public
    property lengthComputable : Boolean Read FlengthComputable;
    property loaded : NativeUINT Read FLoaded;
    property Total : NativeUINT Read FTotal;
  end;

  TJSPageTransitionEventHandler = reference to function(aEvent : TJsPageTransitionEvent) : boolean;
  TJSHashChangeEventhandler = reference to function(aEvent : TJSHashChangeEvent) : boolean;
  TJSMouseWheelEventHandler = reference to function(aEvent : TJSWheelEvent) : boolean;
  TJSMouseEventHandler = reference to function(aEvent : TJSMouseEvent) : boolean;
  THTMLAnimationEventHandler = reference to function(aEvent : TJSAnimationEvent) : boolean;
  TJSErrorEventHandler = reference to function(aEvent : TJSErrorEvent) : boolean;
  TJSFocusEventHandler = reference to function(aEvent : TJSFocusEvent) : boolean;
  TJSKeyEventhandler = reference to function (aEvent : TJSKeyBoardEvent) : boolean;
  TJSLoadEventhandler = reference to function (aEvent : TJSLoadEvent) : boolean;
  TJSPointerEventHandler = reference to function(aEvent : TJSPointerEvent) : boolean;
  TJSUIEventHandler = reference to function(aEvent : TJSUIEvent) : Boolean;
  TJSPopStateEventHandler = reference to function(aEvent : TJSPopStateEvent) : Boolean;
  TJSStorageEventHandler = reference to function(aEvent : TJSStorageEvent) : Boolean;
  TJSProgressEventhandler =  reference to function(aEvent : TJSProgressEvent) : Boolean;
  TJSTouchEventHandler = reference to function(aEvent : TJSTouchEvent) : boolean;

  TJSDocument = class external name 'Document' (TJSNode)
  Private
    fActiveElement : TJSElement; external name 'activeElement';
    FCharacterSet: String; external name 'characterSet';
    FChildElementCount: NativeInt; external name 'childElementCount';
    FCompatMode: String; external name 'compatMode';
    FCurrentScript: TJSElement; external name 'currentScript';
    FDefaultView: TJSWindow; external name 'defaultView';
    FDocType: TJSDocumentType; external name 'docrype';
    FDocumentElement: TJSElement; external name 'documentElement';
    FDocumentURI: String; external name 'documentURI';
    FEmbeds: TJSHTMLCollection; external name 'embeds';
    FFirstElementChild : TJSElement; external name 'firstElementChild';
    FForms: TJSHTMLCollection; external name 'forms';
    FFullScreenElement: TJSElement; external name 'fullscreenElement';
    FFullscreenEnabled: Boolean; external name 'fullscreenEnabled';
    FHead: TJSElement; external name 'head';
    FHidden: Boolean; external name 'hidden';
    FImages: TJSHTMLCollection; external name 'images';
    FImplementation: TJSDOMImplementation; external name 'implementation';
    FLastElementChild : TJSElement; external name 'lastElementChild';
    FLastModified: String; external name 'lastModified';
    FLastStyleSheetSet: String; external name 'lastStyleSheetSet';
    FLinks: TJSHTMLCollection; external name 'links';
    FLocation: TJSLocation; external name 'location';
    FLocationString: String; external name 'location';
    FPlugins: TJSHTMLCollection; external name 'plugins';
    FPointerLockElement: TJSElement; external name 'pointerLockElement';
    FPreferredStyleSheetSet: String; external name 'preferredStyleSheetSet';
    FReadyState: String; external name 'readyState';
    FReferrer: String; external name 'referrer';
    FScripts: TJSHTMLCollection; external name 'scripts';
    FStyleSheets: TJSStyleSheetList; external name 'styleSheets';
    FStyleSheetSets: TJSValueDynArray; external name 'styleSheetSets';
    FURL: String; external name 'URL';
    FVisibilityState: string; external name 'visibilityState';
  Public
    function adoptNode(aExternalNode : TJSNode) : TJSNode;
    procedure close;
    function createAttribute(aName : string) : TJSAttr;
    function createCDATASection(S : String) : TJSNode;
    function createComment(S : String) : TJSNode;
    function createDocumentFragment : TJSDocumentFragment;
    function createElement(tagName : string) : TJSElement; overload;
    function createElement(tagName : string; const options : TJSElementCreationOptions) : TJSElement; overload;
    function createElementNS(aNameSpace,tagName : string) : TJSElement; overload;
    function createElementNS(aNameSpace,tagName : string; const options : TJSElementCreationOptions) : TJSElement; overload;
    function createEvent(aType : string) : TJSEvent;
    function createExpression(xPathText : String; aNameSpaceMapper: TJSNameSpaceMapperCallback) : TJSXPathExpression;
    function createNSResolver(aNode : TJSNode) : TJSXPathNSResolver;
    function createProcessingInstruction(target, data : String) : TJSProcessingInstruction;
    function createRange : TJSRange;
    function createTextNode(S : String) : TJSNode;
    function createTreeWalker(root : TJSNode; whatToShow : NativeInt; filter : TJSNodeFilter) : TJSTreeWalker;
    function elementFromPoint(x,y : integer) : TJSElement;
    procedure enableStyleSheetsForSet(aSet : String);
    function evaluate(xpathExpression : String; ContextNode : TJSNode; NameSpaceResolver : TJSNamespaceMapperCallBack; resultType : NativeInt; aResult : TJSXPathResult) : TJSXPathResult;
    function execCommand(aCommandName : String; aShowDefaultUI : Boolean; AValueArgument : String) : boolean; overload;
    function execCommand(aCommandName : String; aShowDefaultUI : Boolean) : boolean; overload;
    Procedure exitFullScreen;
    function getElementById(aID : String) : TJSElement;
    function getElementsyClassName(aNames : string) : TJSHTMLCollection;
    function getElementsByName(aName : String) : TJSNodeList;
    function getElementsByTagName(aName : String) : TJSHTMLCollection;
    function getElementsByTagNameNS(aNameSpace,aName : String) : TJSHTMLCollection;
    function getSelection : TJSSelection;
    function hasFocus : boolean;
    function importNode(aExternalNode : TJSNode; Deep: boolean) : TJSNode;
    function querySelector(aSelectors : String) : TJSElement;
    function querySelectorAll(aSelectors : String) : TJSNodeList;
    procedure open;
    procedure releaseCapture;
    procedure write(aLine : string);
    procedure writeln(aLine : String);
  Public
    body : TJSElement;
    designMode : string;
    dir : string;
    domain : string;
    selectedStyleSheetSet : string;
    title : string;
    onabort : TJSEventHandler;
    onblur : TJSEventHandler;
    oncancel : TJSEventHandler;
    oncanplay : TJSEventHandler;
    oncanplaythrough : TJSEventHandler;
    onchange : TJSEventHandler;
    onclick: THTMLClickEventHandler;
    onclose : TJSEventHandler;
    oncontextmenu : TJSEventHandler;
    oncuechange : TJSEventHandler;
    ondblclick : THTMLClickEventHandler;
    ondrag : TJSDragDropEventHandler;
    ondragend : TJSDragDropEventHandler;
    ondragenter : TJSDragDropEventHandler;
    ondragexit : TJSDragDropEventHandler;
    ondragover : TJSDragDropEventHandler;
    ondragleave : TJSDragDropEventHandler;
    ondragstart: TJSDragDropEventHandler;
    ondrop : TJSDragDropEventHandler;
    ondurationchange : TJSEventHandler;
    onemptied : TJSEventHandler;
    onended : TJSEventHandler;
    onerror : TJSErrorEventHandler;
    onfocus : TJSFocusEventhandler;
    ongotpointercapture : TJSPointerEventHandler;
    oninput : TJSEventhandler;
    oninvalid : TJSEventhandler;
    onkeydown : TJSKeyEventhandler;
    onkeypress : TJSKeyEventhandler;
    onkeyup : TJSKeyEventhandler;
    onload : TJSEventhandler;
    onloadeddata : TJSEventhandler;
    onloadedmetadata : TJSEventhandler;
    onloadend : TJSProgressEventhandler;
    onloadstart : TJSProgressEventhandler;
    onlostpointercapture : TJSPointerEventHandler;
    onmessage : TJSEventHandler;
    onmousedown : TJSMouseEventHandler;
    onmouseenter : TJSMouseEventHandler;
    onmouseleave : TJSMouseEventHandler;
    onmousemove : TJSMouseEventHandler;
    onmouseout : TJSMouseEventHandler;
    onmouseover : TJSMouseEventHandler;
    onmouseup : TJSMouseEventHandler;
    onmousewheel : TJSMouseEventHandler;
    onpause : TJSEventHandler;
    onplay : TJSEventHandler;
    onplaying : TJSEventHandler;
    onpointercancel : TJSPointerEventHandler;
    onpointerdown : TJSPointerEventHandler;
    onpointerenter : TJSPointerEventHandler;
    onpointerleave : TJSPointerEventHandler;
    onpointermove : TJSPointerEventHandler;
    onpointerout : TJSPointerEventHandler;
    onpointerover : TJSPointerEventHandler;
    onpointerup : TJSPointerEventHandler;
    onpointerlockchange : TJSPointerEventHandler;
    onprogress : TJSProgressEventhandler;
    onreset : TJSUIEventHandler;
    onratechange : TJSEventHandler;
    onscroll : TJSUIEventHandler;
    onseekend : TJSEventHandler;
    onseeking : TJSEventHandler;
    onselect : TJSEventHandler;
    onselectionchange : TJSEventHandler;
    onsshow : TJSEventHandler;
    onsubmit : TJSEventHandler;
    onunload : TJSUIEventHandler;
    onwaiting : TJSEventHandler;
    touchstart : TJSTouchEventHandler;
    touchend : TJSTouchEventHandler;
    touchmove : TJSTouchEventHandler;
    touchcancel : TJSTouchEventHandler;
    Property activeElement : TJSElement Read FActiveElement;
    Property characterSet : String Read FCharacterSet;
    property childElementCount : NativeInt Read FChildElementCount;
    property compatMode : String Read FCompatMode;
    property currentScript : TJSElement Read FCurrentScript;
    property defaultView : TJSWindow Read FDefaultView;
    property doctype : TJSDocumentType read FDocType;
    property documentElement : TJSElement read FDocumentElement;
    property documentURI : String Read FDocumentURI;
    property embeds : TJSHTMLCollection Read FEmbeds;
    property firstElementChild : TJSElement Read FFirstElementChild;
    property lastElementChild : TJSElement Read FLastElementChild;
    property Forms : TJSHTMLCollection Read FForms;
    property fullscreenElement : TJSElement Read FFullScreenElement;
    property fullscreenEnabled : Boolean Read FFullscreenEnabled;
    property head : TJSElement read FHead;
    Property hidden : Boolean read FHidden;
    property images : TJSHTMLCollection Read FImages;
    property _implementation : TJSDOMImplementation Read FImplementation;
    property lastModified : String Read FLastModified;
    property lastStyleSheetSet : String read FLastStyleSheetSet;
    property links : TJSHTMLCollection Read FLinks;
    property location : TJSLocation read FLocation;
    Property LocationString : String Read FURL Write FLocationString; // On purpose
    property plugins : TJSHTMLCollection Read FPlugins;
    property pointerLockElement : TJSElement Read FPointerLockElement;
    property preferredStyleSheetSet : String Read FPreferredStyleSheetSet;
    Property readyState : String Read FReadyState;
    Property referrer : String Read FReferrer;
    property scripts : TJSHTMLCollection Read FScripts;
    property styleSheets : TJSStyleSheetList Read FStyleSheets;
    property styleSheetSets : TJSValueDynArray Read FStyleSheetSets; // No type documented ?
    Property URL : String Read FURL;
    property visibilityState : string read FVisibilityState;
  end;

  TJSConsole = class external name 'Console'
  Public
    procedure assert(anAssertion : string; Obj1 : JSValue); varargs;
    Procedure clear;  
    procedure count; overload;
    procedure count(aCounter : String);
    procedure error(Obj1 : JSValue); varargs;
    procedure group;
    procedure groupCollapsed;
    procedure groupEnd;
    procedure info(Obj1 : JSValue); varargs;
    procedure log(Obj1 : JSValue); varargs;
    procedure table(args: array of JSValue);
    procedure time(aName : string);
    procedure timeEnd(aName : string);
    procedure trace;
    procedure warn(Obj1 : JSValue); varargs;
  end;

  TPromiseResolverFunc = Procedure (aValue : JSValue);
  TPromiseResolverMethod = Procedure (aValue : JSValue);
  TJSPromiseExecutorFunc = procedure (resolve,reject : TPromiseResolverFunc);
  TJSPromiseExecutorMethod = procedure (resolve,reject : TPromiseResolverFunc) of object;
  
  TJSPromise = class external name 'Promise'
    constructor new(Executor : TJSPromiseExecutorFunc);
    constructor new(Executor : TJSPromiseExecutorMethod);
    class function reject(reason : JSValue) : TJSPromise;
    class function resolve(value : JSValue): TJSPromise;
    function catch (onRejected : TPromiseResolverFunc) : TJSPromise;
    function catch (onRejected : TPromiseResolverMethod) : TJSPromise;
    function _then (onRejected : TPromiseResolverFunc) : TJSPromise;
    function _then (onRejected : TPromiseResolverMethod) : TJSPromise;
  end;
  
  { TJSCryptoKey }

  TJSCryptoKey = class external name 'CryptoKey'
  private
    FAlgorithm: JSValue; external name 'algorithm';
    FExtractable: Boolean; external name 'extractable';
    FType: string; external name 'type';
    FUsages: TStringDynArray; external name 'usages';
  Public
    property _type : string read FType;
    property extractable: Boolean read FExtractable;
    property algorithm : JSValue read FAlgorithm;
    property usages : TStringDynArray Read FUsages;
  end;
  
  { TJSSubtleCrypto }

  TJSBufferSource = class external name 'BufferSource' end;
  TJSTypedArray = class external name 'TypedArray' end;

  TJSSubtleCrypto = class external name 'SubtleCrypto'
  Public
    function decrypt(algorithm : JSValue; aKey : TJSCryptoKey; aData : TJSBufferSource) : TJSPromise;
    function deriveKey(algorithm : JSValue; aMasterKey : TJSCryptoKey; aDerivedAlgo : JSValue; extractable : Boolean; Usages : TStringDynArray) : TJSPromise;
    function digest(algorithm : string; Buffer : TJSArrayBuffer) : TJSPromise; overload;
    function digest(algorithm : string; Buffer : TJSTypedArray) : TJSPromise; overload;
    function encrypt(algorithm : JSValue; aKey : TJSCryptoKey; aData : TJSBufferSource) : TJSPromise;
    function exportKey(algorithm : String; AKey : TJSCryptoKey) : TJSPromise;
    function generateKey(algorithm : JSValue; extractable : Boolean; Usages : TStringDynArray) : TJSPromise;
    function importKey(format : String; KeyData : TJSArrayBuffer; algorithm : String; extractable : Boolean; Usages : TStringDynArray) : TJSPromise;
    function sign(algorithm : string; Key : TJSCryptoKey; aText : TJSArrayBuffer) : TJSPromise; overload;
    function unwrapKey(algorithm : string; wrappedKey : TJSArrayBuffer; Key: TJSCryptoKey;
                       unwrapAlgo : string; unwrappedKeyAlgo : string; 
                       extractable : Boolean; Usages : TStringDynArray) : TJSPromise;
   function verify(algorithm : String; key : TJSCryptoKey; Signature : TJSArrayBuffer; 
                   textToVerify : TJSArrayBuffer): TJSPromise;
   function wrapKey(aFormat : string; Key,WrappingKey : TJSCryptoKey; WrapAlgorithm : String) : TJSPromise;                   
  end;
  
  { TJSCrypto }

  TJSCrypto = class external name 'Crypto'
  private
    FsubtleCrypto: TJSSubtleCrypto;
  Public
    procedure getRandomValues (anArray : TJSTypedArray);
    property subtleCrypto : TJSSubtleCrypto Read FsubtleCrypto;
  end;
  
  { TJSHistory }

  TJSHistory = class external name 'History'
  private
    FLength: NativeInt; external name 'length';
{$IFDEF FIREFOX}
    FState : JSValue; external name 'state';
{$ENDIF}
  Public
    procedure back;
    procedure forward;
    procedure go(aIndex : NativeInt);
    procedure go;
    procedure pushState(aState : jsValue; aTitle : String; AURL : String);
    procedure pushState(aState : jsValue; aTitle : String);
    procedure replaceState(aState : jsValue; aTitle : String; AURL : String);
    procedure replaceState(aState : jsValue; aTitle : String);
    procedure replaceState(aState : jsValue);
{$IFDEF FIREFOX}
    property state : JSValue read FState;
{$ENDIF}
    property length: NativeInt read FLength;
  end;

  TJSIDBTransactionMode = class
  const
    readonly = 'readonly';
    readwrite = 'readwrite';
    versionchange = 'versionchange';
  end;


  { TJSIDBTransaction }

  TJSIDBTransaction = class external name 'IDBTransaction'  (TJSEventTarget)
  private
    FDB : TIDBDatabase; external name 'db';
    FError: JSValue; external name 'error';
    FMode: String; external name 'mode';
    FObjectStoreNames: TStringDynArray; external name 'objectStoreNames';
  public
    procedure abort;
    function objectStore(aName : String) : TJSIDBObjectStore;
    property db : TIDBDatabase read FDB;
    property mode : String read FMode;
    property objectStoreNames : TStringDynArray read FObjectStoreNames;
    property error : JSValue read FError;
  end;


  { TJSIDBKeyRange }

  TJSIDBKeyRange = class external name 'IDBKeyRange'
  private
    FLower: JSValue;
    FLowerOpen: Boolean;
    FUpper: JSValue;
    FUpperOpen: Boolean;
  Public
    Class Function bound(aLower,aUpper : JSValue) : TJSIDBKeyRange; overload;
    Class Function bound(aLower,aUpper : JSValue; aLowerOpen : Boolean) : TJSIDBKeyRange; overload;
    Class Function bound(aLower,aUpper : JSValue; aLowerOpen,aUpperOpen : Boolean) : TJSIDBKeyRange; overload;
    Class Function lowerBound(aLower : JSValue) : TJSIDBKeyRange; overload;
    Class Function lowerBound(aLower : JSValue; aOpen: Boolean) : TJSIDBKeyRange; overload;
    Class Function only(aValue : JSValue) : TJSIDBKeyRange;
    Class Function upperBound(aUpper : JSValue) : TJSIDBKeyRange; overload;
    Class Function upperBound(aUpper : JSValue; aOpen: Boolean) : TJSIDBKeyRange; overload;
    function includes (aValue : JSValue) : Boolean;
    property lower : JSValue read FLower;
    property lowerOpen : Boolean read FLowerOpen;
    property upper : JSValue read FUpper;
    property upperOpen : Boolean read FUpperOpen;
  end;

  TJSIDBIndexParameters = record
    unique : boolean;
    multiEntry : boolean;
    locale : string;
  end;


  { TJSIDBIndex }

  TJSIDBIndex = class external name 'IDBIndex'
  private
    FKeyPath: JSValue; external name 'keyPath';
    FMultiEntry: Boolean; external name 'multiEntry';
    FObjectStore: TJSIDBObjectStore; external name 'objectStore';
    FUnique: boolean; external name 'unique';
  public
    name : string;
    function count : TJSIDBRequest;
    function get(aKey : jsValue) : TJSIDBRequest; overload;
    function get(aKey : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function getAll(aKey : jsValue) : TJSIDBRequest; overload;
    function getAll(aKey : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function getAll(aKey : jsValue; ACount : NativeInt) : TJSIDBRequest; overload;
    function getAll(aKey : TJSIDBKeyRange; ACount : NativeInt) : TJSIDBRequest; overload;
    function getAllKeys(aKey : jsValue) : TJSIDBRequest; overload;
    function getAllKeys(aKey : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function getAllKeys(aKey : jsValue; ACount : NativeInt) : TJSIDBRequest; overload;
    function getAllKeys(aKey : TJSIDBKeyRange; ACount : NativeInt) : TJSIDBRequest; overload;
    function getKey(aKey : jsValue) : TJSIDBRequest;
    function openCursor : TJSIDBRequest; overload;
    function openCursor(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function openCursor(aKeyRange : TJSIDBKeyRange; ADirection : String) : TJSIDBRequest;overload;
    function openKeyCursor : TJSIDBRequest;overload;
    function openKeyCursor(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest;overload;
    function openKeyCursor(aKeyRange : TJSIDBKeyRange; ADirection : String) : TJSIDBRequest;overload;
    Property keyPath : JSValue Read FKeyPath;
    property multiEntry : Boolean read FMultiEntry;
    property objectStore : TJSIDBObjectStore read FObjectStore;
    property unique : boolean read FUnique;
  end;

  TJSIDBCursorDirection = class external name 'IDBCursorDirection'
  Const
    next = 'next';
    nextUnique = 'nextUnique';
    prev = 'prev';
    prevUnique = 'prevUnique';
  end;


  { TJSIDBCursor }

  TJSIDBCursor = class external name 'IDBCursor'
  private
    FDirection: string; external name 'direction';
    FKey: JSValue; external name 'key';
    FPrimaryKey: JSValue; external name 'primaryKey';
    FSource: JSValue; external name 'source';
    FSourceAsIndex: TJSIDBIndex; external name 'source';
    FSourceAsStore: TJSIDBObjectStore; external name 'source';
  Public
    procedure advance(aCount : NativeInt); overload;
    procedure advance(aKey : JSValue); overload;
    procedure continue(aKey : JSValue); overload;
    procedure continue; overload;
    procedure continuePrimaryKey(aKey : JSValue); overload;
    procedure continuePrimaryKey(aKey,aPrimaryKey : JSValue); overload;
    procedure delete;
    procedure update(aValue : JSValue);
    property source : JSValue read FSource;
    property sourceAsStore : TJSIDBObjectStore read FSourceAsStore;
    property sourceAsIndex : TJSIDBIndex read FSourceAsIndex;
    property key : JSValue read FKey;
    property primaryKey : JSValue read FPrimaryKey;
    property direction : string read FDirection;
  end;

  TJSIDBObjectStore = class external name 'IDBObjectStore'  (TJSEventTarget)
  public
    function add(aValue : JSValue; aKey : String) : TJSIDBRequest;
    function add(aValue : JSValue) : TJSIDBRequest;
    function clear : TJSIDBRequest;
    function delete(aKey : string) : TJSIDBRequest;
    function delete(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest;
    function get(aKey : string) : TJSIDBRequest; overload;
    function get(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function getKey(aKey : string) : TJSIDBRequest; overload;
    function getKey(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function getAll : TJSIDBRequest; overload;
    function getAll(aKey : String) : TJSIDBRequest; overload;
    function getAll(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function getAll(aKey : String; aCount: NativeInt) : TJSIDBRequest; overload;
    function getAll(aKeyRange : TJSIDBKeyRange; aCount: NativeInt) : TJSIDBRequest; overload;
    function getAllKeys(aKey : String) : TJSIDBRequest; overload;
    function getAllKeys(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function getAllKeys(aKey : String; aCount: NativeInt) : TJSIDBRequest; overload;
    function getAllKeys(aKeyRange : TJSIDBKeyRange; aCount: NativeInt) : TJSIDBRequest; overload;
    function createIndex (aIndexName : String; KeyPath : String)  : TJSIDBIndex; overload;
    function createIndex (aIndexName : String; KeyPath : String; Options : TJSIDBIndexParameters)  : TJSIDBIndex; overload;
    function createIndex (aIndexName : String; KeyPath : Array of String)  : TJSIDBIndex; overload;
    function createIndex (aIndexName : String; KeyPath : Array of String; Options : TJSIDBIndexParameters)  : TJSIDBIndex; overload;
    Procedure deleteIndex (aIndexName : String);
    function index (aIndexName : String)  : TJSIDBIndex;
    function put(aValue : JSValue; aKey : String) : TJSIDBRequest; overload;
    function put(aValue : JSValue) : TJSIDBRequest; overload;
    function openCursor : TJSIDBRequest; overload;
    function openCursor(aKey : String) : TJSIDBRequest; overload;
    function openCursor(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function openCursor(aKey : String; aDirection : string) : TJSIDBRequest; overload;
    function openCursor(aKeyRange : TJSIDBKeyRange; aDirection : string) : TJSIDBRequest; overload;
    function openKeyCursor : TJSIDBRequest; overload;
    function openKeyCursor(aKey : String) : TJSIDBRequest; overload;
    function openKeyCursor(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    function openKeyCursor(aKey : String; aDirection : string) : TJSIDBRequest; overload;
    function openKeyCursor(aKeyRange : TJSIDBKeyRange; aDirection : string) : TJSIDBRequest; overload;
    function count : TJSIDBRequest; overload;
    function count(aKey : String) : TJSIDBRequest; overload;
    function count(aKeyRange : TJSIDBKeyRange) : TJSIDBRequest; overload;
    property Indexes [aIndexName : String] : TJSIDBIndex read index;
  end;

  { TJSIDBRequest }

  TJSIDBRequest = class external name 'IDBRequest'  (TJSEventTarget)
  private
    Ferror : JSValue; external name 'error'; // standards are not quite clear on this one
    FReadyState: string; external name 'readyState';
    FResult: JSValue; external name 'result';
    FResultDatabase: TIDBDatabase; external name 'result';
    FResultIndex: TJSIDBIndex; external name 'result';
    FResultObjectStore : TJSIDBObjectStore; external name 'result';
    FResultCursor : TJSIDBCursor; external name 'result';
    FSourceDatabase: TIDBDatabase; external name 'source';
    FSourceIndex: TJSIDBIndex; external name 'source';
    FSourceObjectStore : TJSIDBObjectStore; external name 'source';
    FSourceCursor : TJSIDBCursor; external name 'source';
    FSource: JSValue; external name 'source';
    FTransaction: TJSIDBTransaction; external name 'transaction';
  Public
    onerror : TJSEventHandler;
    onsuccess : TJSEventHandler;
    Property error : JSValue read FError;
    property readyState : string read FReadyState;

    property result : JSValue read FResult;
    property resultAsObjectStore : TJSIDBObjectStore read FResultObjectStore;
    property resultAsCursor : TJSIDBCursor read FResultCursor;
    property resultAsIndex : TJSIDBIndex read FResultIndex;
    property resultAsDatabase : TIDBDatabase read FResultDatabase;

    property source : JSValue read FSource;
    property sourceAsObjectStore : TJSIDBObjectStore read FSourceObjectStore;
    property sourceAsCursor : TJSIDBCursor read FSourceCursor;
    property sourceAsIndex : TJSIDBIndex read FSourceIndex;
    property sourceAsDatabase : TIDBDatabase read FSourceDatabase;

    property transaction : TJSIDBTransaction read FTransaction;
  end;

  TJSIDBOpenDBRequest = class external name 'IDBOpenDBRequest' (TJSIDBRequest)
  Public
    onblocked : TJSEventHandler;
    onupgradeneeded : TJSEventHandler;
  end;

  TJSCreateObjectStoreOptions = record
    keyPath : jsValue;
    autoIncrement : boolean;
  end;

  { TIDBDatabase }

  TIDBDatabase = class external name 'IDBDatabase' (TJSEventTarget)
  private
    FName: string; external name 'name';
    FobjectStoreNames: TStringDynArray; external name 'objectStoreNames';
    FVersion: integer; external name 'version';
  public
    procedure close;
    function createObjectStore(aName : string) : TJSIDBObjectStore; overload;
    function createObjectStore(aName : string; Options: TJSCreateObjectStoreOptions) : TJSIDBObjectStore; overload;
    procedure deleteObjectStore(aName : string);
    function transaction(aStoreNames : array of string) : TJSIDBTransaction; overload;
    function transaction(aStoreNames : array of string; aMode : string) : TJSIDBTransaction; overload;
    property name : string read FName;
    property version : integer read FVersion;
    property objectStoreNames : TStringDynArray read FobjectStoreNames;
  end;

  TJSIDBFactory = class external name 'IDBFactory' (TJSEventTarget)
  public
    function open(aName : string) : TJSIDBOpenDBRequest;
    function open(aName : string; aVersion : Integer) : TJSIDBOpenDBRequest;
    function deleteDatabase(aName : string) : TJSIDBOpenDBRequest;
    function cmp (a,b : jsValue) : NativeInt;
  end;
  
  { TJSStorage }

  TJSStorage = class external name 'Storage' (TJSEventTarget)
  private
    FLength: NativeInt; external name 'length';
  public
    function key(aIndex : Integer) : String;
    function getItem(aKeyName : string) : string;
    procedure setItem(aKeyName : string; aValue : string);
    procedure removeItem(aKeyName : string);
    procedure clear;
    property Keys[AIndex : Integer] : String read key;
    property Items[aKeyName: String] : String read getItem write setItem; default;
    property length : NativeInt Read FLength;
  end;

  // Fake object, used for objects whose visible can be checked
  TJSVisibleItem = class external name 'IVisible'
  Private
    FVisible : boolean; external name 'visible';
  Public
    Property visible : boolean read FVisible;
  end;
  
  TJSLocationBar = class external name 'LocationBar' (TJSVisibleItem);
  TJSMenuBar = class external name 'MenuBar' (TJSVisibleItem);
  TJSToolBar = class external name 'ToolBar' (TJSVisibleItem);
  TJSPersonalBar = class external name 'PersonalBar' (TJSVisibleItem);
  TJSScrollBars = class external name 'ScrollBars' (TJSVisibleItem);

  TJSPositionError = record
    code : integer;
    message : string;
  end;

  TJSPositionOptions = record
    enableHighAccuracy : boolean;
    timeout : integer;
    maximumAge : integer;
  end;

  TJSCoordinates = record
    latitude : double;
    longitude : double;
    altitude : double;
    accuracy : double;
    altitudeAccuracy : double;
    heading : double;
    speed : double;
  end;

  TJSPosition = record
    coords : TJSCoordinates;
    timestamp : String;
  end;

  TJSGeoLocationCallback = procedure (aPosition : TJSPosition);
  TJSGeoLocationEvent = procedure (aPosition : TJSPosition) of object;
  TJSGeoLocationErrorCallback = procedure (aValue : TJSPositionError);
  TJSGeoLocationErrorEvent = procedure (aValue : TJSPositionError) of object;

  TJSGeoLocation  = class external name 'GeoLocation'
  Public
    Procedure getCurrentPosition(ASuccess : TJSGeoLocationCallback); overload;
    Procedure getCurrentPosition(ASuccess : TJSGeoLocationCallback;aError : TJSGeoLocationErrorCallback); overload;
    Procedure getCurrentPosition(ASuccess : TJSGeoLocationCallback;aError : TJSGeoLocationErrorCallback; AOptions : TJSPositionOptions); overload;
    Function watchPosition(ASuccess : TJSGeoLocationCallback) : NativeInt; overload;
    Function watchPosition(ASuccess : TJSGeoLocationCallback;aError : TJSGeoLocationErrorCallback) : NativeInt; overload;
    Function watchPosition(ASuccess : TJSGeoLocationCallback;aError : TJSGeoLocationErrorCallback; AOptions : TJSPositionOptions) : NativeInt; overload;
    procedure clearWatch(AID : NativeInt);
  end;

  TJSMediaDevices = class external name 'MediaDevices' (TJSEventTarget)
  end;

  TJSWorker = class external name 'Worker' (TJSEventTarget)
  public
    constructor new(aURL : string);
    procedure postMessage(aValue : JSValue);
    procedure postMessage(aValue : JSValue; aList : TJSValueDynArray);
    procedure terminate;
  end;

  TJSMessagePort = class external name 'MessagePort' (TJSEventTarget)
  Public
    procedure close;
    procedure postMessage(aValue : JSValue);
    procedure postMessage(aValue : JSValue; aList : TJSValueDynArray);
    procedure start;
  end;

  { TJSSharedWorker }

  TJSSharedWorker = class external name 'SharedWorker' (TJSEventTarget)
  private
    FPort: TJSMessagePort; external name 'port';
  Public
    constructor new(aURL : String); overload;
    constructor new(aURL : String; aName : string); overload;
    property port : TJSMessagePort Read FPort;
  end;

  { TJSServiceWorker }

  TJSServiceWorker = class external name 'ServiceWorker' (TJSWorker)
  private
    FscriptURL: String;  external name 'scriptURL';
    FState: string;  external name 'state';
  Public
    property state : string read FState;
    property scriptURL : String Read FscriptURL;
  end;

  { TJSServiceWorkerRegistration }

  TJSServiceWorkerRegistration = class external name 'ServiceWorkerRegistration'
  private
    FActive: TJSServiceWorker; external name 'active';
    FInstalling: TJSServiceWorker; external name 'installing';
    FScope: string; external name 'scope';
    FWaiting: TJSServiceWorker; external name 'waiting';
  public
    function unregister : TJSPromise;
    procedure update;
    property active : TJSServiceWorker read FActive;
    property scope : string read FScope;
    property waiting : TJSServiceWorker read FWaiting;
    property installing : TJSServiceWorker read FInstalling;
  end;

  TJSServiceWorkerContainerOptions = record
    scope : string;
  end;

  { TJSServiceWorkerContainer }

  TJSServiceWorkerContainer = class external name 'ServiceWorkerContainer'
  private
    FController: TJSServiceWorker; external name 'controller';
    FReady: TJSPromise; external name 'ready';
  Public
    function register(aURL : String) : TJSPromise; overload;
    function register(aURL : String; aOptions : TJSServiceWorkerContainerOptions) : TJSPromise; overload;
    function getRegistration(aURL : String) : TJSPromise; overload;
    function getRegistration : TJSPromise; overload;
    function getRegistrations : TJSPromise;
    property controller : TJSServiceWorker read FController;
    property ready : TJSPromise read FReady;
  end;


  { TJSNavigator }

  TJSNavigator = class external name 'Navigator'
{$IFDEF FIREFOX}
    FbuildID : String ; external name 'buildID';
    FOSCPU : String ; external name 'oscpu';
    FproductSub : string; external name 'productSub';
    FVendor : string; external name 'vendor';
{$ENDIF}
  private
    FCookieEnabled: Boolean; external name 'cookieEnabled';
    FGeoLocation: TJSGeoLocation; external name 'geolocation';
    FLanguage: String; external name 'language';
    FMaxTouchPoints: NativeInt; external name 'maxTouchPoints';
    FMediaDevices: TJSMediaDevices; external name 'mediaDevices';
    FOnline: boolean; external name 'onLine';
    FPlatform: string; external name 'platform';
    FServiceWorker: TJSServiceWorkerContainer; external name 'serviceWorker';
    FUserAgent: string; external name 'userAgent';
  public
    function getBattery : TJSPromise;
    function requestMediaKeySystemAccess(aKeySystem : String; supportedConfigurations : TJSValueDynArray) : TJSPromise;
    Procedure registerContentHandler(aMimeType,aURI,aTitle : string);
    Procedure registerProtocolHandler(aProtocol,aURI,aTitle : string);
    Procedure vibrate(aPattern : NativeInt);
    Procedure vibrate(aPattern : Array of NativeInt);
{$IFDEF FIREFOX}
    property buildID : String read FBuildID;
    property oscpu : string read FOSCPU;
    property productSub: string read FproductSub;
    property vendor : string read Fvendor;
{$ENDIF}
    property cookieEnabled : Boolean read FCookieEnabled;
    property geoLocation : TJSGeoLocation Read FGeoLocation;
    property language : String read FLanguage;
    property maxTouchPoints : NativeInt read FMaxTouchPoints;
    property mediaDevices : TJSMediaDevices read FMediaDevices;
    property onLine : boolean read FOnline;
    property platform : string read FPlatform;
    property userAgent : string read FUserAgent;
    property serviceWorker : TJSServiceWorkerContainer read FServiceWorker;
  end;

  { TJSTouchEvent }
  TTouchCoord = longint;

  TJSTouch = class external name 'Touch'
  private
    FClientX: TTouchCoord; external name 'clientX';
    FClientY: TTouchCoord; external name 'clientY';
    FIDentifier: longint; external name 'identifier';
    FPageX: TTouchCoord; external name 'pageX';
    FPageY: TTouchCoord; external name 'pageY';
    FScreenX: TTouchCoord; external name 'screenX';
    FScreenY: TTouchCoord; external name 'screenY';
    FTarget: TJSElement; external name 'target';
  Public
    Property identifier : longint read FIDentifier;
    Property ScreenX : TTouchCoord Read FScreenX;
    Property ScreenY : TTouchCoord Read FScreenY;
    Property ClientX : TTouchCoord Read FClientX;
    Property ClientY : TTouchCoord Read FClientY;
    Property PageX : TTouchCoord Read FPageX;
    Property PageY : TTouchCoord Read FPageY;
    Property Target : TJSElement Read FTarget;
  end;

  { TJSTouchList }

  TJSTouchList = class external name 'TouchList'
  private
    FLength: NativeInt; external name 'length';
  Public
    function item (aIndex : Integer) : TJSTouch;
    property length : NativeInt Read FLength;
    Property Touches[AIndex : Integer] : TJSTouch Read item; default;
  end;


  TJSPerformance = class external name 'Performance' (TJSObject);

  TJSScreen = class external name 'Screen' (TJSObject);

  TJSURL = class external name 'URL' (TJSObject);
  
  TJSCSSStyleDeclaration = class; // forward

  TJSTimerCallBack = reference to procedure;

  { TJSMediaQueryList }

  TJSMediaQueryList = class external name 'MediaQueryList' (TJSObject)
  private
    FMatches: Boolean; external name 'matches';
    FMedia: String; external name 'media';
  Public
    Property matches : Boolean Read FMatches;
    Property media : String Read FMedia;
  end;

  { TJSWindow }

  TJSWindowArray = Array of TJSWindow;
  TJSWindow = class external name 'Window' (TJSObject)
  Private
    FClosed: boolean; external name 'closed';
    FConsole : TJSConsole;  external name 'console';
    FCrypto: TJSCrypto; external name 'crypto';
    FDevicePixelRatio: Double; external name 'devicePixelRatio';
    FDocument: TJSDocument; external name 'document';
    FFrameElement: TJSElement; external name 'frameElement';
    FFrames: TJSWindowArray; external name 'frames';
    FHistory: TJSHistory; external name 'history';
    FIndexedDB: TJSIDBFactory; external name 'indexedDB';
    FInnerheight: NativeInt; external name 'innerHeight';
    FInnerWidth: NativeInt; external name 'innerWidth';
    FLength: NativeInt; external name 'length';
    FLocalStorage: TJSStorage; external name 'localStorage';
    FLocation: TJSLocation; external name 'location';
    FLocationBar: TJSLocationBar; external name 'locationbar';
    FLocationString: string; external name 'location';
    FMenuBar: TJSMenuBar; external name 'menubar';
    FNavigator: TJSNavigator; external name 'navigator';
    FOpener: TJSWindow; external name 'opener';
    FOuterheight: NativeInt; external name 'outerHeight';
    FOuterWidth: NativeInt; external name 'outerWidth';
    FParent: TJSWindow; external name 'parent';
    FPerformance: TJSPerformance; external name 'Performance';
    FPersonalBar: TJSPersonalBar; external name 'personalbar';
    FScreen: TJSScreen; external name 'screen';
    FScreenX: NativeInt; external name 'screenX';
    FScreenY: NativeInt; external name 'screenY';
    FScrollbar: TJSScrollBars; external name 'scrollbar';
    FScrollX: NativeInt; external name 'scrollX';
    FScrollY: NativeInt; external name 'scrollY';
    FSelf: TJSWindow; external name 'self';
    FSessionStorage: TJSStorage; external name 'sessionStorage';
    FToolBar: TJSToolBar; external name 'toolbar';
    FTop: TJSWindow; external name 'top';
    FURL: TJSURL; external name 'URL';
  Public
    fullSreen : Boolean;   
    name : string;
    status : string;
    onabort : TJSEventHandler;
    onafterprint : TJSEventHandler;
    onbeforeprint : TJSEventHandler;
    onbeforeinstallprompt : TJSEventHandler;
    onbeforeunloadprompt : TJSEventHandler;
    onblur : TJSEventHandler;
    onchange : TJSEventHandler;
    onclick: THTMLClickEventHandler;
    onclose : TJSEventHandler;
    oncontextmenu : TJSEventHandler;
    ondblclick : THTMLClickEventHandler;
    onerror : TJSErrorEventHandler;
    onfocus : TJSFocusEventhandler;
    onhashchange : TJSHashChangeEventhandler;
    oninput : TJSEventhandler;
    onkeydown : TJSKeyEventhandler;
    onkeypress : TJSKeyEventhandler;
    onkeyup : TJSKeyEventhandler;
    onlanguagechange : TJSEventhandler;
    onload : TJSEventhandler;
    onloadend : TJSLoadEventhandler;
    onloadstart : TJSLoadEventhandler;
    onmessage : TJSEventHandler;
    onmousedown : TJSMouseEventHandler;
    onmouseenter : TJSMouseEventHandler;
    onmouseleave : TJSMouseEventHandler;
    onmousemove : TJSMouseEventHandler;
    onmouseout : TJSMouseEventHandler;
    onmouseover : TJSMouseEventHandler;
    onmouseup : TJSMouseEventHandler;
    onmousewheel : TJSMouseEventHandler;
    onoffline : TJSEventHandler;
    ononline : TJSEventHandler;
    onpagehide : TJSPageTransitionEventHandler;
    onpageshow : TJSPageTransitionEventHandler;
    onpaint : TJSEventHandler;
    onpointercancel : TJSPointerEventHandler;
    onpointerdown : TJSPointerEventHandler;
    onpointerenter : TJSPointerEventHandler;
    onpointerleave : TJSPointerEventHandler;
    onpointermove : TJSPointerEventHandler;
    onpointerout : TJSPointerEventHandler;
    onpointerover : TJSPointerEventHandler;
    onpointerup : TJSPointerEventHandler;
    onpointerlockchange : TJSPointerEventHandler;
    onprogress : TJSProgressEventhandler;
    onpopstate : TJSPopStateEventHandler;
    onreset : TJSUIEventHandler;
    onscroll : TJSUIEventHandler;
    onselect : TJSEventHandler;
    onselectionchange : TJSEventHandler;
    onstorage : TJSStorageEventHandler;
    onsubmit : TJSEventHandler;
    onunload : TJSUIEventHandler;
    touchstart : TJSTouchEventHandler;
    touchend : TJSTouchEventHandler;
    touchmove : TJSTouchEventHandler;
    touchcancel : TJSTouchEventHandler;
    Procedure alert(Const Msg : String);
    Function atob(Const aValue : string) : string;
    procedure blur;
    Procedure clearInterval(aID: NativeInt);
    Procedure clearTimeout(aID: NativeInt);
    Function btoa(Const aValue : string) : string;
    Procedure close;
    Function confirm(Const aMsg : String) :  boolean;
    procedure focus;
    Function getComputedStyle(aElement : TJSElement) : TJSCSSStyleDeclaration; overload;
    Function getComputedStyle(aElement,aPseudoElement : TJSElement) : TJSCSSStyleDeclaration; overload;
    function matchMedia(aQuery : String) : TJSMediaQueryList;
    procedure moveBy(x,y : NativeInt);
    procedure moveTo(x,y : NativeInt);
    function open : TJSWindow;
    function open(Const aURL : String) : TJSWindow; overload;
    function open(Const aURL,aTarget : String) : TJSWindow; overload;
    function open(Const aURL,aTarget : String; AOptions : TJSObject) : TJSWindow; overload;
    procedure print;
    function prompt(const aMessage : String) : String; overload;
    function prompt(const aMessage,aDefault : String) : String; overload;
    procedure resizeBy(aWidth,aHeight : NativeInt);
    procedure resizeTo(aWidth,aHeight : NativeInt);
    procedure scrollBy(x,y : NativeInt);
    procedure scrollTo(x,y : NativeInt);
    Function setInterval(ahandler : TJSTimerCallBack; aInterval : NativeUInt) : NativeInt; varargs;
    Function setTimeout(ahandler : TJSTimerCallBack; aTimeout : NativeUInt) : NativeInt; varargs;
    procedure stop;

    property console : TJSConsole Read FConsole;
    property closed : boolean read FClosed;
    property crypto : TJSCrypto Read FCrypto;
    property devicePixelRatio : Double read FDevicePixelRatio;
    property document : TJSDocument read FDocument;
    property frameElement : TJSElement Read FFrameElement;
    Property frames  : TJSWindowArray read FFrames;
    Property history : TJSHistory read FHistory;
    Property indexedDB : TJSIDBFactory read FIndexedDB;
    Property innerHeight : NativeInt Read FInnerheight;
    Property innerWidth : NativeInt Read FInnerWidth;
    Property length : NativeInt Read FLength;
    Property localStorage : TJSStorage Read FLocalStorage; 
    property location : TJSLocation Read FLocation;
    Property locationString : String read FLocationString write FLocationString;
    property locationbar : TJSLocationBar Read FLocationBar;
    property menubar : TJSMenuBar Read FMenuBar;
    property navigator : TJSNavigator Read FNavigator;
    property opener : TJSWindow read FOpener;
    Property outerHeight : NativeInt Read FOuterheight;
    Property outerWidth : NativeInt Read FOuterWidth;
    Property parent : TJSWindow Read FParent;
    Property Performance : TJSPerformance Read FPerformance;
    property personalbar : TJSPersonalBar Read FPersonalBar;
    property screen : TJSScreen read FScreen;
    property screenX : NativeInt read FScreenX;
    Property screenY : NativeInt read FScreenY;
    Property scrollbar : TJSScrollBars Read FScrollbar;
    property scrollX : NativeInt read FScrollX;
    Property scrollY : NativeInt read FScrollY;
    Property _Self : TJSWindow read FSelf;
    Property sessionStorage : TJSStorage Read FSessionStorage; 
    property toolbar : TJSToolBar Read FToolBar;
    property top : TJSWindow Read FTop;
    property URL : TJSURL Read FURL; 
  end;

  { TJSCSSStyleDeclaration }

  TJSCSSStyleDeclaration = class external name 'CSSStyleDeclaration'
  private
    FLength: NativeInt; external name 'length';
    FParentRule: TJSCSSRule; external name 'parentRule';

  public
    cssText : string;
    function item(aIndex : Integer) : string;
    function removeProperty(const aProperty : String) : string;
    function getPropertyPriority(const aProperty : String) : string;
    function getPropertyValue(const aProperty : String) : string;
    procedure setProperty(const aProperty,aValue : String);overload;
    procedure setProperty(const aProperty,aValue,aPriority : string); overload;
    property length : NativeInt read FLength;
    property parentRule : TJSCSSRule read FParentRule;
  end;





  { TJSHTMLElement }
  TJSHTMLElement = class external name 'HTMLELement' (TJSElement)
  private
    FDataset: TJSObject ; external name 'dataset';
    FIsContentEditable: Boolean ; external name 'isContentEditable';
    FOffsetHeight: Double; external name 'offsetHeight';
    FOffsetLeft: Double; external name 'offsetLeft';
    FOffsetParent: TJSElement; external name 'offsetParent';
    FOffsetTop: Double; external name 'offsetTop';
    FOffsetWidth: Double; external name 'offsetWidth';
  Public
    accessKey : string;
    contentEditable : string;
    dir : string;
    draggable : boolean;
    hidden : boolean;
    lang : string;
    spellcheck : boolean;
    style : TJSCSSStyleDeclaration;
    tabIndex : Integer;
    title: string;
    onabort : TJSEventHandler;
    onanimationcancel: THTMLAnimationEventHandler;
    onanimationend: THTMLAnimationEventHandler;
    onblur : TJSEventHandler;
    oncancel : TJSEventHandler;
    oncanplay : TJSEventHandler;
    oncanplaythrough : TJSEventHandler;
    onchange : TJSEventHandler;
    onclick: THTMLClickEventHandler;
    onclose : TJSEventHandler;
    oncontextmenu : TJSEventHandler;
    ondblclick : THTMLClickEventHandler;
    ondrag : TJSDragDropEventHandler;
    ondragend : TJSDragDropEventHandler;
    ondragenter : TJSDragDropEventHandler;
    ondragexit : TJSDragDropEventHandler;
    ondragover : TJSDragDropEventHandler;
    ondragleave : TJSDragDropEventHandler;
    ondragstart: TJSDragDropEventHandler;
    ondrop : TJSDragDropEventHandler;
    onerror : TJSErrorEventHandler;
    onfocus : TJSFocusEventhandler;
    ondurationchange : TJSEventHandler;
    onemptied : TJSEventHandler;
    onended : TJSEventHandler;
    ongotpointercapture : TJSPointerEventHandler;
    oninput : TJSEventhandler;
    oninvalid : TJSEventhandler;
    onkeydown : TJSKeyEventhandler;
    onkeypress : TJSKeyEventhandler;
    onkeyup : TJSKeyEventhandler;
    onload : TJSEventhandler;
    onloadeddata : TJSEventhandler;
    onloadedmetadata : TJSEventhandler;
    onloadend : TJSLoadEventhandler;
    onloadstart : TJSLoadEventhandler;
    onlostpointercapture : TJSPointerEventHandler;
    onmousedown : TJSMouseEventHandler;
    onmouseenter : TJSMouseEventHandler;
    onmouseleave : TJSMouseEventHandler;
    onmousemove : TJSMouseEventHandler;
    onmouseout : TJSMouseEventHandler;
    onmouseover : TJSMouseEventHandler;
    onmouseup : TJSMouseEventHandler;
    onmousewheel : TJSMouseEventHandler;
    onpause : TJSPointerEventHandler;
    onplay : TJSPointerEventHandler;
    onplaying : TJSPointerEventHandler;
    onpointercancel : TJSPointerEventHandler;
    onpointerdown : TJSPointerEventHandler;
    onpointerenter : TJSPointerEventHandler;
    onpointerleave : TJSPointerEventHandler;
    onpointermove : TJSPointerEventHandler;
    onpointerout : TJSPointerEventHandler;
    onpointerover : TJSPointerEventHandler;
    onpointerup : TJSPointerEventHandler;
    onpointerlockchange : TJSPointerEventHandler;
    onprogress : TJSProgressEventhandler;
    onseeked : TJSEventHandler;
    onseeking : TJSEventHandler;
    onreset : TJSUIEventHandler;
    onscroll : TJSUIEventHandler;
    onselect : TJSEventHandler;
    onselectstart : TJSEventHandler;
    onselectionchange : TJSEventHandler;
    onshow : TJSEventHandler;
    onstalled : TJSEventHandler;
    ontimeupdate : TJSEventHandler;
    ontransitioncancel : TJSEventHandler;
    ontransitionend : TJSEventHandler;
    onvolumechange : TJSEventHandler;
    onsubmit : TJSEventHandler;
    onwheel : TJSMouseWheelEventHandler;
    onwaiting : TJSEventHandler;
    touchstart : TJSTouchEventHandler;
    touchend : TJSTouchEventHandler;
    touchmove : TJSTouchEventHandler;
    touchcancel : TJSTouchEventHandler;
    Procedure blur;
    Procedure focus;
    Procedure click;
    property dataset : TJSObject read FDataset;
    property isContentEditable : Boolean read FIsContentEditable;
    property offsetHeight : Double Read FOffsetHeight;
    property offsetLeft : Double Read FOffsetLeft;
    property offsetTop : Double Read FOffsetTop;
    property offsetWidth : Double Read FOffsetWidth;
    property offsetParent : TJSElement Read FOffsetParent;
  end;

  TJSHTMLFormControlsCollection = class external name 'HTMLFormControlsCollection' (TJSHTMLCollection)
  Public
    function namedItem(S : String) : TJSElement; reintroduce; external name 'namedItem';
    property Items[S : String] : TJSElement read namedItem; default;
  end;

  { TJSHTMLFormElement }

  TJSHTMLFormElement = class external name 'HTMLFormElement' (TJSHTMLElement)
  private
    FElements: TJSHTMLFormControlsCollection; external name 'elements';
    FLength: NativeInt; external name 'length';
  Public
    method : string;
    target : string;
    action : string;
    encoding : string;
    enctype : string;
    acceptCharset :  string;
    autocomplete : string;
    noValidate : boolean;
    property elements : TJSHTMLFormControlsCollection read FElements;
    Property length : NativeInt Read FLength;
  end;

  { TJSValidityState }

  TJSValidityState = class external name 'ValidityState'
  private
    FBadInput: Boolean; external name 'badInput';
    FCustomError: Boolean; external name 'customError';
    FPatternMismatch: Boolean; external name 'patternMisMatch';
    FRangeOverflow: Boolean; external name 'rangeOverflow';
    FRangeUnderflow: Boolean; external name 'rangeUnderflow';
    FStepMismatch: Boolean; external name 'stepMismatch';
    FTooLong: Boolean; external name 'tooLong';
    FTooShort: Boolean; external name 'tooShort';
    FTypeMismatch: Boolean; external name 'typeMisMatch';
    FValid: Boolean; external name 'valid';
    FValueMissing: Boolean; external name 'valueMissing';
  public
    property badInput : Boolean read FBadInput;
    property customError : Boolean read FCustomError;
    property patternMisMatch : Boolean read FPatternMismatch;
    property rangeOverflow : Boolean read FRangeOverflow;
    property rangeUnderflow : Boolean read FRangeUnderflow;
    property stepMismatch : Boolean read FStepMismatch;
    property tooLong : Boolean read FTooLong;
    property tooShort : Boolean read FTooShort;
    property typeMisMatch : Boolean read FTypeMismatch;
    property valid : Boolean Read FValid;
    property valueMissing : Boolean read FValueMissing;
  end;

  { TJSBlob }

  TJSBlob = class external name 'Blob' (TJSEventTarget)
  private
    FSize: NativeInt; external name 'size';
    FType: string; external name  'type';
  Public
    procedure close;
    function slice : TJSBlob; overload;
    function slice(aStart : NativeInt) : TJSBlob; overload;
    function slice(aStart,aEnd : NativeInt) : TJSBlob; overload;
    function slice(aStart,aEnd : NativeInt; AContentType : String) : TJSBlob; overload;
    property size : NativeInt read FSize;
    property _type : string read FType;
  end;


  { TJSHTMLFile }

  TJSHTMLFile = class external name 'File' (TJSBlob)
  private
    FLastModified: NativeInt; external name 'lastModified';
    FLastModifiedDate: TJSDate; external name 'lastModifiedDate';
    FName: string; external name 'name';
  Public
    property name : string read FName;
    property lastModified : NativeInt read FLastModified;
    property lastModifiedDate : TJSDate read FLastModifiedDate;
  end;

  { TJSHTMLFileList }

  TJSHTMLFileList = class external name 'FileList' (TJSEventTarget)
  private
    FLength: NativeInt; external name 'length';
  Public
    function item(aIndex : NativeInt) : TJSHTMLFile;
    property length : NativeInt read FLength;
    property Files[aIndex : NativeInt] : TJSHTMLFile Read item; default;
  end;

   { TJSHTMLInputElement }
  // https://html.spec.whatwg.org/multipage/forms.html#the-input-element

  TJSHTMLInputElement = class external name 'HTMLInputElement' (TJSHTMLElement)
  private
    FFiles: TJSHTMLFileList; external name 'files';
    FForm: TJSHTMLFormElement; external name 'form';
    FLabels: TJSNodeList; external name 'labels';
    FList: TJSHTMLElement; external name 'list';
    FValidationmMessage: string; external name 'validationMessage';
    FValidity: TJSValidityState; external name 'validity';
    FWillValidate: boolean; external name 'willValidate';
  Public
    procedure select;
    procedure setCustomValidity(aText : string);
    procedure stepUp; overload;
    procedure stepUp(n : Integer); overload;
    function checkValidity : Boolean;
    function reportValidity : Boolean;
    procedure setSelectionRange(selectionStart, selectionEnd: NativeInt) ; overload;
    procedure setSelectionRange(selectionStart, selectionEnd: NativeInt; Direction : string) ; overload;
    procedure setRangeText(aText : string; selectionStart, selectionEnd: NativeInt) ; overload;
    procedure setRangeText(aText : string; selectionStart, selectionEnd: NativeInt; Direction : string) ; overload;
  Public
    accept : string;
    allowDirs : boolean;
    align : string;
    alt : string;
    autofocus : boolean;
    autocapitalize : string;
    autocomplete : string;
    defaultValue : string;
    defaultChecked : string;
    checked : boolean;
    dirName : string;
    disabled : boolean;
    formAction : string;
    formEncType : string;
    formMethod : string;
    formNoValidate : Boolean;
    formTarget : string;
    height : Boolean;
    indeterminate : boolean;
    inputMode : string;
    max : string;
    maxLength : NativeInt;
    min : string;
    minLength : NativeInt;
    multiple : boolean;
    pattern : string;
    placeholder : string;
    readOnly : boolean;
    required : boolean;
    size : NativeInt;
    src : string;
    step : string;
    _type : string; external name 'type';
    selectionStart : NativeInt;
    selectionEnd : NativeInt;
    selectionDirection : string;
    useMap : string;
    value : string;
    width : NativeInt;
    property files : TJSHTMLFileList Read FFiles;
    property form : TJSHTMLFormElement read FForm;
    property labels : TJSNodeList read FLabels;
    property list : TJSHTMLElement Read FList;
    property validationMessage : string read FValidationmMessage;
    property willValidate : boolean read FWillValidate;
    property validity : TJSValidityState read FValidity;
  end;

  { TJSHTMLOptionElement }

  TJSHTMLOptionElement = class external name 'Option' (TJSHTMLElement)
  private
    FForm: TJSHTMLFormElement; external name 'form';
    FIndex: NativeInt; external name 'index';
  Public
    Constructor New; overload;
    Constructor New(aText : String); overload;
    Constructor New(aText,aValue : String); overload;
    Constructor New(aText,aValue : String; aDefaultSelected : Boolean); overload;
    Constructor New(aText,aValue : String; aDefaultSelected,Selected : Boolean); overload;
  Public
    defaultSelected : boolean;
    disabled : boolean;
    _label : string ; external name 'label';
    selected : boolean;
    text : string;
    value : string;
    property index : NativeInt Read FIndex;
    property form : TJSHTMLFormElement Read FForm;
  end;

  TJSHTMLOptGroupElement = class external name 'HTMLOptGroupElement' (TJSHTMLElement)
  end;

  TJSHTMLOptionsCollection = class external name 'HTMLOptionsCollection' (TJSHTMLCollection)
  end;

  { TJSHTMLSelectElement }

  TJSHTMLSelectElement = Class external name 'HTMLSelectElement' (TJSHTMLElement)
  private
    FForm: TJSHTMLFormElement; external name 'form';
    FLabels: TJSNodeList; external name 'labels';
    FLength: NativeInt; external name 'length';
    FOptions: TJSHTMLOptionsCollection; external name 'options';
    FSelectedOptions: TJSHTMLCollection; external name 'selectedOptions';
    FType: String; external name 'type';
    FValidationMessage: string; external name 'validationMessage';
    FValidity: TJSValidityState; external name 'validity';
    fwillValidate: Boolean; external name 'willValidate';
  Public
    Procedure add(anItem : TJSHTMLOptionElement); overload;
    Procedure add(anItem, before : TJSHTMLOptionElement); overload;
    function item(aIndex : NativeInt): TJSHTMLOptionElement;
    function namedItem(aName : String): TJSHTMLOptionElement;
    procedure remove(aIndex : NativeInt);
    procedure checkValidity;
    procedure setCustomValidity(aMessage : String);
  Public
    multiple : boolean;
    required: boolean;
    selectedIndex : NativeInt;
    size : NativeInt;
    value : string;
    property length : NativeInt read FLength;
    Property options : TJSHTMLOptionsCollection read FOptions;
    Property selectedOptions : TJSHTMLCollection read FSelectedOptions;
    Property form : TJSHTMLFormElement read FForm;
    property labels : TJSNodeList Read FLabels;
    property _type : String Read FType;
    property validity : TJSValidityState Read FValidity;
    property validationMessage : string Read FValidationMessage;
    property willValidate : Boolean read fwillValidate;
  end;


  TJSCanvasRenderingContext2D = Class;

  THTMLCanvasToBlobCallback = Reference to function (aBlob : TJSBlob) : boolean;

  TJSHTMLCanvasElement = Class external name 'HTMLCanvasElement' (TJSHTMLElement)
  Public
    height : integer;
    width : integer;
    Function getContext(contextType : string) : TJSObject;
    Function getContext(contextType : string; contextAttributes : TJSObject) : TJSObject;
    Function getContextAs2DContext(contextType : string; contextAttributes : TJSObject) : TJSCanvasRenderingContext2D; external name 'getContext';
    Function getContextAs2DContext(contextType : string) : TJSCanvasRenderingContext2D; external name 'getContext';
    Procedure toBlob (aCallBack : THTMLCanvasToBlobCallback; aMimeType : String); overload;
    Procedure toBlob (aCallBack : THTMLCanvasToBlobCallback; aMimeType : String; aQuality : Double); overload;
    Function toDataURL : String; overload;
    Function toDataURL(aMimeType : String) : String; overload;
    Function toDataURL(aMimeType : String; aQuality : Double) : String; overload;
  end;

  // Opaque objects
  TJSCanvasGradient = class external name 'CanvasGradient'
  end;

  TJSCanvasPattern = class external name 'CanvasPattern'
  end;

  TJSPath2D = class external name 'Path2D'
  end;

  { TJSImageData }

  TJSImageData = class external name 'ImageData'
  private
    FData: TJSUint8ClampedArray; external name 'data';
    FHeight: Integer; external name 'height';
    FWidth: Integer; external name 'width';
  Public
    constructor new(awidth,aheight : integer); overload;
    constructor new(anArray :TJSUint8ClampedArray; awidth,aheight : integer); overload;
    property data : TJSUint8ClampedArray read FData;
    property height : Integer Read FHeight;
    property width : Integer Read FWidth;
  end;

  TCanvasCoordType = double; // Is in fact a number.

  TJSTextMetrics = record
    width : TCanvasCoordType;
    actualBoundingBoxLeft : TCanvasCoordType;
    actualBoundingBoxRight : TCanvasCoordType;
    fontBoundingBoxAscent : TCanvasCoordType;
    fontBoundingBoxDescent : TCanvasCoordType;
    actualBoundingBoxAscent : TCanvasCoordType;
    actualBoundingBoxDescent : TCanvasCoordType;
    emHeightAscent : TCanvasCoordType;
    emHeightDescent : TCanvasCoordType;
    hangingBaseline : TCanvasCoordType;
    alphabeticBaseline : TCanvasCoordType;
    ideographicBaseline : TCanvasCoordType;
  end;

  { TJSCanvasRenderingContext2D }
  TJSCanvasRenderingContext2D = class external name 'CanvasRenderingContext2D'
  private
    FCanvas: TJSHTMLCanvasElement; external name 'canvas';
    FfillStyleColor: String; external name 'fillStyle';
    FfillStyleGradient: TJSCanvasGradient; external name 'fillStyle';
    FfillStylePattern: TJSCanvasPattern; external name 'fillStyle';
    FstrokeStyleColor: String; external name 'strokeStyle';
    FstrokeStyleGradient: TJSCanvasGradient; external name 'strokeStyle';
    FstrokeStylePattern: TJSCanvasPattern; external name 'strokeStyle';
  Public
    fillStyle : JSValue;
    font : string;
    globalAlpha : double;
    globalCompositeOperation : String;
    lineCap : string;
    lineDashOffset : Double;
    lineJoin : String;
    lineWidth : Double;
    miterLimit : Double;
    shadowBlur : Double;
    shadowColor : String;
    shadowOffsetX : Double;
    shadowOffsetY : Double;
    strokeStye : JSValue;
    textAlign : String;
    textBaseline : String;
    procedure arc(x,y, radius,startAngle,endAngle : TCanvasCoordType); overload;
    procedure arc(x,y, radius,startAngle,endAngle : TCanvasCoordType; antiClockWise : boolean); overload;
    procedure arcTo(x1,y1,x2,y2,radius : TCanvasCoordType); overload;
    procedure beginPath;
    procedure bezierCurveTo(cp1x,cp1y,cp2x,cp2y,x,y : TCanvasCoordType); overload;
    procedure clearRect(x,y,width,height : TCanvasCoordType);
    procedure clip; overload;
    procedure clip(aFillRule : String); overload;
    procedure clip(aPath : TJSPath2D); overload;
    procedure closePath;
    function createImageData(aWidth,aHeight : Integer) : TJSImageData; overload;
    function createImageData(aImage : TJSImageData) : TJSImageData; overload;
    function createLinearGradient(x0,y0,x1,y1 : TCanvasCoordType) : TJSCanvasGradient;
    function createPattern(aImage : TJSObject; repetition : string) : TJSCanvasPattern;
    function createRadialGradient(x0,y0,r0,x1,y1,r1 : TCanvasCoordType) : TJSCanvasGradient;
    procedure drawFocusIfNeeded(aElement : TJSElement); overload;
    procedure drawFocusIfNeeded(aPath : TJSPath2D; aElement : TJSElement); overload;
    procedure drawImage(image : TJSObject; dx,dy : TCanvasCoordType); overload;
    procedure drawImage(image : TJSObject; dx,dy,dwidth,dheight : TCanvasCoordType); overload;
    procedure drawImage(image : TJSObject; sx,sy,sWidth,sHeight,dx,dy,dwidth,dheight : TCanvasCoordType); overload;
    procedure fill; overload;
    procedure fill(aRule : String); overload;
    procedure fill(aPath : TJSPath2D); overload;
    procedure fill(aPath : TJSPath2D;aRule : String); overload;
    procedure fillRect(x,y,awidth,aheight: TCanvasCoordType); overload;
    procedure fillText(aText : string; x,y : TCanvasCoordType); overload;
    procedure fillText(aText : string; x,y, aMaxWidth : TCanvasCoordType); overload;
    function getImageData(x,y,awidth,aheight: TCanvasCoordType) : TJSImageData; overload;
    function getLineDash : TJSArray;
    function isPointInPath(x,y : TCanvasCoordType) : Boolean; overload;
    function isPointInPath(x,y : TCanvasCoordType; aFillRule : String) : Boolean; overload;
    function isPointInPath(aPath : TJSPath2D; x,y : TCanvasCoordType) : Boolean; overload;
    function isPointInPath(aPath : TJSPath2D; x,y : TCanvasCoordType; aFillRule : String) : Boolean; overload;
    function isPointInStroke(x,y : TCanvasCoordType) : Boolean; overload;
    function isPointInStroke(aPath : TJSPath2D; x,y : TCanvasCoordType) : Boolean; overload;
    procedure lineTo(x,y : TCanvasCoordType);
    function measureText(S : String) : TJSTextMetrics;
    procedure moveTo(x,y : TCanvasCoordType);
    procedure putImageData(aData : TJSImageData; x,y: TCanvasCoordType) ; overload;
    procedure putImageData(aData : TJSImageData; x,y,dityX,dirtyY,dirtyWidth,dirtyHeight: TCanvasCoordType) ; overload;
    procedure quadraticCurveTo(cpx,cpy,x,y : TCanvasCoordType);
    procedure rect(x,y,awidth,aheight: TCanvasCoordType); overload;
    procedure restore;
    procedure rotate(anAngle : double);
    procedure save;
    procedure scale(x,y : double);
    procedure setLineDash(segments : TJSArray); overload;
    procedure setLineDash(segments : array of integer); overload;
    procedure setTransform(a,b,c,d,e,f : double);
    procedure stroke; overload;
    procedure stroke(aPath : TJSPath2D); overload;
    procedure strokeRect(x,y,awidth,aheight: TCanvasCoordType);
    procedure strokeText(aText : string; x,y : TCanvasCoordType); overload;
    procedure strokeText(aText : string; x,y, aMaxWidth : TCanvasCoordType); overload;
    procedure transform(a,b,c,d,e,f : double);
    procedure translate(x,y : TCanvasCoordType);

    property canvas : TJSHTMLCanvasElement Read FCanvas;
    property fillStyleAsColor : String Read FfillStyleColor Write FfillStyleColor;
    property fillStyleAsGradient : TJSCanvasGradient Read FfillStyleGradient Write FfillStyleGradient;
    property fillStyleAsPattern : TJSCanvasPattern Read FfillStylePattern Write FfillStylePattern;
    property strokeStyleAsColor : String Read FstrokeStyleColor Write FstrokeStyleColor;
    property strokeStyleAsGradient : TJSCanvasGradient Read FstrokeStyleGradient Write FstrokeStyleGradient;
    property strokeStyleAsPattern : TJSCanvasPattern Read FstrokeStylePattern Write FstrokeStylePattern;
  end;

  { TJSHTMLIFrameElement }

  TJSHTMLIFrameElement = Class external name 'HTMLIFrameElement' (TJSHTMLElement)
  private
    FAllowPaymentRequest: Boolean; external name 'allowPaymentRequest';
    FContentDocument: TJSDocument; external name 'contentDocument';
    FContentWindow: TJSWindow; external name 'contentWindow';
    FSandbox: string; external name 'sandbox';
  Public
    height : string;
    src : string;
    srcdoc : string;
    width : string;
    Property allowPaymentRequest : Boolean Read FAllowPaymentRequest;
    property contentWindow : TJSWindow Read FContentWindow;
    property contentDocument : TJSDocument Read FContentDocument;
    property sandbox : string read FSandbox;
  end;

  TJSXMLHttpRequestEventTarget = class external name 'XMLHttpRequestEventTarget' (TJSEventTarget)
  end;

  TJSXMLHttpRequestUpload = class external name 'XMLHttpRequestUpload' (TJSXMLHttpRequestEventTarget)
  end;

  { TJSXMLHttpRequest }
  TJSOnReadyStateChangeHandler = reference to procedure;

  TJSXMLHttpRequest = class external name 'XMLHttpRequest' (TJSXMLHttpRequestEventTarget)
  private
    FReadyState: NativeInt; external name 'readyState';
    FResponse: JSValue; external name 'response';
    FResponseText: string; external name 'responseText';
    FResponseType: string; external name 'responseType';
    FresponseURL: string; external name 'responseURL';
    FresponseXML: TJSDocument; external name 'responseXML';
    FUpload: TJSXMLHttpRequestUpload; external name 'upload';
    FStatus : integer; external name 'status';
    FStatusText : string; external name 'statusText';
  public
    const
      UNSENT           = 0;
      OPENED           = 1;
      HEADERS_RECEIVED = 3;
      LOADING          = 3;
      DONE             = 4;
  public
    timeout : LongWord;
    withCredentials : Boolean;
    onreadystatechange : TJSOnReadyStateChangeHandler;
    constructor new;
    procedure abort;
    function getResponseHeader(aName : string) : String;
    function getAllResponseHeaders : String;
    procedure open(aMethod,aURL : String); overload;
    procedure open(aMethod,aURL : String; Async : Boolean); overload;
    procedure open(aMethod,aURL : String; Async : Boolean; AUserame : String); overload;
    procedure open(aMethod,aURL : String; Async : Boolean; AUserame,APassword : String); overload;
    procedure overrideMimeType(aType : String);
    procedure send(aBody : jsValue);overload;
    procedure send;overload;
    procedure setRequestHeader(aName, AValue : string);

    property readyState : NativeInt read FReadyState;
    property ResponseHeaders[aName : string] : string Read getResponseHeader;
    property responseXML : TJSDocument read FresponseXML;
    property responseURL : string read FresponseURL;
    property responseType : string read FResponseType;
    property response : JSValue Read FResponse;
    property responseText : string read FResponseText;
    property Status : integer read FStatus;
    property StatusText : string read FStatusText;
    property upload : TJSXMLHttpRequestUpload read FUpload;

  end;

  { TJSUIEvent }

  TJSUIEvent = class external name 'UIEvent' (TJSEvent)
  private
    FDetail: NativeInt; external name 'detail';
    FView: TJSWindow; external name 'view';
  Public
    property detail : NativeInt read FDetail;
    property view : TJSWindow read FView;
  end;

  { TJSMouseEvent }

  TJSMouseEvent = class external name 'MouseEvent' (TJSUIevent)
  private
    FAltKey: Boolean; external name 'altKey';
    FBUtton: NativeInt; external name 'button';
    FBUttons: NativeInt; external name 'buttons';
    FClientX: Double; external name 'clientX';
    FClientY: Double; external name 'clientY';
    FCtrlKey: Boolean; external name 'ctrlKey';
    FMetaKey: Boolean; external name 'metaKey';
    FmovementX: Double; external name 'movementX';
    FmovementY: Double; external name 'movementY';
    FoffsetX: Double; external name 'offsetX';
    FoffsetY: Double; external name 'offsetY';
    FRegion: String; external name 'region';
    FRelatedTarget: TJSEventTarget; external name 'relatedTarget';
    FscreenX: Double; external name 'screenX';
    FscreenY: Double; external name 'screenY';
    FShiftKey: Boolean; external name 'shiftKey';
  Public
    Property altKey : Boolean read FAltKey;
    Property button: NativeInt read FBUtton;
    Property buttons: NativeInt read FBUttons;
    property clientX : Double read FClientX;
    property clientY : Double read FClientY;
    property ctrlKey : Boolean read FCtrlKey;
    property metaKey : Boolean read FMetaKey;
    property movementX : Double read FmovementX;
    property movementY : Double read FmovementY;
    property offsetX : Double read FoffsetX;
    property offsetY : Double read FoffsetY;
{$IFDEF FIREFOX}
    property pageX : Double read FpageX;
    property pageY : Double read FpageY;
{$ENDIF}
    property region : String read FRegion;
    property relatedTarget : TJSEventTarget read FRelatedTarget;
    property screenX : Double read FscreenX;
    property screenY : Double read FscreenY;
    property shiftKey : Boolean read FShiftKey;
    property x : Double read FClientX;
    property y : Double read FClientY;
  end;

  { TJSWheelEvent }
  TJSWheelEventInit = record
    deltaX : Double;
    deltaY : Double;
    deltaZ : Double;
    deltaMode : NativeInt;
  end;

  TJSWheelEvent = class external name 'WheelEvent' (TJSMouseEvent)
  private
    FDeltaMode: NativeInt; external name 'deltaMode';
    FDeltaX: Double; external name 'deltaX';
    FDeltaY: Double; external name 'deltaY';
    FDeltaZ: Double; external name 'deltaZ';
  Public
    constructor new(atype : String); overload;
    constructor new(atype : String; aInit : TJSWheelEventInit); overload;
    Property deltaX : Double Read FDeltaX;
    Property deltaY : Double Read FDeltaY;
    Property deltaZ : Double Read FDeltaZ;
    Property deltaMode : NativeInt Read FDeltaMode;
  end;

  TJSPointerEvent = Class external name 'PointerEvent' (TJSMouseEvent);

  TJSTouchEvent = Class external name 'TouchEvent'(TJSUIEvent)
  private
    FAltKey: Boolean; external name 'altKey';
    FChangedTouches: TJSTouchList; external name 'changedTouches';
    FCtrlKey: Boolean; external name 'ctrlKey';
    FMetaKey: Boolean; external name 'metaKey';
    FShiftKey: Boolean; external name 'shiftKey';
    FTargetTouches: TJSTouchList; external name 'targetTouches';
    FTouches: TJSTouchList; external name 'touches';
  Public
    Property altKey : Boolean Read FAltKey;
    Property ctrlKey : Boolean Read FCtrlKey;
    Property metaKey : Boolean Read FMetaKey;
    Property shiftKey : Boolean Read FShiftKey;
    property changedTouches : TJSTouchList Read FChangedTouches;
    property touches : TJSTouchList Read FTouches;
    property targetTouches : TJSTouchList Read FTargetTouches;
  end;


  // Namespace for standard key names.
  // See list at https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
  TJSKeyNames = Class
  Const
    Alt = 'Alt';
    AltGraph = 'AltGraph';
    CapsLock = 'CapsLock';
    Control = 'Control';
    Fn = 'Fn';
    FnLock = 'FnLock';
    Hyper = 'Hyper';
    Meta = 'Meta';
    NumLock = 'NumLock';
    ScrollLock = 'ScrollLock';
    Shift = 'Shift';
    Super = 'Super';
    Symbol = 'Symbol';
    SymbolLock = 'SymbolLock';
    Enter = 'Enter';
    Tab = 'Tab';
    Space = ' ';
    ArrowDown = 'ArrowDown';
    ArrowLeft = 'ArrowLeft';
    ArrowRight = 'ArrowRight';
    ArrowUp = 'ArrowUp';
    _End = 'End';
    Home = 'Home';
    PageDown = 'PageDown';
    PageUp = 'PageUp';
    BackSpace = 'Backspace';
    Clear = 'Clear';
    Copy = 'Copy';
    CrSel = 'CrSel';
    Cut = 'Cut';
    Delete = 'Delete';
    EraseEof = 'EraseEof';
    ExSel = 'ExSel';
    Insert = 'Insert';
    Paste = 'Paste';
    Redo = 'Redo';
    Undo = 'Undo';
    Accept = 'Accept';
    Again = 'Again';
    Attn = 'Attn';
    Cancel = 'Cancel';
    ContextMenu = 'Contextmenu';
    Escape = 'Escape';
    Execute = 'Execute';
    Find = 'Find';
    Finish = 'Finish';
    Help = 'Help';
    Pause = 'Pause';
    Play = 'Play';
    Props = 'Props';
    Select = 'Select';
    ZoomIn = 'ZoomIn';
    ZoomOut = 'ZoomOut';
    BrightnessDown = 'BrightnessDown';
    BrightnessUp = 'BrightnessUp';
    Eject = 'Eject';
    LogOff = 'LogOff';
    Power = 'Power';
    PowerOff = 'PowerOff';
    PrintScreen = 'PrintScreen';
    Hibernate = 'Hibernate';
    Standby = 'Standby';
    WakeUp = 'WakeUp';
    AllCandidates = 'AllCandidates';
    Alphanumeric =  'Alphanumeric';
    CodeInput = 'CodeInput';
    Compose = 'Compose';
    Convert = 'Convert';
    Dead = 'Dead';
    FinalMode = 'FinalMode';
    GroupFirst = 'GroupFirst';
    GroupLast = 'GroupLast';
    GroupNext = 'GroupNext';
    GroupPrevious = 'GroupPrevious';
    ModelChange = 'ModelChange';
    NextCandidate = 'NextCandidate';
    NonConvert = 'NonConvert';
    PreviousCandidate = 'PreviousCandidate';
    Process = 'Process';
    SingleCandidate = 'SingleCandidate';
    HangulMode = 'HangulMode';
    HanjaMode = 'HanjaMode';
    JunjaMode = 'JunjaMode';
    Eisu = 'Eisu';
    Hankaku = 'Hankaku';
    Hiranga = 'Hiranga';
    HirangaKatakana = 'HirangaKatakana';
    KanaMode = 'KanaMode';
    Katakana = 'Katakana';
    Romaji = 'Romaji';
    Zenkaku = 'Zenkaku';
    ZenkakuHanaku = 'ZenkakuHanaku';
    F1 = 'F1';
    F2 = 'F2';
    F3 = 'F3';
    F4 = 'F4';
    F5 = 'F5';
    F6 = 'F6';
    F7 = 'F7';
    F8 = 'F8';
    F9 = 'F9';
    F10 = 'F10';
    F11 = 'F11';
    F12 = 'F12';
    F13 = 'F13';
    F14 = 'F14';
    F15 = 'F15';
    F16 = 'F16';
    F17 = 'F17';
    F18 = 'F18';
    F19 = 'F19';
    F20 = 'F20';
    Soft1 = 'Soft1';
    Soft2 = 'Soft2';
    Soft3 = 'Soft3';
    Soft4 = 'Soft4';
    Decimal = 'Decimal';
    Key11 = 'Key11';
    Key12 = 'Key12';
    Multiply = 'Multiply';
    Add = 'Add';
    NumClear = 'Clear';
    Divide = 'Divide';
    Subtract = 'Subtract';
    Separator = 'Separator';
    AppSwitch = 'AppSwitch';
    Call = 'Call';
    Camera = 'Camera';
    CameraFocus = 'CameraFocus';
    EndCall = 'EndCall';
    GoBack = 'GoBack';
    GoHome = 'GoHome';
    HeadsetHook = 'HeadsetHook';
    LastNumberRedial = 'LastNumberRedial';
    Notification = 'Notification';
    MannerMode = 'MannerMode';
    VoiceDial = 'VoiceDial';
    // TODO : Multimedia keys
    // TODO : Audio control keys
    // TODO : TV control keys
    // TODO : Media controller keys
    // TODO : Speech recognition keys
    // TODO : Document keys
    // TODO : Application selector keys
    // TODO : Browser Control keys
  end;


  { TJSKeyboardEvent }

  TJSKeyboardEvent = class external name 'KeyboardEvent' (TJSUIEvent)
  private
    FAltKey: Boolean; external name 'altKey';
    FCode: string; external name 'code';
    FCtrlKey: Boolean; external name 'ctrlKey';
    FIsComposing: Boolean;  external name 'isComposing';
    FKey: String; external name 'key';
    FLocale: string; external name 'locale';
    FLocation: NativeInt; external name 'location';
    FMetaKey: Boolean; external name 'metaKey';
    FRepeat: Boolean; external name 'repeat';
    FShiftKey: Boolean; external name 'shiftKey';
  Public
    function getModifierState(aKey : string) : Boolean;
    property code : string read FCode;
    Property altKey : Boolean read FAltKey;
    property ctrlKey : Boolean read FCtrlKey;
    property isComposing : Boolean read FIsComposing;
    property Key : String read FKey;
    property locale : string read FLocale;
    property location : NativeInt read FLocation;
    property metaKey : Boolean read FMetaKey;
    property _repeat : Boolean read FRepeat;
    property shiftKey : Boolean read FShiftKey;
  end;


var
  document : TJSDocument; external name 'document';
  window : TJSWindow; external name 'window';
  console : TJSConsole; external name 'window.console';
  
implementation
    
end.