pseudo-dom 0.17.0 → 1.0.0

package/dist/classes/PseudoEventListener.d.ts

@@ -1,16 +1,9 @@
 /**
- * @file Substitute for the DOM EventEventListener Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM EventEventListener Class.
  */
 import { EventService } from '../services/EventService';
 /**
  * Handle events as they are stored and implemented.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @property {string} eventType
- * @property {Object} eventOptions
- * @property {boolean} isDefault
  */
 declare class PseudoEventListener {
     private eventOptions;
@@ -20,11 +13,10 @@ declare class PseudoEventListener {
     private readonly defaultListener;
     private isRemoved;
     /**
-     * @param {string} eventType The type of event this listens for
-     * @param {Object} [options] The capture, once and passive options
-     * @param {Function} handleEvent The function which is called with the event, already bound to what it should run as
-     * @param {Function} [originalCallback=handleEvent] The function (or object) which was given when registering, used to find this listener again
-     * @constructor
+     * @param eventType The type of event this listens for
+     * @param options The capture, once and passive options
+     * @param handleEvent The function which is called with the event, already bound to what it should run as
+     * @param originalCallback The function (or object) which was given when registering, used to find this listener again
      */
     constructor(eventType: string, { capture, once, passive }: {
         capture?: boolean;
@@ -45,51 +37,33 @@ declare class PseudoEventListener {
     get removed(): boolean;
     set removed(removed: boolean);
     /**
-     * @method
-     * @name PseudoEventListener#handleEvent
-     * @param {PseudoEvent} event
-     * @returns {*}
+     * @param event
      */
     handleEvent(event: EventService): any;
     /**
      * A capture listener runs while the event travels down to the target.
-     * @method
-     * @name PseudoEventListener#doCapturePhase
-     * @param {PseudoEvent} event
-     * @returns {boolean}
+     * @param event
      */
     doCapturePhase(event: EventService): boolean;
     /**
      * Every listener of the target itself runs, capture listeners first.
-     * @method
-     * @name PseudoEventListener#doTargetPhase
-     * @param {PseudoEvent} event
-     * @returns {boolean}
+     * @param event
      */
     doTargetPhase(event: EventService): boolean;
     /**
      * A listener which is not a capture listener runs while the event travels back up (when it bubbles).
-     * @method
-     * @name PseudoEventListener#doBubblePhase
-     * @param {PseudoEvent} event
-     * @returns {boolean}
+     * @param event
      */
     doBubblePhase(event: EventService): boolean;
     /**
-     * @method
-     * @name PseudoEventListener#skipPhase
-     * @param {PseudoEvent} event
-     * @returns {boolean}
+     * @param event
      */
     skipPhase(event: EventService): boolean;
     /**
      * Whether this listener should not run for the event as it is now (it was removed, or it is for another phase).
      * Stopping propagation is handled by the dispatching, since it stops other targets and not the listeners of the
      * current one.
-     * @method
-     * @name PseudoEventListener#rejectEvent
-     * @param {PseudoEvent} event
-     * @returns {boolean}
+     * @param event
      */
     rejectEvent(event: EventService): boolean;
 }

package/dist/classes/PseudoEventListener.js

@@ -4,26 +4,18 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 /**
- * @file Substitute for the DOM EventEventListener Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM EventEventListener Class.
  */
 const EventService_1 = require('../services/EventService')
 /**
  * Handle events as they are stored and implemented.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @property {string} eventType
- * @property {Object} eventOptions
- * @property {boolean} isDefault
  */
 class PseudoEventListener {
   /**
-   * @param {string} eventType The type of event this listens for
-   * @param {Object} [options] The capture, once and passive options
-   * @param {Function} handleEvent The function which is called with the event, already bound to what it should run as
-   * @param {Function} [originalCallback=handleEvent] The function (or object) which was given when registering, used to find this listener again
-   * @constructor
+   * @param eventType The type of event this listens for
+   * @param options The capture, once and passive options
+   * @param handleEvent The function which is called with the event, already bound to what it should run as
+   * @param originalCallback The function (or object) which was given when registering, used to find this listener again
    */
   constructor (eventType, {
     capture = false,
@@ -83,10 +75,7 @@ class PseudoEventListener {
   }
 
   /**
-   * @method
-   * @name PseudoEventListener#handleEvent
-   * @param {PseudoEvent} event
-   * @returns {*}
+   * @param event
    */
   handleEvent (event) {
     return this.handler(event)
@@ -94,10 +83,7 @@ class PseudoEventListener {
 
   /**
    * A capture listener runs while the event travels down to the target.
-   * @method
-   * @name PseudoEventListener#doCapturePhase
-   * @param {PseudoEvent} event
-   * @returns {boolean}
+   * @param event
    */
   doCapturePhase (event) {
     return event.eventPhase === EventService_1.EventService.CAPTURING_PHASE && this.eventOptions.capture
@@ -105,10 +91,7 @@ class PseudoEventListener {
 
   /**
    * Every listener of the target itself runs, capture listeners first.
-   * @method
-   * @name PseudoEventListener#doTargetPhase
-   * @param {PseudoEvent} event
-   * @returns {boolean}
+   * @param event
    */
   doTargetPhase (event) {
     return event.eventPhase === EventService_1.EventService.AT_TARGET
@@ -116,20 +99,14 @@ class PseudoEventListener {
 
   /**
    * A listener which is not a capture listener runs while the event travels back up (when it bubbles).
-   * @method
-   * @name PseudoEventListener#doBubblePhase
-   * @param {PseudoEvent} event
-   * @returns {boolean}
+   * @param event
    */
   doBubblePhase (event) {
     return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && !this.eventOptions.capture
   }
 
   /**
-   * @method
-   * @name PseudoEventListener#skipPhase
-   * @param {PseudoEvent} event
-   * @returns {boolean}
+   * @param event
    */
   skipPhase (event) {
     return !this.doCapturePhase(event) && !this.doTargetPhase(event) && !this.doBubblePhase(event)
@@ -139,10 +116,7 @@ class PseudoEventListener {
    * Whether this listener should not run for the event as it is now (it was removed, or it is for another phase).
    * Stopping propagation is handled by the dispatching, since it stops other targets and not the listeners of the
    * current one.
-   * @method
-   * @name PseudoEventListener#rejectEvent
-   * @param {PseudoEvent} event
-   * @returns {boolean}
+   * @param event
    */
   rejectEvent (event) {
     return this.isRemoved || this.skipPhase(event)

package/dist/classes/PseudoHTMLDocument.d.ts

@@ -1,7 +1,5 @@
 /**
- * @file Substitute for the DOM HTMLDocument Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM HTMLDocument Class.
  */
 import { HTMLElementService as PseudoHTMLElement } from '../services/HTMLElementService';
 import { DocumentService } from '../services/DocumentService';
@@ -10,31 +8,25 @@ import { NodeService } from '../services/NodeService';
  * Simulate the behaviour of the HTMLDocument Class when there is no DOM available. Like the real HTMLDocument, this
  * only adds the html/head/body structure on top of what Document already gives (createElement, createTextNode,
  * createComment, createDocumentFragment, getElementById, textContent always null).
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments DocumentService
- * @property {PseudoHTMLElement} head - A reference to the Head child element
- * @property {PseudoHTMLElement} body - A reference to the Body child element
  */
 declare class PseudoHTMLDocument extends DocumentService {
+    /** A reference to the Head child element */
     head: PseudoHTMLElement | null;
+    /** A reference to the Body child element */
     body: PseudoHTMLElement | null;
     /**
      * The root HTML element is acts as the parent to all HTML elements in the document.
-     * @constructor
      */
     constructor();
     /**
      * A copy of this document with none of its html/head/body (cloneNode, from the inherited cloneShallow hook, fills
      * them back in, deep copies own document's, empty otherwise - see cloneNode).
-     * @returns {PseudoHTMLDocument}
      */
     protected cloneShallow(): NodeService;
     /**
      * Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in
      * the document (a shallow one is an empty document).
-     * @param {boolean} [deep=false] Copy everything in the document as well
-     * @returns {PseudoHTMLDocument}
+     * @param deep Copy everything in the document as well
      */
     cloneNode(deep?: boolean): PseudoHTMLDocument;
 }

package/dist/classes/PseudoHTMLDocument.js

@@ -10,16 +10,10 @@ const DocumentService_1 = require('../services/DocumentService')
  * Simulate the behaviour of the HTMLDocument Class when there is no DOM available. Like the real HTMLDocument, this
  * only adds the html/head/body structure on top of what Document already gives (createElement, createTextNode,
  * createComment, createDocumentFragment, getElementById, textContent always null).
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments DocumentService
- * @property {PseudoHTMLElement} head - A reference to the Head child element
- * @property {PseudoHTMLElement} body - A reference to the Body child element
  */
 class PseudoHTMLDocument extends DocumentService_1.DocumentService {
   /**
    * The root HTML element is acts as the parent to all HTML elements in the document.
-   * @constructor
    */
   constructor () {
     super()
@@ -27,13 +21,11 @@ class PseudoHTMLDocument extends DocumentService_1.DocumentService {
     this.appendChild(html)
     /**
      * Create document head element
-     * @type {PseudoHTMLElement}
      */
     this.head = this.createElement('head')
     html.appendChild(this.head)
     /**
      * Create document body element
-     * @type {PseudoHTMLElement}
      */
     this.body = this.createElement('body')
     html.appendChild(this.body)
@@ -42,7 +34,6 @@ class PseudoHTMLDocument extends DocumentService_1.DocumentService {
   /**
    * A copy of this document with none of its html/head/body (cloneNode, from the inherited cloneShallow hook, fills
    * them back in, deep copies own document's, empty otherwise - see cloneNode).
-   * @returns {PseudoHTMLDocument}
    */
   cloneShallow () {
     const copy = new this.constructor()
@@ -57,8 +48,7 @@ class PseudoHTMLDocument extends DocumentService_1.DocumentService {
   /**
    * Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in
    * the document (a shallow one is an empty document).
-   * @param {boolean} [deep=false] Copy everything in the document as well
-   * @returns {PseudoHTMLDocument}
+   * @param deep Copy everything in the document as well
    */
   cloneNode (deep = false) {
     const copy = super.cloneNode(deep)

package/dist/classes/PseudoNodeList.d.ts

@@ -1,34 +1,26 @@
 /**
- * @file Substitute for the NodeList interface.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the NodeList interface.
  */
 import { LinkedTreeList } from 'collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList';
 /**
  * A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
  * the linkers that hold them.
- * @class
- * @augments LinkedTreeList
  */
 export declare class PseudoNodeList extends LinkedTreeList {
     /**
      * Iterate over the nodes in this list.
-     * @returns {Iterator}
      */
     [Symbol.iterator](): Iterator<any>;
     /**
      * Iterate over [index, node] pairs.
-     * @returns {Iterator}
      */
     entries(): Iterator<[number, any]>;
     /**
      * Iterate over the indexes.
-     * @returns {Iterator}
      */
     keys(): Iterator<number>;
     /**
      * Iterate over the nodes.
-     * @returns {Iterator}
      */
     values(): Iterator<any>;
 }

package/dist/classes/PseudoNodeList.js

@@ -7,21 +7,16 @@ Object.defineProperty(exports, '__esModule', {
 })
 exports.PseudoNodeList = void 0
 /**
- * @file Substitute for the NodeList interface.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the NodeList interface.
  */
 const LinkedTreeList_1 = require('collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList')
 /**
  * A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
  * the linkers that hold them.
- * @class
- * @augments LinkedTreeList
  */
 class PseudoNodeList extends LinkedTreeList_1.LinkedTreeList {
   /**
    * Iterate over the nodes in this list.
-   * @returns {Iterator}
    */
   [Symbol.iterator] () {
     // Walk the nodes of this list only (the linkers of a child list have no children of their own)
@@ -46,7 +41,6 @@ class PseudoNodeList extends LinkedTreeList_1.LinkedTreeList {
 
   /**
    * Iterate over [index, node] pairs.
-   * @returns {Iterator}
    */
   entries () {
     return Array.from(this).map((node, index) => [index, node])[Symbol.iterator]()
@@ -54,7 +48,6 @@ class PseudoNodeList extends LinkedTreeList_1.LinkedTreeList {
 
   /**
    * Iterate over the indexes.
-   * @returns {Iterator}
    */
   keys () {
     return Array.from(this).map((node, index) => index)[Symbol.iterator]()
@@ -62,7 +55,6 @@ class PseudoNodeList extends LinkedTreeList_1.LinkedTreeList {
 
   /**
    * Iterate over the nodes.
-   * @returns {Iterator}
    */
   values () {
     return Array.from(this)[Symbol.iterator]()

package/dist/factories/createDataset.d.ts

@@ -1,8 +1,6 @@
 /**
  * A live DOMStringMap-like object for an element's data-* attributes.
- * @memberOf module:factories
- * @param {*} element The element whose data-* attributes this reflects
- * @returns {Object.<string, string>}
+ * @param element The element whose data-* attributes this reflects
  */
 declare const createDataset: (element: any) => {
     [key: string]: string;

package/dist/factories/createDataset.js

@@ -6,20 +6,17 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 /**
- * @file Wraps an element in a Proxy which behaves like the DOM's DOMStringMap (element.dataset): a live view of its
+ * Wraps an element in a Proxy which behaves like the DOM's DOMStringMap (element.dataset): a live view of its
  * data-* attributes, under their camelCase names, backed by the element's own getAttribute / setAttribute /
  * hasAttribute / removeAttribute (nothing is stored separately, so it can never fall out of sync with the
  * attributes).
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 const createStyleDeclaration_1 = require('./createStyleDeclaration')
 const DATA_PREFIX = 'data-'
 const attributeName = property => `${DATA_PREFIX}${(0, createStyleDeclaration_1.camelToKebab)(property)}`
 /**
  * Every data-* attribute name currently on the element, as [attributeName, camelCaseName] pairs.
- * @param {*} element
- * @returns {Array<Array<string>>}
+ * @param element
  */
 const dataAttributes = element => {
   const names = []
@@ -33,9 +30,7 @@ const dataAttributes = element => {
 }
 /**
  * A live DOMStringMap-like object for an element's data-* attributes.
- * @memberOf module:factories
- * @param {*} element The element whose data-* attributes this reflects
- * @returns {Object.<string, string>}
+ * @param element The element whose data-* attributes this reflects
  */
 const createDataset = element => new Proxy({}, {
   get (_target, property) {

package/dist/factories/createEvent.d.ts

@@ -1,13 +1,11 @@
 import { EventService } from '../services/EventService';
 /**
  * How the event is being created.
- * @typedef {Object} CreateEventOptions
- * @property {boolean} [browser=false] The browser is creating the event (for a user action, or for something like
- * element.click()), so the standard options for the type of event apply where the init does not give its own
- * @property {boolean} [trusted=false] The event comes from a real user action rather than from a script (isTrusted)
  */
 export type CreateEventOptions = {
+    /** The browser is creating the event (for a user action, or for something like element.click()), so the standard options for the type of event apply where the init does not give its own (default false) */
     browser?: boolean;
+    /** The event comes from a real user action rather than from a script (isTrusted) (default false) */
     trusted?: boolean;
 };
 /**
@@ -16,11 +14,9 @@ export type CreateEventOptions = {
  * the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
  * it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
  * real user action (isTrusted).
- * @function createEvent
- * @param {string} type The type of the event, such as click
- * @param {Object} [init={}] The options for the event (bubbles, cancelable, composed and those of its kind of event)
- * @param {CreateEventOptions} [options={}] Whether the browser is creating the event, and whether it is trusted
- * @returns {EventService}
+ * @param type The type of the event, such as click
+ * @param init The options for the event (bubbles, cancelable, composed and those of its kind of event)
+ * @param options Whether the browser is creating the event, and whether it is trusted
  */
 export declare const createEvent: (type: string, init?: {
     [option: string]: any;

package/dist/factories/createEvent.js

@@ -29,11 +29,9 @@ const eventClasses = {
  * the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
  * it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
  * real user action (isTrusted).
- * @function createEvent
- * @param {string} type The type of the event, such as click
- * @param {Object} [init={}] The options for the event (bubbles, cancelable, composed and those of its kind of event)
- * @param {CreateEventOptions} [options={}] Whether the browser is creating the event, and whether it is trusted
- * @returns {EventService}
+ * @param type The type of the event, such as click
+ * @param init The options for the event (bubbles, cancelable, composed and those of its kind of event)
+ * @param options Whether the browser is creating the event, and whether it is trusted
  */
 const createEvent = (type, init = {}, {
   browser = false,

package/dist/factories/createStyleDeclaration.d.ts

@@ -1,29 +1,23 @@
 /**
- * @file Wraps a CSSStyleDeclarationService in a Proxy so arbitrary camelCase CSS properties (element.style.
+ * Wraps a CSSStyleDeclarationService in a Proxy so arbitrary camelCase CSS properties (element.style.
  * backgroundColor) work like the DOM's, on top of its real methods (getPropertyValue, setProperty, cssText, ...).
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 import { CSSStyleDeclarationService } from '../services/CSSStyleDeclarationService';
 /**
  * kebab-case -> camelCase ("background-color" -> "backgroundColor").
- * @param {string} name
- * @returns {string}
+ * @param name
  */
 declare const kebabToCamel: (name: string) => string;
 /**
  * camelCase -> kebab-case ("backgroundColor" -> "background-color").
- * @param {string} name
- * @returns {string}
+ * @param name
  */
 declare const camelToKebab: (name: string) => string;
 /**
  * A live CSSStyleDeclaration-like object: its real methods (cssText, getPropertyValue, setProperty, ...) work as
  * declared, and any other property name is treated as a camelCase CSS property (declaration.backgroundColor reads /
  * writes the "background-color" declaration), matching what a real element.style supports.
- * @memberOf module:factories
- * @param {string} [cssText=''] Initial declarations
- * @returns {CSSStyleDeclarationService}
+ * @param cssText Initial declarations
  */
 declare const createStyleDeclaration: (cssText?: string) => CSSStyleDeclarationService;
 export { kebabToCamel, camelToKebab };

package/dist/factories/createStyleDeclaration.js

@@ -5,24 +5,20 @@ Object.defineProperty(exports, '__esModule', {
 })
 exports.camelToKebab = exports.kebabToCamel = void 0
 /**
- * @file Wraps a CSSStyleDeclarationService in a Proxy so arbitrary camelCase CSS properties (element.style.
+ * Wraps a CSSStyleDeclarationService in a Proxy so arbitrary camelCase CSS properties (element.style.
  * backgroundColor) work like the DOM's, on top of its real methods (getPropertyValue, setProperty, cssText, ...).
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 const CSSStyleDeclarationService_1 = require('../services/CSSStyleDeclarationService')
 const isIndex = property => /^\d+$/.test(property)
 /**
  * kebab-case -> camelCase ("background-color" -> "backgroundColor").
- * @param {string} name
- * @returns {string}
+ * @param name
  */
 const kebabToCamel = name => name.replace(/-([a-z0-9])/gi, (_match, letter) => letter.toUpperCase())
 exports.kebabToCamel = kebabToCamel
 /**
  * camelCase -> kebab-case ("backgroundColor" -> "background-color").
- * @param {string} name
- * @returns {string}
+ * @param name
  */
 const camelToKebab = name => name.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`)
 exports.camelToKebab = camelToKebab
@@ -30,9 +26,7 @@ exports.camelToKebab = camelToKebab
  * A live CSSStyleDeclaration-like object: its real methods (cssText, getPropertyValue, setProperty, ...) work as
  * declared, and any other property name is treated as a camelCase CSS property (declaration.backgroundColor reads /
  * writes the "background-color" declaration), matching what a real element.style supports.
- * @memberOf module:factories
- * @param {string} [cssText=''] Initial declarations
- * @returns {CSSStyleDeclarationService}
+ * @param cssText Initial declarations
  */
 const createStyleDeclaration = (cssText = '') => {
   const target = new CSSStyleDeclarationService_1.CSSStyleDeclarationService(cssText)

package/dist/factories/cssSelectAdapter.d.ts

@@ -2,8 +2,6 @@
  * Maps pseudo-dom's own Node / Element API onto the Adapter interface css-select needs to query a tree which is not
  * domutils' own (css-select's own Adapter<Node, ElementNode> type). Every method here is one pseudo-dom already has
  * under a different name; nothing here reimplements DOM behaviour.
- * @memberOf module:factories
- * @type {Object}
  */
 export declare const cssSelectAdapter: {
     isTag: (node: any) => boolean;

package/dist/factories/cssSelectAdapter.js

@@ -9,17 +9,14 @@ Object.defineProperty(exports, '__esModule', {
 })
 exports.cssSelectAdapter = void 0
 /**
- * @file The css-select Adapter which lets it query pseudo-dom's own tree, instead of the domutils-based tree it
+ * The css-select Adapter which lets it query pseudo-dom's own tree, instead of the domutils-based tree it
  * defaults to.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 const NodeService_1 = require('../services/NodeService')
 /**
  * Walk up from a node (not including it) to find the nearest element, in the given direction.
- * @param {*} node The node to start from
- * @param {'nextSibling'|'previousSibling'} direction Which sibling reference to follow
- * @returns {*|null}
+ * @param node The node to start from
+ * @param direction Which sibling reference to follow
  */
 const nearestElementSibling = (node, direction) => {
   let current = node ? node[direction] : null
@@ -32,8 +29,6 @@ const nearestElementSibling = (node, direction) => {
  * Maps pseudo-dom's own Node / Element API onto the Adapter interface css-select needs to query a tree which is not
  * domutils' own (css-select's own Adapter<Node, ElementNode> type). Every method here is one pseudo-dom already has
  * under a different name; nothing here reimplements DOM behaviour.
- * @memberOf module:factories
- * @type {Object}
  */
 exports.cssSelectAdapter = {
   isTag: node => !!node && node.nodeType === NodeService_1.NodeService.ELEMENT_NODE,

package/dist/factories/eventDefaults.d.ts

@@ -1,21 +1,18 @@
 /**
- * @file The standard event types of the browser, and how the browser creates them.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * The standard event types of the browser, and how the browser creates them.
  */
 /**
  * How the browser creates an event of a standard type: whether it bubbles, whether it can be cancelled, whether it
  * crosses the boundary of a shadow tree, and which kind of event object it is.
- * @typedef {Object} EventDefinition
- * @property {boolean} bubbles - After the target, the event goes back up through the ancestors (the capture phase, going down, always happens)
- * @property {boolean} cancelable - preventDefault() can stop the default action
- * @property {boolean} composed - The event crosses the boundary of a shadow tree
- * @property {string} interface - The kind of event object: Event, UIEvent, MouseEvent, PointerEvent, KeyboardEvent, FocusEvent, InputEvent or CustomEvent
  */
 export type EventDefinition = {
+    /** After the target, the event goes back up through the ancestors (the capture phase, going down, always happens) */
     bubbles: boolean;
+    /** preventDefault() can stop the default action */
     cancelable: boolean;
+    /** The event crosses the boundary of a shadow tree */
     composed: boolean;
+    /** The kind of event object: Event, UIEvent, MouseEvent, PointerEvent, KeyboardEvent, FocusEvent, InputEvent or CustomEvent */
     interface: 'Event' | 'UIEvent' | 'MouseEvent' | 'PointerEvent' | 'KeyboardEvent' | 'FocusEvent' | 'InputEvent' | 'CustomEvent';
 };
 /**
@@ -23,7 +20,6 @@ export type EventDefinition = {
  * options. A script which creates an event with the constructor gets none of them (everything is false) unless it asks
  * for them, which is why createEvent only uses this table when it is told the browser is creating the event.
  * The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop, Touch and CSS specifications.
- * @type {Object.<string, EventDefinition>}
  */
 export declare const eventDefaults: {
     [type: string]: EventDefinition;

package/dist/factories/eventDefaults.js

@@ -1,9 +1,7 @@
 'use strict'
 
 /**
- * @file The standard event types of the browser, and how the browser creates them.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * The standard event types of the browser, and how the browser creates them.
  */
 Object.defineProperty(exports, '__esModule', {
   value: true
@@ -20,7 +18,6 @@ const define = (bubbles, cancelable, composed, eventInterface = 'Event') => ({
  * options. A script which creates an event with the constructor gets none of them (everything is false) unless it asks
  * for them, which is why createEvent only uses this table when it is told the browser is creating the event.
  * The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop, Touch and CSS specifications.
- * @type {Object.<string, EventDefinition>}
  */
 exports.eventDefaults = {
   // Mouse (UI Events)

package/dist/factories/generateDocument.d.ts

@@ -2,10 +2,8 @@ import PseudoEventTarget from '../services/EventTargetService';
 /**
  * Construct the Pseudo Dom to provide access to Dom objects which are otherwise not available outside the browser
  * context.
- * @function generateDocument
- * @param {Object} root
- * @param {Object} context
- * @returns {Window|PseudoEventTarget}
+ * @param root
+ * @param context
  */
 declare const generateDocument: (root: Window | any, context?: object) => Window | PseudoEventTarget;
 export default generateDocument;