pseudo-dom 0.17.0 → 1.0.0

package/dist/interfaces/PseudoDocument.d.ts

@@ -4,32 +4,27 @@ import { PseudoDocumentFragment } from './PseudoDocumentFragment';
 export interface PseudoDocument extends PseudoNode {
     /**
      * The first element, in tree order, whose id matches the given value, or null when there is none.
-     * @param {string} id
-     * @returns {PseudoElement|null}
+     * @param id
      */
     getElementById(id: string): PseudoElement | null;
     /**
      * Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
-     * @param {string} [tagName='div'] The type of element to create
-     * @returns {PseudoElement}
+     * @param tagName The type of element to create
      */
     createElement(tagName: string): PseudoElement;
     /**
      * Make a text node which belongs to this document.
-     * @param {string} [data=''] The text
-     * @returns {PseudoNode}
+     * @param data The text
      */
     createTextNode(data: string): PseudoNode;
     /**
      * Make a comment which belongs to this document.
-     * @param {string} [data=''] The comment
-     * @returns {PseudoNode}
+     * @param data The comment
      */
     createComment(data: string): PseudoNode;
     /**
      * Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
      * then inserted in one go.
-     * @returns {PseudoDocumentFragment}
      */
     createDocumentFragment(): PseudoDocumentFragment;
 }

package/dist/interfaces/PseudoDocumentFragment.d.ts

@@ -3,8 +3,7 @@ import { PseudoElement } from './PseudoElement';
 export interface PseudoDocumentFragment extends PseudoNode {
     /**
      * The first element, in tree order, whose id matches the given value, or null when there is none.
-     * @param {string} id
-     * @returns {PseudoElement|null}
+     * @param id
      */
     getElementById(id: string): PseudoElement | null;
 }

package/dist/interfaces/PseudoElement.d.ts

@@ -1,7 +1,5 @@
 /**
- * @file Substitute for the DOM Element Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM Element Class.
  */
 import { PseudoNode } from './PseudoNode';
 import { PseudoHTMLSlotElement } from './PseudoHTMLSlotElement';
@@ -13,18 +11,6 @@ import { PseudoAnimation } from './PseudoAnimation';
 import { PseudoAttr } from './PseudoAttr';
 /**
  * Simulate the behaviour of the Element Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments PseudoNode
- * @property {string} tagName
- * @property {string} className
- * @property {string} id
- * @property {string} innerHtml
- * @property {Array} attributes
- * @property {function} hasAttribute
- * @property {function} setAttribute
- * @property {function} getAttribute
- * @property {function} removeAttribute
  */
 export interface PseudoElement extends PseudoNode {
     /**
@@ -492,8 +478,7 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Attaches a shadow DOM tree to the specified element and returns a reference to its ShadowRoot. Throws when the
      * element already hosts one.
-     * @param {{mode: string}} options
-     * @returns {PseudoShadowRoot}
+     * @param options
      */
     attachShadow(options: {
         mode: string;
@@ -506,19 +491,16 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Returns whether an element is expected to be visible or not. Settable directly (boundingClientRect / isVisible /
      * etc.) rather than really computed - there is no layout engine here.
-     * @returns {boolean}
      */
     checkVisibility(): boolean;
     /**
      * Returns the Element which is the closest ancestor of the current element (or the current element itself) which matches the selectors given in parameter.
-     * @param {string} selectors A CSS selector
-     * @returns {PseudoElement|null}
+     * @param selectors A CSS selector
      */
     closest(selectors: string): PseudoElement | null;
     /**
      * Returns a read-only view of the element's own inline style declarations (there is no CSS cascade here, so this
      * is not a real computed style).
-     * @returns {{get: function(string): (string|undefined)}}
      */
     computedStyleMap(): {
         get: (property: string) => string | undefined;
@@ -526,7 +508,6 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Returns an array of Animation objects currently active on the element. Settable directly (animations) - there is
      * no animation engine here.
-     * @returns {Array<*>}
      */
     getAnimations(): Array<any>;
     /**
@@ -535,7 +516,6 @@ export interface PseudoElement extends PseudoNode {
     getAttribute(attributeName: string): string | null;
     /**
      * Returns an array of attribute names from the current element.
-     * @returns {Array<string>}
      */
     getAttributeNames(): Array<string>;
     /**
@@ -546,22 +526,21 @@ export interface PseudoElement extends PseudoNode {
      * Retrieves the node representation of the attribute with the specified name and namespace, from the current
      * node and returns it as an Attr. There is no real namespace parsing here, so this ignores the namespace and
      * behaves exactly like getAttributeNode.
-     * @param {string} namespace Ignored
-     * @param {string} attributeName
+     * @param namespace Ignored
+     * @param attributeName
      */
     getAttributeNodeNS(namespace: string, attributeName: string): PseudoAttr | null;
     /**
      * Retrieves the value of the attribute with the specified namespace and name from the current node and returns
      * it as a string. There is no real namespace parsing here, so this ignores the namespace and behaves exactly
      * like getAttribute.
-     * @param {string} namespace Ignored
-     * @param {string} attributeName
+     * @param namespace Ignored
+     * @param attributeName
      */
     getAttributeNS(namespace: string, attributeName: string): string | null;
     /**
      * Returns the size of an element and its position relative to the viewport. Settable directly
      * (boundingClientRect) rather than really computed - there is no layout engine here.
-     * @returns {{x: number, y: number, width: number, height: number, top: number, right: number, bottom: number, left: number}}
      */
     getBoundingClientRect(): {
         x: number;
@@ -576,28 +555,24 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Returns a collection of rectangles that indicate the bounding rectangles for each line of text in a client.
      * Settable directly (clientRects) rather than really computed - there is no layout engine here.
-     * @returns {Array<*>}
      */
     getClientRects(): Array<any>;
     /**
      * Returns a live HTMLCollection that contains all descendants of the current element that possess the list of classes given in the parameter.
-     * @param {string} className One or more space separated classes
-     * @returns {PseudoHTMLCollection}
+     * @param className One or more space separated classes
      */
     getElementsByClassName(className: string): PseudoHTMLCollection;
     /**
      * Returns a live HTMLCollection containing all descendant elements, of a particular tag name, from the current element.
-     * @param {string} tagName A tag name, or * for every element
-     * @returns {PseudoHTMLCollection}
+     * @param tagName A tag name, or * for every element
      */
     getElementsByTagName(tagName: string): PseudoHTMLCollection;
     /**
      * Returns a live HTMLCollection containing all descendant elements, of a particular tag name, from the current
      * element. There is no real namespace parsing here, so this ignores the namespace and behaves exactly like
      * getElementsByTagName.
-     * @param {string} namespace Ignored
-     * @param {string} tagName
-     * @returns {PseudoHTMLCollection}
+     * @param namespace Ignored
+     * @param tagName
      */
     getElementsByTagNameNS(namespace: string, tagName: string): PseudoHTMLCollection;
     /**
@@ -608,45 +583,42 @@ export interface PseudoElement extends PseudoNode {
      * Returns a boolean value indicating if the element has the specified attribute, in the specified namespace, or
      * not. There is no real namespace parsing here, so this ignores the namespace and behaves exactly like
      * hasAttribute.
-     * @param {string} namespace Ignored
-     * @param {string} attributeName
+     * @param namespace Ignored
+     * @param attributeName
      */
     hasAttributeNS(namespace: string, attributeName: string): boolean;
     /**
      * Returns a boolean value indicating if the element has one or more HTML attributes present.
-     * @returns {boolean}
      */
     hasAttributes(): boolean;
     /**
      * Indicates whether the element on which it is invoked has pointer capture for the pointer identified by the given pointer ID.
-     * @param {number} pointerId
-     * @returns {boolean}
+     * @param pointerId
      */
     hasPointerCapture(pointerId: number): boolean;
     /**
      * Inserts a given element at a given position relative to the element it is invoked upon.
-     * @param {string} position beforebegin, afterbegin, beforeend or afterend
-     * @param {PseudoElement} element The element to insert
-     * @returns {PseudoElement|null} The inserted element, or null when the position needs a parent this element does not have
+     * @param position beforebegin, afterbegin, beforeend or afterend
+     * @param element The element to insert
+     * @returns The inserted element, or null when the position needs a parent this element does not have
      */
     insertAdjacentElement(position: string, element: PseudoElement): PseudoElement | null;
     /**
      * Parses the text as HTML and inserts the resulting nodes into the tree in the position given.
-     * @param {string} position beforebegin, afterbegin, beforeend or afterend
-     * @param {string} text The markup to parse
+     * @param position beforebegin, afterbegin, beforeend or afterend
+     * @param text The markup to parse
      * @throws {Error} When the position is not one of the four above
      */
     insertAdjacentHTML(position: string, text: string): void;
     /**
      * Inserts a given text at a given position relative to the element it is invoked upon.
-     * @param {string} position beforebegin, afterbegin, beforeend or afterend
-     * @param {string} text The text to insert
+     * @param position beforebegin, afterbegin, beforeend or afterend
+     * @param text The text to insert
      */
     insertAdjacentText(position: string, text: string): void;
     /**
      * Returns a boolean value indicating whether or not the element would be selected by the specified selector string.
-     * @param {string} selectors A CSS selector
-     * @returns {boolean}
+     * @param selectors A CSS selector
      */
     matches(selectors: string): boolean;
     /**
@@ -655,20 +627,17 @@ export interface PseudoElement extends PseudoNode {
     prepend(...nodes: Array<PseudoNode | string>): void;
     /**
      * Returns the first Node which matches the specified selector string relative to the element.
-     * @param {string} selectors A CSS selector
-     * @returns {PseudoElement|null}
+     * @param selectors A CSS selector
      */
     querySelector(selectors: string): PseudoElement | null;
     /**
      * Returns a NodeList of nodes which match the specified selector string relative to the element.
-     * @param {string} selectors A CSS selector
-     * @returns {Array<PseudoElement>}
+     * @param selectors A CSS selector
      */
     querySelectorAll(selectors: string): Array<PseudoElement>;
     /**
      * Releases (stops) pointer capture that was previously set for a specific pointer event.
-     * @param {number} pointerId
-     * @returns {undefined}
+     * @param pointerId
      */
     releasePointerCapture(pointerId: number): void;
     /**
@@ -687,8 +656,8 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Removes the attribute with the specified name and namespace, from the current node. There is no real
      * namespace parsing here, so this ignores the namespace and behaves exactly like removeAttribute.
-     * @param {string} namespace Ignored
-     * @param {string} attributeName
+     * @param namespace Ignored
+     * @param attributeName
      */
     removeAttributeNS(namespace: string, attributeName: string): void;
     /**
@@ -703,21 +672,18 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Asynchronously asks the browser to make the element fullscreen. There is no real fullscreen here, so this just
      * resolves, like a browser granting the request would.
-     * @returns {Promise<void>}
      */
     requestFullscreen(): Promise<void>;
     /**
      * Allows to asynchronously ask for the pointer to be locked on the given element. There is no real pointer lock
      * here, so this just resolves, like a browser granting the request would.
-     * @returns {Promise<void>}
      */
     requestPointerLock(): Promise<void>;
     /**
      * Scrolls to a particular set of coordinates inside a given element. There is no real scrollable viewport here:
      * this just sets scrollLeft / scrollTop.
-     * @param {number|{left: number, top: number}} [x]
-     * @param {number} [y]
-     * @returns {undefined}
+     * @param x
+     * @param y
      */
     scroll(x: number | {
         left?: number;
@@ -725,9 +691,8 @@ export interface PseudoElement extends PseudoNode {
     }, y: number): void;
     /**
      * Scrolls an element by the given amount, relative to the current position.
-     * @param {number|{left: number, top: number}} [x]
-     * @param {number} [y]
-     * @returns {undefined}
+     * @param x
+     * @param y
      */
     scrollBy(x: number | {
         left?: number;
@@ -736,14 +701,12 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Scrolls an ancestor until the element gets into view. There is no real viewport here for that to mean anything,
      * so this does nothing.
-     * @returns {undefined}
      */
     scrollIntoView(): void;
     /**
      * Scrolls to a particular set of coordinates inside a given element. An alias for scroll.
-     * @param {number|{left: number, top: number}} [x]
-     * @param {number} [y]
-     * @returns {undefined}
+     * @param x
+     * @param y
      */
     scrollTo(x: number | {
         left?: number;
@@ -767,23 +730,21 @@ export interface PseudoElement extends PseudoNode {
     /**
      * Sets the value of the attribute with the specified name and namespace, from the current node. There is no
      * real namespace parsing here, so this ignores the namespace and behaves exactly like setAttribute.
-     * @param {string} namespace Ignored
-     * @param {string} attributeName
-     * @param {string} attributeValue
+     * @param namespace Ignored
+     * @param attributeName
+     * @param attributeValue
      */
     setAttributeNS(namespace: string, attributeName: string, attributeValue: string): void;
     /**
      * Designates a specific element as the capture target of future pointer events.
-     * @param {number} pointerId
-     * @returns {undefined}
+     * @param pointerId
      */
     setPointerCapture(pointerId: number): void;
     /**
      * Toggles a boolean attribute, removing it if it is present and adding it if it is not present, on the specified
      * element - unless force says which of those to do instead. Returns whether the attribute is present afterwards.
-     * @param {string} attributeName
-     * @param {boolean} [force]
-     * @returns {boolean}
+     * @param attributeName
+     * @param force
      */
     toggleAttribute(attributeName: string, force: boolean): boolean;
 }

package/dist/interfaces/PseudoEvent.d.ts

@@ -1,79 +1,47 @@
 /**
- * @file Substitute for the DOM Event Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM Event Class.
  */
 import { PseudoEventTarget } from './PseudoEventTarget';
 /**
  * Simulate the behaviour of the Event Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @property {number} NONE
- * @property {number} CAPTURING_PHASE
- * @property {number} AT_TARGET
- * @property {number} BUBBLING_PHASE
- * @property {boolean} bubbles - A Boolean indicating whether the event bubbles up through the Dom or not.
- * @property {boolean} cancelable - A Boolean indicating whether the event is cancelable.
- * @property {boolean} composed - A Boolean value indicating whether the event can bubble across the boundary
- * between the shadow Dom and the regular Dom.
- * @property {function|PseudoEventTarget} currentTarget - A reference to the currently registered target for the event. This
- * is the object to which the event is currently slated to be sent; it's possible this has been changed along the way
- * through re-targeting.
- * @property {boolean} defaultPrevented - Indicates whether event.preventDefault() has been called on the event.
- * @property {int} eventPhase - Indicates which phase of the event flow is being processed. Uses PseudoEvent constants.
- * @property {EventTarget|PseudoEventTarget} target - A reference to the target to which the event was originally
- * dispatched.
- * @property {int} timeStamp - The time at which the event was created (in milliseconds). By specification, this
- * value is time since epoch, but in reality browsers' definitions vary; in addition, work is underway to change this
- * to be a DomHighResTimeStamp instead.
- * @property {string} type - The name of the event (case-insensitive).
- * @property {boolean} isTrusted - Indicates whether the event was initiated by the browser (after a user
- * click for instance) or by a script (using an event creation method, like event.initEvent)
  */
 export interface PseudoEvent {
-    /**
-     *
-     * @param {string} type
-     * @param {Object} [eventOptions={}]
-     * @param {boolean} [eventOptions.bubbles=true]
-     * @param {boolean} [eventOptions.cancelable=true]
-     * @param {boolean} [eventOptions.composed=true]
-     * @constructor
-     */
+    /** A Boolean indicating whether the event bubbles up through the Dom or not. */
     get bubbles(): boolean;
+    /** A Boolean indicating whether the event is cancelable. */
     get cancelable(): boolean;
+    /** A Boolean value indicating whether the event can bubble across the boundary between the shadow Dom and the regular Dom. */
     get composed(): boolean;
+    /** A reference to the currently registered target for the event. This is the object to which the event is currently slated to be sent; it's possible this has been changed along the way through re-targeting. */
     get currentTarget(): PseudoEventTarget;
+    /** Indicates whether event.preventDefault() has been called on the event. */
     get defaultPrevented(): boolean;
+    /** Indicates which phase of the event flow is being processed. Uses PseudoEvent constants. */
     get eventPhase(): number;
+    /** Indicates whether the event was initiated by the browser (after a user click for instance) or by a script (using an event creation method, like event.initEvent) */
     get isTrusted(): boolean;
+    /** A reference to the target to which the event was originally dispatched. */
     get target(): PseudoEventTarget;
+    /** The time at which the event was created (in milliseconds). By specification, this value is time since epoch, but in reality browsers' definitions vary; in addition, work is underway to change this to be a DomHighResTimeStamp instead. */
     get timeStamp(): number;
+    /** The name of the event (case-insensitive). */
     get type(): string;
     /**
      * Return an array of targets that will have the event executed open them. The order is based on the eventPhase
-     * @method
-     * @returns {Array.<PseudoEventTarget>}
      */
     composedPath(): Array<PseudoEventTarget>;
     /**
      * Cancels the event (if it is cancelable).
-     * @method
-     * @returns {null}
      */
     preventDefault(): null;
     /**
      * For this particular event, no other listener will be called.
      * Neither those attached on the same element, nor those attached on elements which will be traversed later (in
      * capture phase, for instance)
-     * @method
-     * @returns {null}
      */
     stopImmediatePropagation(): null;
     /**
      * Stops the propagation of events further along in the Dom.
-     * @method
-     * @returns {null}
      */
     stopPropagation(): null;
 }

package/dist/interfaces/PseudoEvent.js

@@ -1,9 +1,7 @@
 'use strict'
 
 /**
- * @file Substitute for the DOM Event Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM Event Class.
  */
 Object.defineProperty(exports, '__esModule', {
   value: true

package/dist/interfaces/PseudoEventTarget.d.ts

@@ -1,7 +1,5 @@
 /**
- * @file Substitute for the DOM EventTarget Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM EventTarget Class.
  */
 import { PseudoEvent } from './PseudoEvent';
 export type listenerOptions = {
@@ -11,11 +9,6 @@ export type listenerOptions = {
 };
 /**
  * Simulate the behaviour of the EventTarget Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @interface
- * @property {function} addEventListener
- * @property {function} removeEventListener
- * @property {function} dispatchEvent
  */
 export interface PseudoEventTarget {
     /**
@@ -23,24 +16,22 @@ export interface PseudoEventTarget {
      */
     /**
      * Registers an event handler of a specific event type on the EventTarget.
-     * @param {string} type
-     * @param {function|Object} callback
-     * @param {boolean|Object} [useCapture=false]
+     * @param type
+     * @param callback
+     * @param useCapture
      */
     addEventListener(type: string, callback: Function | {
         handleEvent: Function;
     } | any, useCapture: listenerOptions | boolean): void;
     /**
      * Removes an event listener from the EventTarget.
-     * @param {string} type
-     * @param {function} callback
+     * @param type
+     * @param callback
      */
     removeEventListener(type: string, callback: Function, options?: listenerOptions | boolean): void;
     /**
      * Dispatches an event to this EventTarget.
-     * @param {Event|PseudoEvent} event
-     * @param {EventTarget|PseudoEventTarget} target
-     * @returns {boolean}
+     * @param event
      */
     dispatchEvent(event: PseudoEvent): boolean;
 }

package/dist/interfaces/PseudoHTMLCollection.d.ts

@@ -10,14 +10,12 @@ export interface PseudoHTMLCollection extends Iterable<PseudoElement> {
     get length(): number;
     /**
      * The element at the given index, or null when there is none.
-     * @param {number} index
-     * @returns {PseudoElement|null}
+     * @param index
      */
     item(index: number): PseudoElement | null;
     /**
      * The element whose id, or whose name attribute, is the given value, or null when there is none.
-     * @param {string} name
-     * @returns {PseudoElement|null}
+     * @param name
      */
     namedItem(name: string): PseudoElement | null;
 }

package/dist/interfaces/PseudoHTMLElement.d.ts

@@ -1,22 +1,17 @@
 /**
- * @file Substitute for the DOM HTMLElement Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM HTMLElement Class.
  */
 import { PseudoElement } from './PseudoElement';
 import { PseudoCSSStyleDeclaration } from './PseudoCSSStyleDeclaration';
 /**
  * Simulate the behaviour of the HTMLElement Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments PseudoElement
- * @property {boolean} hidden - State of whether element is visible
- * @property {number} offsetHeight - The height of the element as offset by the parent element
- * @property {number} offsetLeft - The position of the left side of the element based on the parent element
- * @property {PseudoHTMLElement} offsetParent - A reference to the closest positioned parent element
- * @property {number} offsetTop - The position of the top side of the element based on the parent element
- * @property {number} offsetWidth - The width of the element as offset by the parent element
- * @property {string} title - The title attribute which affects the text visible on hover
+ *
+ * It also has these simple properties, which are stored as attributes:
+ * - `hidden`: state of whether the element is visible
+ * - `title`: the title attribute, which affects the text visible on hover
+ * - `offsetHeight`, `offsetWidth`: the height and width of the element as offset by the parent element
+ * - `offsetLeft`, `offsetTop`: the position of the left and top sides of the element based on the parent element
+ * - `offsetParent`: a reference to the closest positioned parent element
  */
 export interface PseudoHTMLElement extends PseudoElement {
     /**

package/dist/interfaces/PseudoNode.d.ts

@@ -1,7 +1,5 @@
 /**
- * @file Substitute for the DOM Node Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM Node Class.
  */
 import { PseudoEventTarget } from './PseudoEventTarget';
 import { PseudoNodeList } from '../classes/PseudoNodeList';
@@ -11,12 +9,6 @@ import { PseudoElement } from './PseudoElement';
 import { PseudoDocumentFragment } from './PseudoDocumentFragment';
 /**
  * Simulate the behaviour of the Node Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments PseudoEventTarget
- * @property {string} name
- * @property {function} appendChild
- * @property {function} removeChild
  */
 export interface PseudoNode extends PseudoEventTarget {
     /**
@@ -99,8 +91,7 @@ export interface PseudoNode extends PseudoEventTarget {
     set textContent(text: string | null);
     /**
      * Adds the specified childNode argument as the last child to the current node. If the argument referenced an existing node on the DOM tree, the node will be detached from its current position and attached at the new position.
-     * @param {PseudoNode} childNode
-     * @returns {PseudoNode}
+     * @param childNode
      */
     appendChild(childNode: PseudoNode): PseudoNode;
     /**
@@ -166,8 +157,7 @@ export interface PseudoNode extends PseudoEventTarget {
     normalize(): void;
     /**
      * Removes a child node from the current element, which must be a child of the current node.
-     * @param {PseudoNode} child
-     * @returns {PseudoNode}
+     * @param child
      */
     removeChild(child: PseudoNode): PseudoNode;
     /**

package/dist/main.d.ts

@@ -1,7 +1,5 @@
 /**
- * @file All of the Pseudo Dom Helper Objects functions for simulating parts of the DOM when running scripts in NodeJs.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * All of the Pseudo Dom Helper Objects functions for simulating parts of the DOM when running scripts in NodeJs.
  */
 import { EventService as PseudoEvent } from './services/EventService';
 import PseudoEventTarget from './services/EventTargetService';
@@ -26,9 +24,6 @@ import simulate from './simulate';
 import { TextService as PseudoText, CommentService as PseudoComment } from './services/NodeService';
 /**
  * All methods exported from this module are encapsulated within pseudoDom.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @typedef {Object} pseudoDom
- * @module pseudoDom/objects
  */
 declare const pseudoDom: {
     generateDocument: (root: Window | any, context?: object) => Window | PseudoEventTarget;

package/dist/main.js

@@ -1,9 +1,7 @@
 'use strict'
 
 /**
- * @file All of the Pseudo Dom Helper Objects functions for simulating parts of the DOM when running scripts in NodeJs.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * All of the Pseudo Dom Helper Objects functions for simulating parts of the DOM when running scripts in NodeJs.
  */
 const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
   return mod && mod.__esModule
@@ -131,9 +129,6 @@ Object.defineProperty(exports, 'PseudoComment', {
 })
 /**
  * All methods exported from this module are encapsulated within pseudoDom.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @typedef {Object} pseudoDom
- * @module pseudoDom/objects
  */
 const pseudoDom = {
   generateDocument: generateDocument_1.default,