pseudo-dom 0.1.0

package/dist/services/EventService.js

@@ -0,0 +1,216 @@
+'use strict'
+
+/**
+ * @file Substitute for the DOM Event Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule
+    ? mod
+    : {
+        default: mod
+      }
+}
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.EventService = void 0
+const getParentNodes_1 = __importDefault(require('../functions/getParentNodes'))
+/**
+ * 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 {boolean} immediatePropagationStopped - Flag that no further propagation should occur, including on current
+ * target.
+ * @property {boolean} propagationStopped - Flag that no further propagation should occur.
+ * @property {int} eventPhase - Indicates which phase of the event flow is being processed. Uses EventService 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)
+ */
+class EventService {
+  /**
+   *
+   * @param {string} typeArg
+   * @param {Object} [eventOptions={}]
+   * @param {boolean} [eventOptions.bubbles=true]
+   * @param {boolean} [eventOptions.cancelable=true]
+   * @param {boolean} [eventOptions.composed=true]
+   * @constructor
+   */
+  constructor (typeArg = '', {
+    bubbles = true,
+    cancelable = true,
+    composed = true
+  } = {}) {
+    this.properties = {
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+      currentTarget: null,
+      defaultPrevented: false,
+      immediatePropagationStopped: false,
+      propagationStopped: false,
+      eventPhase: 0,
+      target: null,
+      timeStamp: Math.floor(Date.now() / 1000),
+      type: '',
+      isTrusted: true
+    }
+    this.setReadOnlyProperties({
+      type: typeArg,
+      bubbles,
+      cancelable,
+      composed
+    })
+  }
+
+  get bubbles () {
+    return this.properties.bubbles
+  }
+
+  get cancelable () {
+    return this.properties.cancelable
+  }
+
+  get composed () {
+    return this.properties.composed
+  }
+
+  get currentTarget () {
+    return this.properties.currentTarget
+  }
+
+  get defaultPrevented () {
+    return this.properties.defaultPrevented
+  }
+
+  get eventPhase () {
+    return this.properties.eventPhase
+  }
+
+  get isTrusted () {
+    return this.properties.isTrusted
+  }
+
+  get target () {
+    return this.properties.target
+  }
+
+  get timeStamp () {
+    return this.properties.timeStamp
+  }
+
+  get type () {
+    return this.properties.type
+  }
+
+  /**
+   * Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+   * @returns {EventInner}
+   */
+  get inner () {
+    const self = this
+    return {
+      set currentTarget (target) {
+        self.properties.currentTarget = target
+      },
+      set eventPhase (phase) {
+        self.properties.eventPhase = phase
+      },
+      set target (target) {
+        self.properties.target = target
+      },
+      get immediatePropagationStopped () {
+        return self.properties.immediatePropagationStopped
+      },
+      get propagationStopped () {
+        return self.properties.propagationStopped
+      }
+    }
+  }
+
+  /**
+   * 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 () {
+    switch (this.eventPhase) {
+      case EventService.CAPTURING_PHASE:
+        return (0, getParentNodes_1.default)(this.target)
+      case EventService.BUBBLING_PHASE:
+        return (0, getParentNodes_1.default)(this.target).slice().reverse()
+      case EventService.AT_TARGET:
+        return [this.target]
+      default:
+        return []
+    }
+  }
+
+  /**
+   * Cancels the event (if it is cancelable).
+   * @method
+   * @returns {null}
+   */
+  preventDefault () {
+    this.setReadOnlyProperties({
+      defaultPrevented: true
+    })
+    return 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 () {
+    this.setReadOnlyProperties({
+      immediatePropagationStopped: true
+    })
+    return null
+  }
+
+  /**
+   * Stops the propagation of events further along in the Dom.
+   * @method
+   * @returns {null}
+   */
+  stopPropagation () {
+    this.setReadOnlyProperties({
+      propagationStopped: true
+    })
+    return null
+  }
+
+  setReadOnlyProperties (updateProps = {}) {
+    this.properties = Object.assign({}, this.properties, updateProps)
+    return this
+  }
+}
+exports.EventService = EventService
+EventService.NONE = 0
+EventService.CAPTURING_PHASE = 1
+EventService.AT_TARGET = 2
+EventService.BUBBLING_PHASE = 3

package/dist/services/EventService.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.EventService=void 0;const getParentNodes_1=__importDefault(require("../functions/getParentNodes"));class EventService{constructor(e="",{bubbles:t=!0,cancelable:r=!0,composed:s=!0}={}){this.properties={bubbles:!0,cancelable:!0,composed:!0,currentTarget:null,defaultPrevented:!1,immediatePropagationStopped:!1,propagationStopped:!1,eventPhase:0,target:null,timeStamp:Math.floor(Date.now()/1e3),type:"",isTrusted:!0},this.setReadOnlyProperties({type:e,bubbles:t,cancelable:r,composed:s})}get bubbles(){return this.properties.bubbles}get cancelable(){return this.properties.cancelable}get composed(){return this.properties.composed}get currentTarget(){return this.properties.currentTarget}get defaultPrevented(){return this.properties.defaultPrevented}get eventPhase(){return this.properties.eventPhase}get isTrusted(){return this.properties.isTrusted}get target(){return this.properties.target}get timeStamp(){return this.properties.timeStamp}get type(){return this.properties.type}get inner(){const e=this;return{set currentTarget(t){e.properties.currentTarget=t},set eventPhase(t){e.properties.eventPhase=t},set target(t){e.properties.target=t},get immediatePropagationStopped(){return e.properties.immediatePropagationStopped},get propagationStopped(){return e.properties.propagationStopped}}}composedPath(){switch(this.eventPhase){case EventService.CAPTURING_PHASE:return(0,getParentNodes_1.default)(this.target);case EventService.BUBBLING_PHASE:return(0,getParentNodes_1.default)(this.target).slice().reverse();case EventService.AT_TARGET:return[this.target];default:return[]}}preventDefault(){return this.setReadOnlyProperties({defaultPrevented:!0}),null}stopImmediatePropagation(){return this.setReadOnlyProperties({immediatePropagationStopped:!0}),null}stopPropagation(){return this.setReadOnlyProperties({propagationStopped:!0}),null}setReadOnlyProperties(e={}){return this.properties=Object.assign({},this.properties,e),this}}exports.EventService=EventService,EventService.NONE=0,EventService.CAPTURING_PHASE=1,EventService.AT_TARGET=2,EventService.BUBBLING_PHASE=3;

package/dist/services/EventTargetService.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @file Substitute for the DOM EventTarget Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { EventService } from './EventService';
+import { listenerOptions, PseudoEventTarget } from '../interfaces/PseudoEventTarget';
+/**
+ * Simulate the behaviour of the EventTarget Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @property {Object.<string, Array.<PseudoEventListener>>} listeners
+ * @property {function} addEventListener
+ * @property {function} removeEventListener
+ * @property {function} dispatchEvent
+ */
+declare class EventTargetService implements PseudoEventTarget {
+    private readonly listeners;
+    private readonly defaultEvent;
+    /**
+     * @constructor
+     */
+    constructor();
+    /**
+     * The listeners registered for a type of event, creating the (empty) list of them when there are none yet.
+     * @param {string} type
+     * @returns {LinkedList}
+     */
+    private listenersFor;
+    /**
+     * Run each of the listeners registered on this target for the type of the event.
+     * Listeners which do not apply to the event's phase are skipped, running stops once immediate propagation is stopped,
+     * and listeners added or removed while running do not change which ones run for this event.
+     * @param {EventService} event
+     * @returns {*} true when there was nothing registered, otherwise the last value returned from a handler (null when none ran)
+     */
+    private runEvents;
+    /**
+     * Register the function to run when nothing else has prevented the default for this type of event.
+     * @param {string} type
+     * @param {Function} callback
+     */
+    protected setDefaultEvent(type: string, callback: Function): void;
+    private runDefaultEvent;
+    private startEvents;
+    addEventListener(type: string, callback: Function | {
+        handleEvent: Function;
+    } | any, useCapture?: listenerOptions | boolean): void;
+    removeEventListener(type: string, callback: Function): void;
+    dispatchEvent(event: EventService, target?: EventTargetService): boolean;
+}
+export default EventTargetService;

package/dist/services/EventTargetService.js

@@ -0,0 +1,163 @@
+'use strict'
+
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.filter.js')
+require('core-js/modules/esnext.iterator.find.js')
+require('core-js/modules/esnext.iterator.for-each.js')
+const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule
+    ? mod
+    : {
+        default: mod
+      }
+}
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+/**
+ * @file Substitute for the DOM EventTarget Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const EventService_1 = require('./EventService')
+const PseudoEventListener_1 = __importDefault(require('../classes/PseudoEventListener'))
+const LinkedList_1 = require('collect-your-stuff/dist/collections/linked-list/LinkedList')
+/**
+ * Simulate the behaviour of the EventTarget Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @property {Object.<string, Array.<PseudoEventListener>>} listeners
+ * @property {function} addEventListener
+ * @property {function} removeEventListener
+ * @property {function} dispatchEvent
+ */
+class EventTargetService {
+  /**
+   * @constructor
+   */
+  constructor () {
+    this.listeners = {}
+    this.defaultEvent = {}
+  }
+
+  /**
+   * The listeners registered for a type of event, creating the (empty) list of them when there are none yet.
+   * @param {string} type
+   * @returns {LinkedList}
+   */
+  listenersFor (type) {
+    if (!(type in this.listeners)) {
+      this.listeners[type] = new LinkedList_1.LinkedList()
+    }
+    return this.listeners[type]
+  }
+
+  /**
+   * Run each of the listeners registered on this target for the type of the event.
+   * Listeners which do not apply to the event's phase are skipped, running stops once immediate propagation is stopped,
+   * and listeners added or removed while running do not change which ones run for this event.
+   * @param {EventService} event
+   * @returns {*} true when there was nothing registered, otherwise the last value returned from a handler (null when none ran)
+   */
+  runEvents (event) {
+    if (!(event.type in this.listeners)) {
+      return true
+    }
+    const listeners = this.listeners[event.type]
+    let eventReturn = null
+    // Work from a copy of the linkers so that removing a listener (for example a once listener) does not disturb the walk
+    for (const linker of Array.from(listeners)) {
+      const listener = linker.data
+      if (event.inner.immediatePropagationStopped) {
+        break
+      }
+      if (listener.rejectEvent(event)) {
+        continue
+      }
+      eventReturn = listener.handleEvent(event)
+      if (listener.once) {
+        listeners.remove(linker)
+      }
+    }
+    return eventReturn
+  }
+
+  /**
+   * Register the function to run when nothing else has prevented the default for this type of event.
+   * @param {string} type
+   * @param {Function} callback
+   */
+  setDefaultEvent (type, callback) {
+    this.listenersFor(type)
+    this.defaultEvent[type] = callback
+  }
+
+  runDefaultEvent (event) {
+    if (event.defaultPrevented) {
+      return false
+    }
+    this.defaultEvent[event.type](event)
+    return true
+  }
+
+  startEvents (eventType) {
+    const event = new EventService_1.EventService(eventType)
+    event.inner.target = this;
+    [EventService_1.EventService.CAPTURING_PHASE, EventService_1.EventService.AT_TARGET, EventService_1.EventService.BUBBLING_PHASE].forEach(phase => {
+      let continueEvents = null
+      if (phase === EventService_1.EventService.AT_TARGET || !event.inner.propagationStopped) {
+        event.inner.eventPhase = phase
+        event.composedPath().forEach(target => {
+          event.inner.currentTarget = target
+          continueEvents = event.currentTarget.runEvents(event)
+        })
+      }
+      if (event.eventPhase === EventService_1.EventService.AT_TARGET && typeof continueEvents !== 'boolean' && this.defaultEvent[eventType]) {
+        this.runDefaultEvent(event)
+      }
+    })
+    return true
+  }
+
+  addEventListener (type, callback, useCapture = false) {
+    let options = {
+      capture: false,
+      once: false,
+      passive: false
+    }
+    if (typeof useCapture === 'object') {
+      // Originally useCapture was a single boolean flag, later optional other flags can be used
+      // Here we take all the given flags from the object and assign them as the options
+      options = Object.assign(options, useCapture)
+    } else {
+      options.capture = useCapture
+    }
+    const listener = new PseudoEventListener_1.default(type, options, (callback.handleEvent || callback).bind(this), callback)
+    const listeners = this.listenersFor(type)
+    // Listeners run in the order they were added, except that listeners which are not defaults always come before the defaults
+    const firstDefault = Array.from(listeners).find(linker => linker.data.isDefault)
+    if (firstDefault && !listener.isDefault) {
+      listeners.insertBefore(firstDefault, listener)
+    } else {
+      listeners.append(listener)
+    }
+  }
+
+  removeEventListener (type, callback) {
+    if (!(type in this.listeners)) {
+      return
+    }
+    const listeners = this.listeners[type]
+    Array.from(listeners).filter(linker => !linker.data.isDefault && linker.data.callback === callback).forEach(linker => listeners.remove(linker))
+  }
+
+  dispatchEvent (event, target = this) {
+    event.inner.target = target
+    if (!(event.type in this.listeners)) {
+      return true
+    }
+    this.runEvents(event)
+    return !event.defaultPrevented
+  }
+}
+exports.default = EventTargetService

package/dist/services/EventTargetService.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.for-each.js");var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const EventService_1=require("./EventService"),PseudoEventListener_1=__importDefault(require("../classes/PseudoEventListener")),LinkedList_1=require("collect-your-stuff/dist/collections/linked-list/LinkedList");class EventTargetService{constructor(){this.listeners={},this.defaultEvent={}}listenersFor(e){return e in this.listeners||(this.listeners[e]=new LinkedList_1.LinkedList),this.listeners[e]}runEvents(e){if(!(e.type in this.listeners))return!0;const t=this.listeners[e.type];let r=null;for(const n of Array.from(t)){const s=n.data;if(e.inner.immediatePropagationStopped)break;s.rejectEvent(e)||(r=s.handleEvent(e),s.once&&t.remove(n))}return r}setDefaultEvent(e,t){this.listenersFor(e),this.defaultEvent[e]=t}runDefaultEvent(e){return!e.defaultPrevented&&(this.defaultEvent[e.type](e),!0)}startEvents(e){const t=new EventService_1.EventService(e);return t.inner.target=this,[EventService_1.EventService.CAPTURING_PHASE,EventService_1.EventService.AT_TARGET,EventService_1.EventService.BUBBLING_PHASE].forEach(r=>{let n=null;r!==EventService_1.EventService.AT_TARGET&&t.inner.propagationStopped||(t.inner.eventPhase=r,t.composedPath().forEach(e=>{t.inner.currentTarget=e,n=t.currentTarget.runEvents(t)})),t.eventPhase===EventService_1.EventService.AT_TARGET&&"boolean"!=typeof n&&this.defaultEvent[e]&&this.runDefaultEvent(t)}),!0}addEventListener(e,t,r=!1){let n={capture:!1,once:!1,passive:!1};"object"==typeof r?n=Object.assign(n,r):n.capture=r;const s=new PseudoEventListener_1.default(e,n,(t.handleEvent||t).bind(this),t),i=this.listenersFor(e),o=Array.from(i).find(e=>e.data.isDefault);o&&!s.isDefault?i.insertBefore(o,s):i.append(s)}removeEventListener(e,t){if(!(e in this.listeners))return;const r=this.listeners[e];Array.from(r).filter(e=>!e.data.isDefault&&e.data.callback===t).forEach(e=>r.remove(e))}dispatchEvent(e,t=this){return e.inner.target=t,!(e.type in this.listeners)||(this.runEvents(e),!e.defaultPrevented)}}exports.default=EventTargetService;

package/dist/services/HTMLCollectionService.d.ts

@@ -0,0 +1,3 @@
+import { PseudoHTMLCollection } from '../interfaces/PseudoHTMLCollection';
+export declare class HTMLCollectionService implements PseudoHTMLCollection {
+}

package/dist/services/HTMLCollectionService.js

@@ -0,0 +1,8 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.HTMLCollectionService = void 0
+class HTMLCollectionService {}
+exports.HTMLCollectionService = HTMLCollectionService

package/dist/services/HTMLCollectionService.min.js

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

package/dist/services/HTMLElementService.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Substitute for the DOM HTMLElement Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { PseudoHTMLElement } from '../interfaces/PseudoHTMLElement';
+import { PseudoNode } from '../interfaces/PseudoNode';
+import { ElementService } from './ElementService';
+/**
+ * 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 {Object} style - A container to define all applied inline-styles
+ * @property {string} title - The title attribute which affects the text visible on hover
+ */
+export declare class HTMLElementService extends ElementService implements Partial<PseudoHTMLElement> {
+    /**
+     * Simulate the HTMLElement object when the Dom is not available
+     * @param {Object} [elementOptions={}]
+     * @param {string} [elementOptions.tagName='']
+     * @param {PseudoNode|Object} [elementOptions.parent={}]
+     * @param {Array} [elementOptions.children=[]]
+     * @constructor
+     */
+    constructor({ tagName, parent, children }?: {
+        tagName?: string;
+        parent?: PseudoNode | null;
+        children?: Array<any>;
+    });
+}

package/dist/services/HTMLElementService.js

@@ -0,0 +1,68 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.HTMLElementService = void 0
+const ElementService_1 = require('./ElementService')
+/**
+ * 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 {Object} style - A container to define all applied inline-styles
+ * @property {string} title - The title attribute which affects the text visible on hover
+ */
+class HTMLElementService extends ElementService_1.ElementService {
+  /**
+   * Simulate the HTMLElement object when the Dom is not available
+   * @param {Object} [elementOptions={}]
+   * @param {string} [elementOptions.tagName='']
+   * @param {PseudoNode|Object} [elementOptions.parent={}]
+   * @param {Array} [elementOptions.children=[]]
+   * @constructor
+   */
+  constructor ({
+    tagName = '',
+    parent = null,
+    children = []
+  } = {}) {
+    super({
+      tagName,
+      attributes: [{
+        name: 'hidden',
+        value: false
+      }, {
+        name: 'offsetHeight',
+        value: 0
+      }, {
+        name: 'offsetLeft',
+        value: 0
+      }, {
+        name: 'offsetParent',
+        value: null
+      }, {
+        name: 'offsetTop',
+        value: 0
+      }, {
+        name: 'offsetWidth',
+        value: 0
+      }, {
+        name: 'style',
+        value: {}
+      }, {
+        name: 'title',
+        value: ''
+      }],
+      parent,
+      children
+    })
+  }
+}
+exports.HTMLElementService = HTMLElementService

package/dist/services/HTMLElementService.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.HTMLElementService=void 0;const ElementService_1=require("./ElementService");class HTMLElementService extends ElementService_1.ElementService{constructor({tagName:e="",parent:t=null,children:n=[]}={}){super({tagName:e,attributes:[{name:"hidden",value:!1},{name:"offsetHeight",value:0},{name:"offsetLeft",value:0},{name:"offsetParent",value:null},{name:"offsetTop",value:0},{name:"offsetWidth",value:0},{name:"style",value:{}},{name:"title",value:""}],parent:t,children:n})}}exports.HTMLElementService=HTMLElementService;

package/dist/services/HTMLSlotElementService.d.ts

@@ -0,0 +1,4 @@
+import { PseudoHTMLSlotElement } from '../interfaces/PseudoHTMLSlotElement';
+import { HTMLElementService } from './HTMLElementService';
+export declare class HTMLSlotElementService extends HTMLElementService implements Partial<PseudoHTMLSlotElement> {
+}

package/dist/services/HTMLSlotElementService.js

@@ -0,0 +1,9 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.HTMLSlotElementService = void 0
+const HTMLElementService_1 = require('./HTMLElementService')
+class HTMLSlotElementService extends HTMLElementService_1.HTMLElementService {}
+exports.HTMLSlotElementService = HTMLSlotElementService

package/dist/services/HTMLSlotElementService.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.HTMLSlotElementService=void 0;const HTMLElementService_1=require("./HTMLElementService");class HTMLSlotElementService extends HTMLElementService_1.HTMLElementService{}exports.HTMLSlotElementService=HTMLSlotElementService;

package/dist/services/NamedNodeMapService.d.ts

@@ -0,0 +1,23 @@
+import { PseudoNamedNodeMap } from '../interfaces/PseudoNamedNodeMap';
+import { PseudoAttr } from '../interfaces/PseudoAttr';
+/**
+ * Simulate the behaviour of the NamedNodeMap Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ */
+export declare class NamedNodeMapService implements PseudoNamedNodeMap {
+    private attributes;
+    /**
+     * @param {Array<PseudoAttr>} [attributes=[]] The attributes to start with
+     * @constructor
+     */
+    constructor(attributes?: Array<PseudoAttr>);
+    get length(): number;
+    getNamedItem(name: string): PseudoAttr | null;
+    setNamedItem(attr: PseudoAttr): PseudoAttr | null;
+    removeNamedItem(attrName: string): PseudoAttr;
+    item(index: number): PseudoAttr | null;
+    getNamedItemNS(namespace: string, localName: string): PseudoAttr | null;
+    setNamedItemNS(attr: PseudoAttr): PseudoAttr | null;
+    removeNamedItemNS(namespace: string, localName: string): PseudoAttr;
+}