pseudo-dom 0.8.0 → 0.10.0

package/dist/classes/PseudoHTMLDocument.d.ts

@@ -1,41 +1,41 @@
-/**
- * @file Substitute for the DOM HTMLDocument Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-import { HTMLElementService as PseudoHTMLElement } from '../services/HTMLElementService';
-import { DocumentService } from '../services/DocumentService';
-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 {
-    head: PseudoHTMLElement | null;
-    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}
-     */
-    cloneNode(deep?: boolean): PseudoHTMLDocument;
-}
-export default PseudoHTMLDocument;
+/**
+ * @file Substitute for the DOM HTMLDocument Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { HTMLElementService as PseudoHTMLElement } from '../services/HTMLElementService';
+import { DocumentService } from '../services/DocumentService';
+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 {
+    head: PseudoHTMLElement | null;
+    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}
+     */
+    cloneNode(deep?: boolean): PseudoHTMLDocument;
+}
+export default PseudoHTMLDocument;

package/dist/classes/PseudoHTMLDocument.js

@@ -1,74 +1,74 @@
-'use strict'
-
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.find.js')
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-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()
-    const html = this.createElement('html')
-    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)
-  }
-
-  /**
-   * 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()
-    while (copy.firstChild) {
-      copy.removeChild(copy.firstChild)
-    }
-    copy.head = null
-    copy.body = null
-    return copy
-  }
-
-  /**
-   * 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}
-   */
-  cloneNode (deep = false) {
-    const copy = super.cloneNode(deep)
-    if (deep) {
-      const html = Array.from(copy.childNodes).find(child => child.tagName === 'html')
-      const inHtml = tagName => html ? Array.from(html.childNodes).find(child => child.tagName === tagName) || null : null
-      copy.head = inHtml('head')
-      copy.body = inHtml('body')
-    }
-    return copy
-  }
-}
-exports.default = PseudoHTMLDocument
+'use strict'
+
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.find.js')
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+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()
+    const html = this.createElement('html')
+    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)
+  }
+
+  /**
+   * 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()
+    while (copy.firstChild) {
+      copy.removeChild(copy.firstChild)
+    }
+    copy.head = null
+    copy.body = null
+    return copy
+  }
+
+  /**
+   * 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}
+   */
+  cloneNode (deep = false) {
+    const copy = super.cloneNode(deep)
+    if (deep) {
+      const html = Array.from(copy.childNodes).find(child => child.tagName === 'html')
+      const inHtml = tagName => html ? Array.from(html.childNodes).find(child => child.tagName === tagName) || null : null
+      copy.head = inHtml('head')
+      copy.body = inHtml('body')
+    }
+    return copy
+  }
+}
+exports.default = PseudoHTMLDocument

package/dist/factories/createDataset.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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>}
+ */
+declare const createDataset: (element: any) => {
+    [key: string]: string;
+};
+export default createDataset;

package/dist/factories/createDataset.js

@@ -0,0 +1,78 @@
+'use strict'
+
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.map.js')
+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
+ * 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>>}
+ */
+const dataAttributes = element => {
+  const names = []
+  for (let index = 0; index < element.attributes.length; index++) {
+    const name = element.attributes.item(index).name
+    if (name.indexOf(DATA_PREFIX) === 0 && name.length > DATA_PREFIX.length) {
+      names.push([name, (0, createStyleDeclaration_1.kebabToCamel)(name.slice(DATA_PREFIX.length))])
+    }
+  }
+  return names
+}
+/**
+ * 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>}
+ */
+const createDataset = element => new Proxy({}, {
+  get (_target, property) {
+    if (typeof property !== 'string') {
+      return undefined
+    }
+    const value = element.getAttribute(attributeName(property))
+    return value === null ? undefined : value
+  },
+  set (_target, property, value) {
+    if (typeof property !== 'string') {
+      return false
+    }
+    element.setAttribute(attributeName(property), String(value))
+    return true
+  },
+  deleteProperty (_target, property) {
+    if (typeof property === 'string') {
+      element.removeAttribute(attributeName(property))
+    }
+    return true
+  },
+  has (_target, property) {
+    return typeof property === 'string' && element.hasAttribute(attributeName(property))
+  },
+  ownKeys () {
+    return dataAttributes(element).map(([, camelCaseName]) => camelCaseName)
+  },
+  getOwnPropertyDescriptor (_target, property) {
+    if (typeof property !== 'string' || !element.hasAttribute(attributeName(property))) {
+      return undefined
+    }
+    return {
+      enumerable: true,
+      configurable: true,
+      value: element.getAttribute(attributeName(property))
+    }
+  }
+})
+exports.default = createDataset

package/dist/factories/createDataset.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js"),Object.defineProperty(exports,"__esModule",{value:!0});const createStyleDeclaration_1=require("./createStyleDeclaration"),DATA_PREFIX="data-",attributeName=t=>`data-${(0,createStyleDeclaration_1.camelToKebab)(t)}`,dataAttributes=t=>{const e=[];for(let r=0;r<t.attributes.length;r++){const a=t.attributes.item(r).name;0===a.indexOf("data-")&&a.length>5&&e.push([a,(0,createStyleDeclaration_1.kebabToCamel)(a.slice(5))])}return e},createDataset=t=>new Proxy({},{get(e,r){if("string"!=typeof r)return;const a=t.getAttribute(attributeName(r));return null===a?void 0:a},set:(e,r,a)=>"string"==typeof r&&(t.setAttribute(attributeName(r),String(a)),!0),deleteProperty:(e,r)=>("string"==typeof r&&t.removeAttribute(attributeName(r)),!0),has:(e,r)=>"string"==typeof r&&t.hasAttribute(attributeName(r)),ownKeys:()=>dataAttributes(t).map(([,t])=>t),getOwnPropertyDescriptor(e,r){if("string"==typeof r&&t.hasAttribute(attributeName(r)))return{enumerable:!0,configurable:!0,value:t.getAttribute(attributeName(r))}}});exports.default=createDataset;

package/dist/factories/createStyleDeclaration.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file 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}
+ */
+declare const kebabToCamel: (name: string) => string;
+/**
+ * camelCase -> kebab-case ("backgroundColor" -> "background-color").
+ * @param {string} name
+ * @returns {string}
+ */
+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}
+ */
+declare const createStyleDeclaration: (cssText?: string) => CSSStyleDeclarationService;
+export { kebabToCamel, camelToKebab };
+export default createStyleDeclaration;

package/dist/factories/createStyleDeclaration.js

@@ -0,0 +1,64 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.camelToKebab = exports.kebabToCamel = void 0
+/**
+ * @file 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}
+ */
+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}
+ */
+const camelToKebab = name => name.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`)
+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}
+ */
+const createStyleDeclaration = (cssText = '') => {
+  const target = new CSSStyleDeclarationService_1.CSSStyleDeclarationService(cssText)
+  return new Proxy(target, {
+    get (declaration, property, receiver) {
+      if (typeof property !== 'string') {
+        return Reflect.get(declaration, property, receiver)
+      }
+      if (isIndex(property)) {
+        return declaration.item(Number(property))
+      }
+      if (property in declaration) {
+        return Reflect.get(declaration, property, receiver)
+      }
+      return declaration.getPropertyValue(camelToKebab(property))
+    },
+    set (declaration, property, value) {
+      if (typeof property !== 'string' || property === 'cssText') {
+        return Reflect.set(declaration, property, value)
+      }
+      declaration.setProperty(camelToKebab(property), value === null || typeof value === 'undefined' ? '' : String(value))
+      return true
+    },
+    has (declaration, property) {
+      return typeof property === 'string' && (property in declaration || declaration.getPropertyValue(camelToKebab(property)) !== '')
+    }
+  })
+}
+exports.default = createStyleDeclaration

package/dist/factories/createStyleDeclaration.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.camelToKebab=exports.kebabToCamel=void 0;const CSSStyleDeclarationService_1=require("../services/CSSStyleDeclarationService"),isIndex=e=>/^\d+$/.test(e),kebabToCamel=e=>e.replace(/-([a-z0-9])/gi,(e,t)=>t.toUpperCase());exports.kebabToCamel=kebabToCamel;const camelToKebab=e=>e.replace(/[A-Z]/g,e=>`-${e.toLowerCase()}`);exports.camelToKebab=camelToKebab;const createStyleDeclaration=(e="")=>{const t=new CSSStyleDeclarationService_1.CSSStyleDeclarationService(e);return new Proxy(t,{get:(e,t,a)=>"string"!=typeof t?Reflect.get(e,t,a):isIndex(t)?e.item(Number(t)):t in e?Reflect.get(e,t,a):e.getPropertyValue(camelToKebab(t)),set:(e,t,a)=>"string"!=typeof t||"cssText"===t?Reflect.set(e,t,a):(e.setProperty(camelToKebab(t),null==a?"":String(a)),!0),has:(e,t)=>"string"==typeof t&&(t in e||""!==e.getPropertyValue(camelToKebab(t)))})};exports.default=createStyleDeclaration;

package/dist/functions/getElementById.d.ts

@@ -1,13 +1,13 @@
-import { NodeService } from '../services/NodeService';
-import { PseudoElement } from '../interfaces/PseudoElement';
-/**
- * The first element, in tree order, below (not including) the given node whose id matches the given value, or null
- * when there is none. Shared by Document and DocumentFragment, which both implement the DOM's NonElementParentNode
- * mixin (so ShadowRoot, a DocumentFragment, gets it too).
- * @memberOf module:functions
- * @param {NodeService} root The node to search below
- * @param {string} id
- * @returns {PseudoElement|null}
- */
-declare const getElementById: (root: NodeService, id: string) => PseudoElement | null;
-export default getElementById;
+import { NodeService } from '../services/NodeService';
+import { PseudoElement } from '../interfaces/PseudoElement';
+/**
+ * The first element, in tree order, below (not including) the given node whose id matches the given value, or null
+ * when there is none. Shared by Document and DocumentFragment, which both implement the DOM's NonElementParentNode
+ * mixin (so ShadowRoot, a DocumentFragment, gets it too).
+ * @memberOf module:functions
+ * @param {NodeService} root The node to search below
+ * @param {string} id
+ * @returns {PseudoElement|null}
+ */
+declare const getElementById: (root: NodeService, id: string) => PseudoElement | null;
+export default getElementById;

package/dist/functions/getElementById.js

@@ -1,33 +1,33 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-const NodeService_1 = require('../services/NodeService')
-/**
- * The first element, in tree order, below (not including) the given node whose id matches the given value, or null
- * when there is none. Shared by Document and DocumentFragment, which both implement the DOM's NonElementParentNode
- * mixin (so ShadowRoot, a DocumentFragment, gets it too).
- * @memberOf module:functions
- * @param {NodeService} root The node to search below
- * @param {string} id
- * @returns {PseudoElement|null}
- */
-const getElementById = (root, id) => {
-  const search = node => {
-    for (const child of Array.from(node.childNodes)) {
-      if (child.nodeType === NodeService_1.NodeService.ELEMENT_NODE) {
-        if (child.id === id) {
-          return child
-        }
-        const found = search(child)
-        if (found) {
-          return found
-        }
-      }
-    }
-    return null
-  }
-  return search(root)
-}
-exports.default = getElementById
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+const NodeService_1 = require('../services/NodeService')
+/**
+ * The first element, in tree order, below (not including) the given node whose id matches the given value, or null
+ * when there is none. Shared by Document and DocumentFragment, which both implement the DOM's NonElementParentNode
+ * mixin (so ShadowRoot, a DocumentFragment, gets it too).
+ * @memberOf module:functions
+ * @param {NodeService} root The node to search below
+ * @param {string} id
+ * @returns {PseudoElement|null}
+ */
+const getElementById = (root, id) => {
+  const search = node => {
+    for (const child of Array.from(node.childNodes)) {
+      if (child.nodeType === NodeService_1.NodeService.ELEMENT_NODE) {
+        if (child.id === id) {
+          return child
+        }
+        const found = search(child)
+        if (found) {
+          return found
+        }
+      }
+    }
+    return null
+  }
+  return search(root)
+}
+exports.default = getElementById

package/dist/interfaces/PseudoCSSStyleDeclaration.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file Substitute for the DOM CSSStyleDeclaration Class. Real instances (from createStyleDeclaration) also accept
+ * arbitrary camelCase CSS property names (declaration.backgroundColor), which cannot be expressed in an interface.
+ */
+export interface PseudoCSSStyleDeclaration {
+    get length(): number;
+    get cssText(): string;
+    set cssText(cssText: string);
+    item(index: number): string;
+    getPropertyValue(property: string): string;
+    getPropertyPriority(property: string): string;
+    setProperty(property: string, value: string, priority: string): void;
+    removeProperty(property: string): string;
+}

package/dist/interfaces/PseudoCSSStyleDeclaration.js

@@ -0,0 +1,5 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})

package/dist/interfaces/PseudoCSSStyleDeclaration.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

package/dist/interfaces/PseudoDocument.d.ts

@@ -1,35 +1,35 @@
-import { PseudoNode } from './PseudoNode';
-import { PseudoElement } from './PseudoElement';
-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}
-     */
-    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}
-     */
-    createElement(tagName: string): PseudoElement;
-    /**
-     * Make a text node which belongs to this document.
-     * @param {string} [data=''] The text
-     * @returns {PseudoNode}
-     */
-    createTextNode(data: string): PseudoNode;
-    /**
-     * Make a comment which belongs to this document.
-     * @param {string} [data=''] The comment
-     * @returns {PseudoNode}
-     */
-    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;
-}
+import { PseudoNode } from './PseudoNode';
+import { PseudoElement } from './PseudoElement';
+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}
+     */
+    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}
+     */
+    createElement(tagName: string): PseudoElement;
+    /**
+     * Make a text node which belongs to this document.
+     * @param {string} [data=''] The text
+     * @returns {PseudoNode}
+     */
+    createTextNode(data: string): PseudoNode;
+    /**
+     * Make a comment which belongs to this document.
+     * @param {string} [data=''] The comment
+     * @returns {PseudoNode}
+     */
+    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

@@ -1,10 +1,10 @@
-import { PseudoNode } from './PseudoNode';
-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}
-     */
-    getElementById(id: string): PseudoElement | null;
-}
+import { PseudoNode } from './PseudoNode';
+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}
+     */
+    getElementById(id: string): PseudoElement | null;
+}