pseudo-dom 0.12.0 → 0.15.0

package/README.md

@@ -54,7 +54,10 @@ else, document fragments insert their children instead of themselves, and a node
 
 **Attribute helpers** work like the DOM's: `getAttributeNames`, `hasAttributes`, `toggleAttribute(name, [force])`.
 `localName` matches `tagName` and `prefix` is always `null` (there's no real namespace parsing);
-`getElementsByTagNameNS` behaves exactly like `getElementsByTagName`, ignoring the namespace.
+`getElementsByTagNameNS` behaves exactly like `getElementsByTagName`, ignoring the namespace. All 37 `aria*`
+reflected properties (`ariaLabel`, `ariaExpanded`, `ariaValueNow`, ...) are real too - each just reads/writes its
+matching `aria-*` attribute (`ariaLabel` <-> `aria-label`; the mapping isn't camelCase-to-kebab-case, so
+`ariaColCount` <-> `aria-colcount`, not `aria-col-count`).
 
 **`style`** is a real, live `CSSStyleDeclaration`:
 
@@ -144,10 +147,12 @@ if (typeof document === 'undefined') {
 }
 ```
 
-`installGlobal(target = globalThis)` fills in `document` / `Node` / `Element` / `HTMLElement` on `target`, using
+`installGlobal(target = globalThis)` fills in `document` / `Node` / `Element` / `HTMLElement` / `HTMLDocument` /
+`window` (a self-reference, like a real browser's) on `target`, using
 [browser-or-node](https://www.npmjs.com/package/browser-or-node) to check whether a real DOM (a real browser, or a
 jsdom-based test environment) is already there first - it's always safe to call, everywhere: it does nothing when
-one is.
+one is. `Node` / `Element` / `HTMLElement` / `HTMLDocument` are the classes themselves (not instances), so
+`x instanceof Element` works, matching the real DOM's.
 
 There's no real rendering to look at, so `logElement(node, [label])` prints a readable, indented view of a node's
 markup to the console (`prettyPrint(node, [indent])`, from the same module, returns the string instead of printing
@@ -166,7 +171,6 @@ it) - useful for watching pseudo-dom-driven code run, or checking a final result
 
 ## Not implemented yet
 
-- The `aria*` reflected properties
 - The `Attr`-node / namespaced attribute methods (`getAttributeNode`, `getAttributeNS`, ...)
 ## Modules
 
@@ -317,10 +321,14 @@ order in which an event travels down through them). A node which has no parent h
 <dd><p>Remember the element which has the focus in a tree.</p>
 </dd>
 <dt><a href="#escapeText">escapeText(text)</a> ⇒ <code>string</code></dt>
-<dd><p>Escape text so it is safe inside HTML text content.</p>
+<dd><p>Escape text so it is safe inside HTML text content. Coerces to a string first - unlike a real DOM, pseudo-dom&#39;s
+setAttribute does not itself coerce (see the same note on escapeAttributeValue), and nodeValue is not guaranteed
+to be a string either.</p>
 </dd>
 <dt><a href="#escapeAttributeValue">escapeAttributeValue(value)</a> ⇒ <code>string</code></dt>
-<dd><p>Escape a value so it is safe inside a double-quoted HTML attribute.</p>
+<dd><p>Escape a value so it is safe inside a double-quoted HTML attribute. Coerces to a string first: a real DOM&#39;s
+setAttribute always stores a string, however pseudo-dom&#39;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 &#39;5&#39;.</p>
 </dd>
 <dt><a href="#serializeAttributes">serializeAttributes(element)</a> ⇒ <code>string</code></dt>
 <dd><p>Every attribute of the element, serialized (class instead of className, boolean attributes bare, the never-real
@@ -2969,6 +2977,8 @@ Simulate the behaviour of the Element Class when there is no DOM available.
     * [.requestFullscreen()](#ElementService+requestFullscreen) ⇒ <code>Promise.&lt;void&gt;</code>
     * [.requestPointerLock()](#ElementService+requestPointerLock) ⇒ <code>Promise.&lt;void&gt;</code>
     * [.attachShadow(options)](#ElementService+attachShadow) ⇒ <code>PseudoShadowRoot</code>
+    * [.getAriaAttribute(attributeName)](#ElementService+getAriaAttribute) ⇒ <code>string</code>
+    * [.setAriaAttribute(attributeName, value)](#ElementService+setAriaAttribute) ⇒ <code>undefined</code>
 
 <a name="new_ElementService_new"></a>
 
@@ -3413,6 +3423,29 @@ Attach a shadow tree to this element and return its ShadowRoot. Throws when it a
 | --- | --- |
 | options | <code>Object</code> | 
 
+<a name="ElementService+getAriaAttribute"></a>
+
+### elementService.getAriaAttribute(attributeName) ⇒ <code>string</code>
+Read one of the aria-* reflected properties (see the individual aria* getters/setters below).
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| attributeName | <code>string</code> | A real aria-* attribute name (aria-label, ...) |
+
+<a name="ElementService+setAriaAttribute"></a>
+
+### elementService.setAriaAttribute(attributeName, value) ⇒ <code>undefined</code>
+Write one of the aria-* reflected properties.
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| attributeName | <code>string</code> | A real aria-* attribute name (aria-label, ...) |
+| value | <code>string</code> |  |
+
 <a name="DocumentService"></a>
 
 ## DocumentService ⇐ [<code>NodeService</code>](#NodeService)
@@ -5483,24 +5516,28 @@ Remember the element which has the focus in a tree.
 <a name="escapeText"></a>
 
 ## escapeText(text) ⇒ <code>string</code>
-Escape text so it is safe inside HTML text content.
+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.
 
 **Kind**: global function  
 
 | Param | Type |
 | --- | --- |
-| text | <code>string</code> | 
+| text | <code>\*</code> | 
 
 <a name="escapeAttributeValue"></a>
 
 ## escapeAttributeValue(value) ⇒ <code>string</code>
-Escape a value so it is safe inside a double-quoted HTML attribute.
+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'.
 
 **Kind**: global function  
 
 | Param | Type |
 | --- | --- |
-| value | <code>string</code> | 
+| value | <code>\*</code> | 
 
 <a name="serializeAttributes"></a>
 
@@ -5566,9 +5603,10 @@ context.
 
 * [generateDocument(root, context)](#generateDocument) ⇒ <code>Window</code> \| <code>PseudoEventTarget</code>
     * [~newWindow](#generateDocument..newWindow) : <code>Window</code> \| <code>PseudoEventTarget</code>
-    * [~Node](#generateDocument..Node) : <code>Node</code> \| <code>PseudoNode</code>
-    * [~Element](#generateDocument..Element) : <code>Element</code> \| <code>PseudoElement</code>
-    * [~HTMLElement](#generateDocument..HTMLElement) : <code>HTMLElement</code> \| <code>PseudoHTMLElement</code>
+    * [~Node](#generateDocument..Node) : <code>function</code>
+    * [~Element](#generateDocument..Element) : <code>function</code>
+    * [~HTMLElement](#generateDocument..HTMLElement) : <code>function</code>
+    * [~HTMLDocument](#generateDocument..HTMLDocument) : <code>function</code>
     * [~document](#generateDocument..document) : <code>Document</code> \| [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
 
 <a name="generateDocument..newWindow"></a>
@@ -5577,22 +5615,35 @@ context.
 **Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
 <a name="generateDocument..Node"></a>
 
-### generateDocument~Node : <code>Node</code> \| <code>PseudoNode</code>
+### generateDocument~Node : <code>function</code>
+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()`.
+
 **Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
 <a name="generateDocument..Element"></a>
 
-### generateDocument~Element : <code>Element</code> \| <code>PseudoElement</code>
+### generateDocument~Element : <code>function</code>
+The Element class itself, for the same reason as Node.
+
 **Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
 <a name="generateDocument..HTMLElement"></a>
 
-### generateDocument~HTMLElement : <code>HTMLElement</code> \| <code>PseudoHTMLElement</code>
-Create an instance of HTMLElement if not available
+### generateDocument~HTMLElement : <code>function</code>
+The HTMLElement class itself, for the same reason as Node.
+
+**Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
+<a name="generateDocument..HTMLDocument"></a>
+
+### generateDocument~HTMLDocument : <code>function</code>
+The HTMLDocument class itself, for the same reason as Node (so `document instanceof HTMLDocument`, a common
+real-DOM-detection check, works).
 
 **Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
 <a name="generateDocument..document"></a>
 
 ### generateDocument~document : <code>Document</code> \| [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
-Define document when not available
+Define document when not available - a real instance, unlike the classes above (window.document IS an object,
+not a constructor).
 
 **Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
 <a name="nearestElementSibling"></a>

package/browser/pseudo-dom.js

@@ -734,30 +734,42 @@
    */
       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()
@@ -814,17 +826,21 @@
  * 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, generated by generateDocument, 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.
+ * 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 onto - defaults to globalThis, so
- * bare `document`, `Node`, etc. resolve from anywhere once this has run
+ * @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
     }
@@ -1055,17 +1071,21 @@
     // 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).
@@ -2775,6 +2795,321 @@
       get shadowRoot () {
         return this.shadowRootInstance && this.shadowRootInstance.mode === 'open' ? this.shadowRootInstance : null
       }
+
+      /**
+   * Read one of the aria-* reflected properties (see the individual aria* getters/setters below).
+   * @param {string} attributeName A real aria-* attribute name (aria-label, ...)
+   * @returns {string}
+   */
+      getAriaAttribute (attributeName) {
+        return this.getAttribute(attributeName) || ''
+      }
+
+      /**
+   * Write one of the aria-* reflected properties.
+   * @param {string} attributeName A real aria-* attribute name (aria-label, ...)
+   * @param {string} value
+   * @returns {undefined}
+   */
+      setAriaAttribute (attributeName, value) {
+        this.setAttribute(attributeName, value)
+      }
+
+      get ariaAtomic () {
+        return this.getAriaAttribute('aria-atomic')
+      }
+
+      set ariaAtomic (value) {
+        this.setAriaAttribute('aria-atomic', value)
+      }
+
+      get ariaAutoComplete () {
+        return this.getAriaAttribute('aria-autocomplete')
+      }
+
+      set ariaAutoComplete (value) {
+        this.setAriaAttribute('aria-autocomplete', value)
+      }
+
+      get ariaBusy () {
+        return this.getAriaAttribute('aria-busy')
+      }
+
+      set ariaBusy (value) {
+        this.setAriaAttribute('aria-busy', value)
+      }
+
+      get ariaChecked () {
+        return this.getAriaAttribute('aria-checked')
+      }
+
+      set ariaChecked (value) {
+        this.setAriaAttribute('aria-checked', value)
+      }
+
+      get ariaColCount () {
+        return this.getAriaAttribute('aria-colcount')
+      }
+
+      set ariaColCount (value) {
+        this.setAriaAttribute('aria-colcount', value)
+      }
+
+      get ariaColIndex () {
+        return this.getAriaAttribute('aria-colindex')
+      }
+
+      set ariaColIndex (value) {
+        this.setAriaAttribute('aria-colindex', value)
+      }
+
+      get ariaColSpan () {
+        return this.getAriaAttribute('aria-colspan')
+      }
+
+      set ariaColSpan (value) {
+        this.setAriaAttribute('aria-colspan', value)
+      }
+
+      get ariaCurrent () {
+        return this.getAriaAttribute('aria-current')
+      }
+
+      set ariaCurrent (value) {
+        this.setAriaAttribute('aria-current', value)
+      }
+
+      get ariaDescription () {
+        return this.getAriaAttribute('aria-description')
+      }
+
+      set ariaDescription (value) {
+        this.setAriaAttribute('aria-description', value)
+      }
+
+      get ariaDisabled () {
+        return this.getAriaAttribute('aria-disabled')
+      }
+
+      set ariaDisabled (value) {
+        this.setAriaAttribute('aria-disabled', value)
+      }
+
+      get ariaExpanded () {
+        return this.getAriaAttribute('aria-expanded')
+      }
+
+      set ariaExpanded (value) {
+        this.setAriaAttribute('aria-expanded', value)
+      }
+
+      get ariaHasPopup () {
+        return this.getAriaAttribute('aria-haspopup')
+      }
+
+      set ariaHasPopup (value) {
+        this.setAriaAttribute('aria-haspopup', value)
+      }
+
+      get ariaHidden () {
+        return this.getAriaAttribute('aria-hidden')
+      }
+
+      set ariaHidden (value) {
+        this.setAriaAttribute('aria-hidden', value)
+      }
+
+      get ariaKeyShortcuts () {
+        return this.getAriaAttribute('aria-keyshortcuts')
+      }
+
+      set ariaKeyShortcuts (value) {
+        this.setAriaAttribute('aria-keyshortcuts', value)
+      }
+
+      get ariaLabel () {
+        return this.getAriaAttribute('aria-label')
+      }
+
+      set ariaLabel (value) {
+        this.setAriaAttribute('aria-label', value)
+      }
+
+      get ariaLevel () {
+        return this.getAriaAttribute('aria-level')
+      }
+
+      set ariaLevel (value) {
+        this.setAriaAttribute('aria-level', value)
+      }
+
+      get ariaLive () {
+        return this.getAriaAttribute('aria-live')
+      }
+
+      set ariaLive (value) {
+        this.setAriaAttribute('aria-live', value)
+      }
+
+      get ariaModal () {
+        return this.getAriaAttribute('aria-modal')
+      }
+
+      set ariaModal (value) {
+        this.setAriaAttribute('aria-modal', value)
+      }
+
+      get ariaMultiline () {
+        return this.getAriaAttribute('aria-multiline')
+      }
+
+      set ariaMultiline (value) {
+        this.setAriaAttribute('aria-multiline', value)
+      }
+
+      get ariaMultiSelectable () {
+        return this.getAriaAttribute('aria-multiselectable')
+      }
+
+      set ariaMultiSelectable (value) {
+        this.setAriaAttribute('aria-multiselectable', value)
+      }
+
+      get ariaOrientation () {
+        return this.getAriaAttribute('aria-orientation')
+      }
+
+      set ariaOrientation (value) {
+        this.setAriaAttribute('aria-orientation', value)
+      }
+
+      get ariaPlaceholder () {
+        return this.getAriaAttribute('aria-placeholder')
+      }
+
+      set ariaPlaceholder (value) {
+        this.setAriaAttribute('aria-placeholder', value)
+      }
+
+      get ariaPosInSet () {
+        return this.getAriaAttribute('aria-posinset')
+      }
+
+      set ariaPosInSet (value) {
+        this.setAriaAttribute('aria-posinset', value)
+      }
+
+      get ariaPressed () {
+        return this.getAriaAttribute('aria-pressed')
+      }
+
+      set ariaPressed (value) {
+        this.setAriaAttribute('aria-pressed', value)
+      }
+
+      get ariaReadOnly () {
+        return this.getAriaAttribute('aria-readonly')
+      }
+
+      set ariaReadOnly (value) {
+        this.setAriaAttribute('aria-readonly', value)
+      }
+
+      get ariaRequired () {
+        return this.getAriaAttribute('aria-required')
+      }
+
+      set ariaRequired (value) {
+        this.setAriaAttribute('aria-required', value)
+      }
+
+      get ariaRoleDescription () {
+        return this.getAriaAttribute('aria-roledescription')
+      }
+
+      set ariaRoleDescription (value) {
+        this.setAriaAttribute('aria-roledescription', value)
+      }
+
+      get ariaRowCount () {
+        return this.getAriaAttribute('aria-rowcount')
+      }
+
+      set ariaRowCount (value) {
+        this.setAriaAttribute('aria-rowcount', value)
+      }
+
+      get ariaRowIndex () {
+        return this.getAriaAttribute('aria-rowindex')
+      }
+
+      set ariaRowIndex (value) {
+        this.setAriaAttribute('aria-rowindex', value)
+      }
+
+      get ariaRowSpan () {
+        return this.getAriaAttribute('aria-rowspan')
+      }
+
+      set ariaRowSpan (value) {
+        this.setAriaAttribute('aria-rowspan', value)
+      }
+
+      get ariaSelected () {
+        return this.getAriaAttribute('aria-selected')
+      }
+
+      set ariaSelected (value) {
+        this.setAriaAttribute('aria-selected', value)
+      }
+
+      get ariaSetSize () {
+        return this.getAriaAttribute('aria-setsize')
+      }
+
+      set ariaSetSize (value) {
+        this.setAriaAttribute('aria-setsize', value)
+      }
+
+      get ariaSort () {
+        return this.getAriaAttribute('aria-sort')
+      }
+
+      set ariaSort (value) {
+        this.setAriaAttribute('aria-sort', value)
+      }
+
+      get ariaValueMax () {
+        return this.getAriaAttribute('aria-valuemax')
+      }
+
+      set ariaValueMax (value) {
+        this.setAriaAttribute('aria-valuemax', value)
+      }
+
+      get ariaValueMin () {
+        return this.getAriaAttribute('aria-valuemin')
+      }
+
+      set ariaValueMin (value) {
+        this.setAriaAttribute('aria-valuemin', value)
+      }
+
+      get ariaValueNow () {
+        return this.getAriaAttribute('aria-valuenow')
+      }
+
+      set ariaValueNow (value) {
+        this.setAriaAttribute('aria-valuenow', value)
+      }
+
+      get ariaValueText () {
+        return this.getAriaAttribute('aria-valuetext')
+      }
+
+      set ariaValueText (value) {
+        this.setAriaAttribute('aria-valuetext', value)
+      }
     }
     exports.ElementService = ElementService
   }, { '../factories/createEvent': 5, '../factories/query': 14, '../factories/serializeHTML': 15, '../functions/getParentNodesFromAttribute': 19, './AttrService': 22, './DOMTokenListService': 25, './HTMLCollectionService': 32, './NamedNodeMapService': 37, './NodeService': 38, './ShadowRootService': 40, 'core-js/modules/esnext.iterator.constructor.js': 193, 'core-js/modules/esnext.iterator.every.js': 194, 'core-js/modules/esnext.iterator.find.js': 196, 'core-js/modules/esnext.iterator.for-each.js': 197, 'core-js/modules/esnext.iterator.map.js': 198, 'core-js/modules/esnext.iterator.some.js': 200, 'core-js/modules/esnext.set.add-all.js': 214, 'core-js/modules/esnext.set.delete-all.js': 215, 'core-js/modules/esnext.set.difference.js': 216, 'core-js/modules/esnext.set.every.js': 217, 'core-js/modules/esnext.set.filter.js': 218, 'core-js/modules/esnext.set.find.js': 219, 'core-js/modules/esnext.set.intersection.js': 220, 'core-js/modules/esnext.set.is-disjoint-from.js': 221, 'core-js/modules/esnext.set.is-subset-of.js': 222, 'core-js/modules/esnext.set.is-superset-of.js': 223, 'core-js/modules/esnext.set.join.js': 224, 'core-js/modules/esnext.set.map.js': 225, 'core-js/modules/esnext.set.reduce.js': 226, 'core-js/modules/esnext.set.some.js': 227, 'core-js/modules/esnext.set.symmetric-difference.js': 228, 'core-js/modules/esnext.set.union.js': 229, 'si-funciona/dist/helpers/objects/cloneObject': 263, 'si-funciona/dist/helpers/objects/isEqual': 265 }],