pseudo-dom 0.11.0 → 0.14.0

package/dist/factories/generateDocument.js

@@ -30,36 +30,53 @@ const generateDocument = (root, context = {}) => {
    */
   const newWindow = typeof root.document === 'undefined' ? root : new EventTargetService_1.default()
   /**
-   * @type {Node|PseudoNode}
+   * The Node class itself (matching the DOM's window.Node), not an instance - the right-hand side of `instanceof`
+   * must be a constructor, so `x instanceof Node` needs this, not `new PseudoNode()`.
+   * @type {Function}
    */
-  const Node = root.Node || new NodeService_1.NodeService()
+  const Node = root.Node || NodeService_1.NodeService
   if (typeof newWindow.Node === 'undefined') {
     newWindow.Node = Node
   }
   /**
-   *
-   * @type {Element|PseudoElement}
+   * The Element class itself, for the same reason as Node.
+   * @type {Function}
    */
-  const Element = root.Element || new ElementService_1.ElementService()
+  const Element = root.Element || ElementService_1.ElementService
   if (typeof newWindow.Element === 'undefined') {
     newWindow.Element = Element
   }
   /**
-   * Create an instance of HTMLElement if not available
-   * @type {HTMLElement|PseudoHTMLElement}
+   * The HTMLElement class itself, for the same reason as Node.
+   * @type {Function}
    */
-  const HTMLElement = root.HTMLElement || new HTMLElementService_1.HTMLElementService()
+  const HTMLElement = root.HTMLElement || HTMLElementService_1.HTMLElementService
   if (typeof newWindow.HTMLElement === 'undefined') {
     newWindow.HTMLElement = HTMLElement
   }
   /**
-   * Define document when not available
+   * The HTMLDocument class itself, for the same reason as Node (so `document instanceof HTMLDocument`, a common
+   * real-DOM-detection check, works).
+   * @type {Function}
+   */
+  const HTMLDocument = root.HTMLDocument || PseudoHTMLDocument_1.default
+  if (typeof newWindow.HTMLDocument === 'undefined') {
+    newWindow.HTMLDocument = HTMLDocument
+  }
+  /**
+   * Define document when not available - a real instance, unlike the classes above (window.document IS an object,
+   * not a constructor).
    * @type {Document|PseudoHTMLDocument}
    */
   const document = root.document || new PseudoHTMLDocument_1.default()
   if (typeof newWindow.document === 'undefined') {
     newWindow.document = document
   }
-  return context ? Object.assign(context, newWindow) : Object.assign(root, newWindow)
+  // When there was no real document, newWindow is root itself (see above), so every assignment above already
+  // mutated it directly. If context is also that same object (root and context given as one and the same, as
+  // installGlobal does) merging is already done - doing it again would be Object.assign(target, target), which
+  // throws on any getter-only own property target already has (globalThis.crypto, in Node).
+  const mergeInto = context || root
+  return newWindow === mergeInto ? newWindow : Object.assign(mergeInto, newWindow)
 }
 exports.default = generateDocument

package/dist/factories/generateDocument.min.js

@@ -1 +1 @@
-"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const EventTargetService_1=__importDefault(require("../services/EventTargetService")),NodeService_1=require("../services/NodeService"),ElementService_1=require("../services/ElementService"),HTMLElementService_1=require("../services/HTMLElementService"),PseudoHTMLDocument_1=__importDefault(require("../classes/PseudoHTMLDocument")),generateDocument=(e,t={})=>{const r=void 0===e.document?e:new EventTargetService_1.default,n=e.Node||new NodeService_1.NodeService;void 0===r.Node&&(r.Node=n);const c=e.Element||new ElementService_1.ElementService;void 0===r.Element&&(r.Element=c);const o=e.HTMLElement||new HTMLElementService_1.HTMLElementService;void 0===r.HTMLElement&&(r.HTMLElement=o);const i=e.document||new PseudoHTMLDocument_1.default;return void 0===r.document&&(r.document=i),t?Object.assign(t,r):Object.assign(e,r)};exports.default=generateDocument;
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const EventTargetService_1=__importDefault(require("../services/EventTargetService")),NodeService_1=require("../services/NodeService"),ElementService_1=require("../services/ElementService"),HTMLElementService_1=require("../services/HTMLElementService"),PseudoHTMLDocument_1=__importDefault(require("../classes/PseudoHTMLDocument")),generateDocument=(e,t={})=>{const n=void 0===e.document?e:new EventTargetService_1.default,r=e.Node||NodeService_1.NodeService;void 0===n.Node&&(n.Node=r);const o=e.Element||ElementService_1.ElementService;void 0===n.Element&&(n.Element=o);const c=e.HTMLElement||HTMLElementService_1.HTMLElementService;void 0===n.HTMLElement&&(n.HTMLElement=c);const i=e.HTMLDocument||PseudoHTMLDocument_1.default;void 0===n.HTMLDocument&&(n.HTMLDocument=i);const u=e.document||new PseudoHTMLDocument_1.default;void 0===n.document&&(n.document=u);const m=t||e;return n===m?n:Object.assign(m,n)};exports.default=generateDocument;

package/dist/factories/installGlobal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * When there is no real DOM already available (a real browser, or a jsdom-based test environment - isBrowser is
+ * true for both, since jsdom's window has a document too, and a jsdom document should never be overwritten, real
+ * DOM behaviour is always closer to the real thing), populate the given global-like target with document / Node /
+ * Element / HTMLElement / HTMLDocument, generated by generateDocument, plus window (a self-reference, matching a
+ * real browser's global scope - some code checks for a bare `window` before falling back to `global`), so code
+ * written against a real DOM's globals works as-is. Does nothing when a real DOM is already there, matching
+ * generateDocument's own only-fill-what-is-missing behaviour - calling this is always safe, in any environment.
+ * @memberOf module:factories
+ * @param {*} [target] The object to add document / Node / Element / HTMLElement / window onto - defaults to
+ * globalThis, so bare `document`, `Node`, `window`, etc. resolve from anywhere once this has run
+ * @returns {*} The same target, for convenience
+ */
+declare const installGlobal: (target?: any) => any;
+export default installGlobal;

package/dist/factories/installGlobal.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule
+    ? mod
+    : {
+        default: mod
+      }
+}
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+/**
+ * @file Makes pseudo-dom a drop-in swap for a real DOM: code written against bare globals (document.createElement,
+ * new Node(), ...) works unmodified, in the browser or in Node, without an if (typeof document === 'undefined')
+ * check at every call site.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const browser_or_node_1 = require('browser-or-node')
+const generateDocument_1 = __importDefault(require('./generateDocument'))
+/**
+ * When there is no real DOM already available (a real browser, or a jsdom-based test environment - isBrowser is
+ * true for both, since jsdom's window has a document too, and a jsdom document should never be overwritten, real
+ * DOM behaviour is always closer to the real thing), populate the given global-like target with document / Node /
+ * Element / HTMLElement / HTMLDocument, generated by generateDocument, plus window (a self-reference, matching a
+ * real browser's global scope - some code checks for a bare `window` before falling back to `global`), so code
+ * written against a real DOM's globals works as-is. Does nothing when a real DOM is already there, matching
+ * generateDocument's own only-fill-what-is-missing behaviour - calling this is always safe, in any environment.
+ * @memberOf module:factories
+ * @param {*} [target] The object to add document / Node / Element / HTMLElement / window onto - defaults to
+ * globalThis, so bare `document`, `Node`, `window`, etc. resolve from anywhere once this has run
+ * @returns {*} The same target, for convenience
+ */
+const installGlobal = (target = typeof globalThis !== 'undefined' ? globalThis : {}) => {
+  if (!browser_or_node_1.isBrowser) {
+    (0, generateDocument_1.default)(target, target)
+    if (typeof target.window === 'undefined') {
+      target.window = target
+    }
+  }
+  return target
+}
+exports.default = installGlobal

package/dist/factories/installGlobal.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const browser_or_node_1=require("browser-or-node"),generateDocument_1=__importDefault(require("./generateDocument")),installGlobal=(e=("undefined"!=typeof globalThis?globalThis:{}))=>(browser_or_node_1.isBrowser||((0,generateDocument_1.default)(e,e),void 0===e.window&&(e.window=e)),e);exports.default=installGlobal;

package/dist/factories/logElement.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Print a node's markup to the console, indented for readability (see prettyPrint).
+ * @memberOf module:factories
+ * @param {*} node
+ * @param {string} [label=''] A label printed above the markup, to identify this log call
+ * @returns {undefined}
+ */
+declare const logElement: (node: any, label?: string) => void;
+export default logElement;

package/dist/factories/logElement.js

@@ -0,0 +1,23 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+/**
+ * @file Prints an element (or any node) to the console, readably - the point of pseudo-dom running headlessly is
+ * usually to watch what code does to a tree without a real browser to look at.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const serializeHTML_1 = require('./serializeHTML')
+/**
+ * Print a node's markup to the console, indented for readability (see prettyPrint).
+ * @memberOf module:factories
+ * @param {*} node
+ * @param {string} [label=''] A label printed above the markup, to identify this log call
+ * @returns {undefined}
+ */
+const logElement = (node, label = '') => {
+  console.log(`${label ? `${label}\n` : ''}${(0, serializeHTML_1.prettyPrint)(node)}`)
+}
+exports.default = logElement

package/dist/factories/logElement.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const serializeHTML_1=require("./serializeHTML"),logElement=(e,t="")=>{console.log(`${t?`${t}\n`:""}${(0,serializeHTML_1.prettyPrint)(e)}`)};exports.default=logElement;

package/dist/factories/parseHTML.d.ts

@@ -1,13 +1,13 @@
-/**
- * Parse an HTML string into the nodes it describes (siblings at the top level, exactly like the DOM's own HTML
- * parsing does for innerHTML / insertAdjacentHTML - there is no single root unless the markup itself has one).
- * @memberOf module:factories
- * @param {string} html
- * @param {*} ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
- * @param {function(new: *, {tagName: string})} ElementClass The class to build each parsed element with
- * @returns {Array<*>}
- */
-declare const parseHTML: (html: string, ownerDocument: any, ElementClass: new (options: {
-    tagName: string;
-}) => any) => Array<any>;
-export default parseHTML;
+/**
+ * Parse an HTML string into the nodes it describes (siblings at the top level, exactly like the DOM's own HTML
+ * parsing does for innerHTML / insertAdjacentHTML - there is no single root unless the markup itself has one).
+ * @memberOf module:factories
+ * @param {string} html
+ * @param {*} ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
+ * @param {function(new: *, {tagName: string})} ElementClass The class to build each parsed element with
+ * @returns {Array<*>}
+ */
+declare const parseHTML: (html: string, ownerDocument: any, ElementClass: new (options: {
+    tagName: string;
+}) => any) => Array<any>;
+export default parseHTML;

package/dist/factories/parseHTML.js

@@ -1,84 +1,84 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-/**
- * @file Parses an HTML string into pseudo-dom nodes, for innerHTML / outerHTML / insertAdjacentHTML. Built on
- * htmlparser2's Parser (a SAX-style tokenizer) with a custom handler which builds pseudo-dom nodes directly -
- * htmlparser2's own default DomHandler / domutils tree (which this never uses) is stubbed out of the browser bundle
- * by the browser.ignore config, the same way css-select's unused default adapter already is.
- *
- * The class to build parsed elements with is given by the caller (rather than imported here) so this has no
- * dependency on ElementService / HTMLElementService - importing either here, from a factory ElementService itself
- * would need to call, would create an import cycle.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-const htmlparser2_1 = require('htmlparser2')
-const NodeService_1 = require('../services/NodeService')
-/**
- * Parse an HTML string into the nodes it describes (siblings at the top level, exactly like the DOM's own HTML
- * parsing does for innerHTML / insertAdjacentHTML - there is no single root unless the markup itself has one).
- * @memberOf module:factories
- * @param {string} html
- * @param {*} ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
- * @param {function(new: *, {tagName: string})} ElementClass The class to build each parsed element with
- * @returns {Array<*>}
- */
-const parseHTML = (html, ownerDocument, ElementClass) => {
-  const roots = []
-  const stack = []
-  const appendNode = node => {
-    node.ownerDocumentStore = ownerDocument
-    if (stack.length) {
-      stack[stack.length - 1].appendChild(node)
-    } else {
-      roots.push(node)
-    }
-  }
-  const parser = new htmlparser2_1.Parser({
-    onopentagname (name) {
-      const element = new ElementClass({
-        tagName: name
-      })
-      appendNode(element)
-      stack.push(element)
-    },
-    onattribute (name, value) {
-      if (!stack.length) {
-        return
-      }
-      const element = stack[stack.length - 1]
-      // pseudo-dom's className / classList and style are not kept in sync with a literal 'class' / 'style'
-      // attribute the way setAttribute usually is (there is no such special-casing here, unlike a real DOM) - route
-      // them to the real objects directly, the same way cssSelectAdapter does for reading 'class' when matching a
-      // CSS selector, so parsed markup's class="..." / style="..." actually populates className/classList and style.
-      if (name === 'class') {
-        element.className = value
-        return
-      }
-      if (name === 'style' && element.style) {
-        element.style.cssText = value
-        return
-      }
-      element.setAttribute(name, value)
-    },
-    ontext (text) {
-      appendNode(new NodeService_1.TextService(text))
-    },
-    oncomment (data) {
-      appendNode(new NodeService_1.CommentService(data))
-    },
-    onclosetag () {
-      stack.pop()
-    }
-  }, {
-    lowerCaseTags: true,
-    lowerCaseAttributeNames: true
-  })
-  parser.write(String(html || ''))
-  parser.end()
-  return roots
-}
-exports.default = parseHTML
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+/**
+ * @file Parses an HTML string into pseudo-dom nodes, for innerHTML / outerHTML / insertAdjacentHTML. Built on
+ * htmlparser2's Parser (a SAX-style tokenizer) with a custom handler which builds pseudo-dom nodes directly -
+ * htmlparser2's own default DomHandler / domutils tree (which this never uses) is stubbed out of the browser bundle
+ * by the browser.ignore config, the same way css-select's unused default adapter already is.
+ *
+ * The class to build parsed elements with is given by the caller (rather than imported here) so this has no
+ * dependency on ElementService / HTMLElementService - importing either here, from a factory ElementService itself
+ * would need to call, would create an import cycle.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const htmlparser2_1 = require('htmlparser2')
+const NodeService_1 = require('../services/NodeService')
+/**
+ * Parse an HTML string into the nodes it describes (siblings at the top level, exactly like the DOM's own HTML
+ * parsing does for innerHTML / insertAdjacentHTML - there is no single root unless the markup itself has one).
+ * @memberOf module:factories
+ * @param {string} html
+ * @param {*} ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
+ * @param {function(new: *, {tagName: string})} ElementClass The class to build each parsed element with
+ * @returns {Array<*>}
+ */
+const parseHTML = (html, ownerDocument, ElementClass) => {
+  const roots = []
+  const stack = []
+  const appendNode = node => {
+    node.ownerDocumentStore = ownerDocument
+    if (stack.length) {
+      stack[stack.length - 1].appendChild(node)
+    } else {
+      roots.push(node)
+    }
+  }
+  const parser = new htmlparser2_1.Parser({
+    onopentagname (name) {
+      const element = new ElementClass({
+        tagName: name
+      })
+      appendNode(element)
+      stack.push(element)
+    },
+    onattribute (name, value) {
+      if (!stack.length) {
+        return
+      }
+      const element = stack[stack.length - 1]
+      // pseudo-dom's className / classList and style are not kept in sync with a literal 'class' / 'style'
+      // attribute the way setAttribute usually is (there is no such special-casing here, unlike a real DOM) - route
+      // them to the real objects directly, the same way cssSelectAdapter does for reading 'class' when matching a
+      // CSS selector, so parsed markup's class="..." / style="..." actually populates className/classList and style.
+      if (name === 'class') {
+        element.className = value
+        return
+      }
+      if (name === 'style' && element.style) {
+        element.style.cssText = value
+        return
+      }
+      element.setAttribute(name, value)
+    },
+    ontext (text) {
+      appendNode(new NodeService_1.TextService(text))
+    },
+    oncomment (data) {
+      appendNode(new NodeService_1.CommentService(data))
+    },
+    onclosetag () {
+      stack.pop()
+    }
+  }, {
+    lowerCaseTags: true,
+    lowerCaseAttributeNames: true
+  })
+  parser.write(String(html || ''))
+  parser.end()
+  return roots
+}
+exports.default = parseHTML

package/dist/factories/serializeHTML.d.ts

@@ -1,15 +1,25 @@
-/**
- * A node's children, serialized in order (this is what innerHTML returns).
- * @memberOf module:factories
- * @param {*} node
- * @returns {string}
- */
-declare const serializeChildren: (node: any) => string;
-/**
- * An element itself, serialized with its children (this is what outerHTML returns).
- * @memberOf module:factories
- * @param {*} element
- * @returns {string}
- */
-declare const serializeOuter: (element: any) => string;
-export { serializeChildren, serializeOuter };
+/**
+ * A node's children, serialized in order (this is what innerHTML returns).
+ * @memberOf module:factories
+ * @param {*} node
+ * @returns {string}
+ */
+declare const serializeChildren: (node: any) => string;
+/**
+ * An element itself, serialized with its children (this is what outerHTML returns).
+ * @memberOf module:factories
+ * @param {*} element
+ * @returns {string}
+ */
+declare const serializeOuter: (element: any) => string;
+/**
+ * A node's markup, indented one level per level of nesting - a real DOM's outerHTML / innerHTML has no line breaks
+ * at all, which does not read well for a whole tree (a board full of cells, say). Useful for watching pseudo-dom-
+ * driven code run headlessly, printed to a terminal - see also logElement, which does the printing too.
+ * @memberOf module:factories
+ * @param {*} node
+ * @param {string} [indent='  '] The indentation used per level of nesting
+ * @returns {string}
+ */
+declare const prettyPrint: (node: any, indent?: string) => string;
+export { serializeChildren, serializeOuter, prettyPrint };

package/dist/factories/serializeHTML.js

@@ -22,7 +22,7 @@ require('core-js/modules/esnext.set.union.js')
 Object.defineProperty(exports, '__esModule', {
   value: true
 })
-exports.serializeOuter = exports.serializeChildren = void 0
+exports.prettyPrint = exports.serializeOuter = exports.serializeChildren = void 0
 /**
  * @file Serializes pseudo-dom nodes back into an HTML string, for innerHTML / outerHTML.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -43,17 +43,21 @@ const ATTRIBUTE_NAME = {
 // Boolean HTML attributes: present (with no value) when true, absent entirely when false
 const BOOLEAN_ATTRIBUTES = new Set(['hidden'])
 /**
- * Escape text so it is safe inside HTML text content.
- * @param {string} text
+ * Escape text so it is safe inside HTML text content. Coerces to a string first - unlike a real DOM, pseudo-dom's
+ * setAttribute does not itself coerce (see the same note on escapeAttributeValue), and nodeValue is not guaranteed
+ * to be a string either.
+ * @param {*} text
  * @returns {string}
  */
-const escapeText = text => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+const escapeText = text => String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
 /**
- * Escape a value so it is safe inside a double-quoted HTML attribute.
- * @param {string} value
+ * Escape a value so it is safe inside a double-quoted HTML attribute. Coerces to a string first: a real DOM's
+ * setAttribute always stores a string, however pseudo-dom's does not coerce what it is given, so a value set via
+ * setAttribute(name, 5) is stored (and read back by getAttribute) as the number 5, not the string '5'.
+ * @param {*} value
  * @returns {string}
  */
-const escapeAttributeValue = value => value.replace(/&/g, '&amp;').replace(/"/g, '&quot;')
+const escapeAttributeValue = value => String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;')
 /**
  * Every attribute of the element, serialized (class instead of className, boolean attributes bare, the never-real
  * mock properties left out, style added from the live CSSStyleDeclaration when it is not empty).
@@ -112,3 +116,45 @@ exports.serializeChildren = serializeChildren
  */
 const serializeOuter = element => serializeNode(element)
 exports.serializeOuter = serializeOuter
+/**
+ * One node, indented for readability (see prettyPrint) - unlike serializeNode, every non-empty node is its own
+ * line, so the structure of a whole tree is easy to read at a glance.
+ * @param {*} node
+ * @param {number} depth
+ * @param {string} indent
+ * @returns {string}
+ */
+const prettyPrintNode = (node, depth, indent) => {
+  const pad = indent.repeat(depth)
+  if (node.nodeType === NodeService_1.NodeService.TEXT_NODE) {
+    const text = escapeText((node.nodeValue || '').trim())
+    return text ? `${pad}${text}` : ''
+  }
+  if (node.nodeType === NodeService_1.NodeService.COMMENT_NODE) {
+    return `${pad}<!--${node.nodeValue || ''}-->`
+  }
+  if (node.nodeType !== NodeService_1.NodeService.ELEMENT_NODE) {
+    return ''
+  }
+  const tagName = node.tagName
+  const attributes = serializeAttributes(node)
+  if (VOID_ELEMENTS.has(tagName)) {
+    return `${pad}<${tagName}${attributes}>`
+  }
+  const children = Array.from(node.childNodes).map(child => prettyPrintNode(child, depth + 1, indent)).filter(line => line !== '')
+  if (children.length === 0) {
+    return `${pad}<${tagName}${attributes}></${tagName}>`
+  }
+  return `${pad}<${tagName}${attributes}>\n${children.join('\n')}\n${pad}</${tagName}>`
+}
+/**
+ * A node's markup, indented one level per level of nesting - a real DOM's outerHTML / innerHTML has no line breaks
+ * at all, which does not read well for a whole tree (a board full of cells, say). Useful for watching pseudo-dom-
+ * driven code run headlessly, printed to a terminal - see also logElement, which does the printing too.
+ * @memberOf module:factories
+ * @param {*} node
+ * @param {string} [indent='  '] The indentation used per level of nesting
+ * @returns {string}
+ */
+const prettyPrint = (node, indent = '  ') => prettyPrintNode(node, 0, indent)
+exports.prettyPrint = prettyPrint

package/dist/factories/serializeHTML.min.js

@@ -1 +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.map.js"),require("core-js/modules/esnext.set.add-all.js"),require("core-js/modules/esnext.set.delete-all.js"),require("core-js/modules/esnext.set.difference.js"),require("core-js/modules/esnext.set.every.js"),require("core-js/modules/esnext.set.filter.js"),require("core-js/modules/esnext.set.find.js"),require("core-js/modules/esnext.set.intersection.js"),require("core-js/modules/esnext.set.is-disjoint-from.js"),require("core-js/modules/esnext.set.is-subset-of.js"),require("core-js/modules/esnext.set.is-superset-of.js"),require("core-js/modules/esnext.set.join.js"),require("core-js/modules/esnext.set.map.js"),require("core-js/modules/esnext.set.reduce.js"),require("core-js/modules/esnext.set.some.js"),require("core-js/modules/esnext.set.symmetric-difference.js"),require("core-js/modules/esnext.set.union.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.serializeOuter=exports.serializeChildren=void 0;const NodeService_1=require("../services/NodeService"),VOID_ELEMENTS=new Set(["area","base","br","col","embed","hr","img","input","link","meta","param","source","track","wbr"]),NEVER_SERIALIZE=new Set(["innerHTML","clientHeight","clientLeft","clientTop","clientWidth","scrollHeight","scrollLeft","scrollTop","scrollWidth","offsetHeight","offsetLeft","offsetParent","offsetTop","offsetWidth"]),ATTRIBUTE_NAME={className:"class"},BOOLEAN_ATTRIBUTES=new Set(["hidden"]),escapeText=e=>e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;"),escapeAttributeValue=e=>e.replace(/&/g,"&amp;").replace(/"/g,"&quot;"),serializeAttributes=e=>{let s=(e.getAttributeNames?e.getAttributeNames():[]).filter(e=>!NEVER_SERIALIZE.has(e)).map(s=>{if(BOOLEAN_ATTRIBUTES.has(s))return e[s]?` ${s}`:"";const r=e.getAttribute(s);return""===r?"":` ${ATTRIBUTE_NAME[s]||s}="${escapeAttributeValue(r)}"`}).join("");const r=e.style;return r&&r.cssText&&(s+=` style="${escapeAttributeValue(r.cssText)}"`),s},serializeNode=e=>{if(e.nodeType===NodeService_1.NodeService.TEXT_NODE)return escapeText(e.nodeValue||"");if(e.nodeType===NodeService_1.NodeService.COMMENT_NODE)return`\x3c!--${e.nodeValue||""}--\x3e`;if(e.nodeType!==NodeService_1.NodeService.ELEMENT_NODE)return"";const s=e.tagName,r=serializeAttributes(e);return VOID_ELEMENTS.has(s)?`<${s}${r}>`:`<${s}${r}>${serializeChildren(e)}</${s}>`},serializeChildren=e=>Array.from(e.childNodes).map(serializeNode).join("");exports.serializeChildren=serializeChildren;const serializeOuter=e=>serializeNode(e);exports.serializeOuter=serializeOuter;
+"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.set.add-all.js"),require("core-js/modules/esnext.set.delete-all.js"),require("core-js/modules/esnext.set.difference.js"),require("core-js/modules/esnext.set.every.js"),require("core-js/modules/esnext.set.filter.js"),require("core-js/modules/esnext.set.find.js"),require("core-js/modules/esnext.set.intersection.js"),require("core-js/modules/esnext.set.is-disjoint-from.js"),require("core-js/modules/esnext.set.is-subset-of.js"),require("core-js/modules/esnext.set.is-superset-of.js"),require("core-js/modules/esnext.set.join.js"),require("core-js/modules/esnext.set.map.js"),require("core-js/modules/esnext.set.reduce.js"),require("core-js/modules/esnext.set.some.js"),require("core-js/modules/esnext.set.symmetric-difference.js"),require("core-js/modules/esnext.set.union.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.prettyPrint=exports.serializeOuter=exports.serializeChildren=void 0;const NodeService_1=require("../services/NodeService"),VOID_ELEMENTS=new Set(["area","base","br","col","embed","hr","img","input","link","meta","param","source","track","wbr"]),NEVER_SERIALIZE=new Set(["innerHTML","clientHeight","clientLeft","clientTop","clientWidth","scrollHeight","scrollLeft","scrollTop","scrollWidth","offsetHeight","offsetLeft","offsetParent","offsetTop","offsetWidth"]),ATTRIBUTE_NAME={className:"class"},BOOLEAN_ATTRIBUTES=new Set(["hidden"]),escapeText=e=>String(e).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;"),escapeAttributeValue=e=>String(e).replace(/&/g,"&amp;").replace(/"/g,"&quot;"),serializeAttributes=e=>{let r=(e.getAttributeNames?e.getAttributeNames():[]).filter(e=>!NEVER_SERIALIZE.has(e)).map(r=>{if(BOOLEAN_ATTRIBUTES.has(r))return e[r]?` ${r}`:"";const t=e.getAttribute(r);return""===t?"":` ${ATTRIBUTE_NAME[r]||r}="${escapeAttributeValue(t)}"`}).join("");const t=e.style;return t&&t.cssText&&(r+=` style="${escapeAttributeValue(t.cssText)}"`),r},serializeNode=e=>{if(e.nodeType===NodeService_1.NodeService.TEXT_NODE)return escapeText(e.nodeValue||"");if(e.nodeType===NodeService_1.NodeService.COMMENT_NODE)return`\x3c!--${e.nodeValue||""}--\x3e`;if(e.nodeType!==NodeService_1.NodeService.ELEMENT_NODE)return"";const r=e.tagName,t=serializeAttributes(e);return VOID_ELEMENTS.has(r)?`<${r}${t}>`:`<${r}${t}>${serializeChildren(e)}</${r}>`},serializeChildren=e=>Array.from(e.childNodes).map(serializeNode).join("");exports.serializeChildren=serializeChildren;const serializeOuter=e=>serializeNode(e);exports.serializeOuter=serializeOuter;const prettyPrintNode=(e,r,t)=>{const s=t.repeat(r);if(e.nodeType===NodeService_1.NodeService.TEXT_NODE){const r=escapeText((e.nodeValue||"").trim());return r?`${s}${r}`:""}if(e.nodeType===NodeService_1.NodeService.COMMENT_NODE)return`${s}\x3c!--${e.nodeValue||""}--\x3e`;if(e.nodeType!==NodeService_1.NodeService.ELEMENT_NODE)return"";const i=e.tagName,o=serializeAttributes(e);if(VOID_ELEMENTS.has(i))return`${s}<${i}${o}>`;const n=Array.from(e.childNodes).map(e=>prettyPrintNode(e,r+1,t)).filter(e=>""!==e);return 0===n.length?`${s}<${i}${o}></${i}>`:`${s}<${i}${o}>\n${n.join("\n")}\n${s}</${i}>`},prettyPrint=(e,r="  ")=>prettyPrintNode(e,0,r);exports.prettyPrint=prettyPrint;