@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/nodes/NodeList-impl.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const idlUtils = require("../../../generated/idl/utils.js");
+
+exports.implementation = class NodeListImpl {
+  constructor(globalObject, args, privateData) {
+    if (privateData.nodes) {
+      this._list = [...privateData.nodes];
+      this._isLive = false;
+    } else {
+      this._list = [];
+      this._isLive = true;
+      this._version = -1;
+      this._element = privateData.element;
+      this._query = privateData.query;
+      this._update();
+    }
+  }
+  get length() {
+    this._update();
+    return this._list.length;
+  }
+  item(index) {
+    this._update();
+    return this._list[index] || null;
+  }
+  _update() {
+    if (this._isLive) {
+      if (this._version < this._element._version) {
+        const snapshot = this._query();
+        for (let i = 0; i < snapshot.length; i++) {
+          this._list[i] = snapshot[i];
+        }
+        this._list.length = snapshot.length;
+        this._version = this._element._version;
+      }
+    }
+  }
+  get [idlUtils.supportedPropertyIndices]() {
+    this._update();
+    return this._list.keys();
+  }
+};

package/lib/jsdom/living/nodes/NonDocumentTypeChildNode-impl.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+
+class NonDocumentTypeChildNodeImpl {
+  get nextElementSibling() {
+    for (const sibling of domSymbolTree.nextSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+
+  get previousElementSibling() {
+    for (const sibling of domSymbolTree.previousSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  implementation: NonDocumentTypeChildNodeImpl
+};

package/lib/jsdom/living/nodes/NonElementParentNode-impl.js

@@ -0,0 +1,11 @@
+"use strict";
+
+// https://dom.spec.whatwg.org/#interface-nonelementparentnode
+// getElementById is implemented separately inside Document and DocumentFragment.
+class NonElementParentNodeImpl {
+
+}
+
+module.exports = {
+  implementation: NonElementParentNodeImpl
+};

package/lib/jsdom/living/nodes/ParentNode-impl.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const NodeList = require("../../../generated/idl/NodeList");
+const HTMLCollection = require("../../../generated/idl/HTMLCollection");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const NODE_TYPE = require("../node-type");
+const { convertNodesIntoNode } = require("../node");
+
+class ParentNodeImpl {
+  get children() {
+    if (!this._childrenList) {
+      this._childrenList = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => domSymbolTree.childrenToArray(this, {
+          filter: node => node.nodeType === NODE_TYPE.ELEMENT_NODE
+        })
+      });
+    } else {
+      this._childrenList._update();
+    }
+    return this._childrenList;
+  }
+
+  get firstElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get lastElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this, { reverse: true })) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get childElementCount() {
+    return this.children.length;
+  }
+
+  prepend(...nodes) {
+    this._preInsert(convertNodesIntoNode(this._ownerDocument, nodes), this.firstChild);
+  }
+
+  append(...nodes) {
+    this._append(convertNodesIntoNode(this._ownerDocument, nodes));
+  }
+
+  replaceChildren(...nodes) {
+    const node = convertNodesIntoNode(this._ownerDocument, nodes);
+    this._preInsertValidity(node, null);
+    this._replaceAll(node);
+  }
+
+  querySelector(selectors) {
+    if (shouldAlwaysSelectNothing(this)) {
+      return null;
+    }
+    const domSelector = this._ownerDocument._domSelector;
+    return domSelector.querySelector(selectors, this);
+  }
+
+  // WARNING FOR INTERNAL USERS:
+  // This returns a NodeList impl, not a NodeList wrapper. NodeList impls are not iterable and do not have indexed
+  // properties. To iterate over them, use `for (let i = 0; i < nodeListImpl.length; ++i) { nodeListImpl.item(i) }`.
+  querySelectorAll(selectors) {
+    if (shouldAlwaysSelectNothing(this)) {
+      return NodeList.createImpl(this._globalObject, [], { nodes: [] });
+    }
+    const domSelector = this._ownerDocument._domSelector;
+    const nodes = domSelector.querySelectorAll(selectors, this);
+    return NodeList.createImpl(this._globalObject, [], { nodes });
+  }
+}
+
+function shouldAlwaysSelectNothing(elImpl) {
+  // This is true during initialization.
+  return elImpl === elImpl._ownerDocument && !elImpl.documentElement;
+}
+
+module.exports = {
+  implementation: ParentNodeImpl
+};

package/lib/jsdom/living/nodes/ProcessingInstruction-impl.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+
+const NODE_TYPE = require("../node-type");
+
+class ProcessingInstructionImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.nodeType = NODE_TYPE.PROCESSING_INSTRUCTION_NODE;
+    this._target = privateData.target;
+  }
+
+  get target() {
+    return this._target;
+  }
+}
+
+module.exports = {
+  implementation: ProcessingInstructionImpl
+};

package/lib/jsdom/living/nodes/RadioNodeList-impl.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const NodeListImpl = require("./NodeList-impl").implementation;
+
+class RadioNodeListImpl extends NodeListImpl {
+  // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#dom-radionodelist-value
+  // Note in general the spec says to manipulate/consult checkedness, but we use `checked` instead
+  // because the spec isn't very good here: https://github.com/whatwg/html/issues/7612.
+
+  get value() {
+    this._update();
+
+    const element = this._list.find(e => e._localName === "input" && e.type === "radio" && e.checked);
+    if (element === undefined) {
+      return "";
+    }
+
+    if (!element.hasAttributeNS(null, "value")) {
+      return "on";
+    }
+
+    return element.getAttributeNS(null, "value");
+  }
+
+  set value(value) {
+    let element;
+    if (value === "on") {
+      element = this._list.find(
+        e => e._localName === "input" &&
+             e.type === "radio" &&
+             (!e.hasAttributeNS(null, "value") || e.getAttributeNS(null, "value") === value)
+      );
+    } else {
+      element = this._list.find(
+        e => e._localName === "input" &&
+             e.type === "radio" &&
+             (e.hasAttributeNS(null, "value") && e.getAttributeNS(null, "value") === value)
+      );
+    }
+
+    if (element) {
+      element.checked = true;
+    }
+  }
+}
+
+module.exports = {
+  implementation: RadioNodeListImpl
+};

package/lib/jsdom/living/nodes/SVGDefsElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGGraphicsElementImpl = require("./SVGGraphicsElement-impl").implementation;
+
+class SVGDefsElementImpl extends SVGGraphicsElementImpl {}
+
+module.exports = {
+  implementation: SVGDefsElementImpl
+};

package/lib/jsdom/living/nodes/SVGDescElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGElementImpl = require("./SVGElement-impl").implementation;
+
+class SVGDescElementImpl extends SVGElementImpl {}
+
+module.exports = {
+  implementation: SVGDescElementImpl
+};

package/lib/jsdom/living/nodes/SVGElement-impl.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { SVG_NS } = require("../helpers/namespaces");
+const { mixin } = require("../../utils");
+const ElementImpl = require("./Element-impl").implementation;
+const ElementCSSInlineStyleImpl = require("./ElementCSSInlineStyle-impl").implementation;
+const GlobalEventHandlersImpl = require("./GlobalEventHandlers-impl").implementation;
+const HTMLOrSVGElementImpl = require("./HTMLOrSVGElement-impl").implementation;
+
+class SVGElementImpl extends ElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._initHTMLOrSVGElement();
+    this._initElementCSSInlineStyle();
+    this._initGlobalEvents();
+  }
+
+  // Keep in sync with HTMLElement. https://github.com/jsdom/jsdom/issues/2599
+  _attrModified(name, value, oldValue) {
+    if (name === "style" && value !== oldValue && !this._settingCssText) {
+      this._settingCssText = true;
+      this._style.cssText = value;
+      this._settingCssText = false;
+    } else if (name.startsWith("on")) {
+      this._globalEventChanged(name.substring(2));
+    }
+
+    super._attrModified(name, value, oldValue);
+  }
+
+  get ownerSVGElement() {
+    let e = domSymbolTree.parent(this);
+    while (e && e.namespaceURI === SVG_NS) {
+      if (e.localName === "svg") {
+        return e;
+      }
+      e = domSymbolTree.parent(e);
+    }
+
+    return null;
+  }
+
+  get viewportElement() {
+    // Get the nearest ancestor that establishes the viewport.
+    // https://svgwg.org/svg2-draft/coords.html#EstablishingANewSVGViewport
+    let e = domSymbolTree.parent(this);
+    while (e && e.namespaceURI === SVG_NS) {
+      if (e.localName === "svg" || e.localName === "symbol") {
+        return e;
+      }
+      e = domSymbolTree.parent(e);
+    }
+    return null;
+  }
+}
+
+SVGElementImpl.attributeRegistry = new Map();
+
+mixin(SVGElementImpl.prototype, ElementCSSInlineStyleImpl.prototype);
+mixin(SVGElementImpl.prototype, GlobalEventHandlersImpl.prototype);
+mixin(SVGElementImpl.prototype, HTMLOrSVGElementImpl.prototype);
+
+exports.implementation = SVGElementImpl;

package/lib/jsdom/living/nodes/SVGGElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGGraphicsElementImpl = require("./SVGGraphicsElement-impl").implementation;
+
+class SVGGElementImpl extends SVGGraphicsElementImpl {}
+
+module.exports = {
+  implementation: SVGGElementImpl
+};

package/lib/jsdom/living/nodes/SVGGraphicsElement-impl.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const SVGElementImpl = require("./SVGElement-impl").implementation;
+const SVGTestsImpl = require("./SVGTests-impl").implementation;
+
+class SVGGraphicsElementImpl extends SVGElementImpl {}
+
+SVGGraphicsElementImpl.attributeRegistry = new Map([
+  ...SVGElementImpl.attributeRegistry,
+  ...SVGTestsImpl.attributeRegistry
+]);
+
+mixin(SVGGraphicsElementImpl.prototype, SVGTestsImpl.prototype);
+
+exports.implementation = SVGGraphicsElementImpl;

package/lib/jsdom/living/nodes/SVGMetadataElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGElementImpl = require("./SVGElement-impl").implementation;
+
+class SVGMetadataElementImpl extends SVGElementImpl {}
+
+module.exports = {
+  implementation: SVGMetadataElementImpl
+};

package/lib/jsdom/living/nodes/SVGSVGElement-impl.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const SVGNumber = require("../../../generated/idl/SVGNumber");
+const SVGRect = require("../../../generated/idl/SVGRect");
+const SVGGraphicsElementImpl = require("./SVGGraphicsElement-impl").implementation;
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { ELEMENT_NODE } = require("../node-type");
+
+class SVGSVGElementImpl extends SVGGraphicsElementImpl {
+  createSVGNumber() {
+    return SVGNumber.createImpl(this._globalObject, [], {});
+  }
+
+  createSVGRect() {
+    return SVGRect.createImpl(this._globalObject, [], {});
+  }
+
+  // Unlike `Document`'s `getElementById()`, this searches within this element's subtree, so the document-level
+  // `ByIdCache` can't be used (it might return an element outside this subtree). A per-`<svg>` cache isn't worthwhile
+  // since `SVGSVGElement`'s `getElementById()` is rarely called and `<svg>` subtrees are typically small.
+  getElementById(elementId) {
+    for (const node of domSymbolTree.treeIterator(this)) {
+      if (node.nodeType === ELEMENT_NODE && node.getAttributeNS(null, "id") === elementId) {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  suspendRedraw() {
+    return 1;
+  }
+  unsuspendRedraw() {}
+  unsuspendRedrawAll() {}
+  forceRedraw() {}
+}
+
+module.exports = {
+  implementation: SVGSVGElementImpl
+};

package/lib/jsdom/living/nodes/SVGSwitchElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGGraphicsElementImpl = require("./SVGGraphicsElement-impl").implementation;
+
+class SVGSwitchElementImpl extends SVGGraphicsElementImpl {}
+
+module.exports = {
+  implementation: SVGSwitchElementImpl
+};

package/lib/jsdom/living/nodes/SVGSymbolElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGGraphicsElementImpl = require("./SVGGraphicsElement-impl").implementation;
+
+class SVGSymbolElementImpl extends SVGGraphicsElementImpl {}
+
+module.exports = {
+  implementation: SVGSymbolElementImpl
+};

package/lib/jsdom/living/nodes/SVGTests-impl.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const { splitOnASCIIWhitespace, splitOnCommas } = require("../helpers/strings");
+const { reserializeCommaSeparatedTokens, reserializeSpaceSeparatedTokens } = require("../helpers/svg/basic-types");
+const SVGStringList = require("../../../generated/idl/SVGStringList");
+
+class SVGTestsImpl {
+  get requiredExtensions() {
+    return SVGStringList.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "requiredExtensions"
+    });
+  }
+
+  get systemLanguage() {
+    return SVGStringList.createImpl(this._globalObject, [], {
+      element: this,
+      attribute: "systemLanguage"
+    });
+  }
+}
+
+SVGTestsImpl.attributeRegistry = new Map([
+  // https://svgwg.org/svg2-draft/struct.html#RequiredExtensionsAttribute
+  [
+    "requiredExtensions", {
+      getValue: splitOnASCIIWhitespace,
+      serialize: reserializeSpaceSeparatedTokens,
+      initialValue: undefined
+    }
+  ],
+  // https://svgwg.org/svg2-draft/struct.html#SystemLanguageAttribute
+  [
+    "systemLanguage", {
+      getValue: splitOnCommas,
+      serialize: reserializeCommaSeparatedTokens,
+      initialValue: undefined
+    }
+  ]
+]);
+
+exports.implementation = SVGTestsImpl;

package/lib/jsdom/living/nodes/SVGTitleElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const SVGElementImpl = require("./SVGElement-impl").implementation;
+
+class SVGTitleElementImpl extends SVGElementImpl { }
+
+module.exports = {
+  implementation: SVGTitleElementImpl
+};

package/lib/jsdom/living/nodes/ShadowRoot-impl.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const { nodeRoot } = require("../helpers/node");
+const { mixin } = require("../../utils");
+
+const DocumentFragment = require("./DocumentFragment-impl").implementation;
+const DocumentOrShadowRootImpl = require("./DocumentOrShadowRoot-impl").implementation;
+const InnerHTMLImpl = require("../domparsing/InnerHTML-impl").implementation;
+
+class ShadowRootImpl extends DocumentFragment {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    const { mode } = privateData;
+    this._mode = mode;
+    this._availableToElementInternals = false;
+  }
+
+  _getTheParent(event) {
+    if (!event.composed && this === nodeRoot(event._path[0].item)) {
+      return null;
+    }
+
+    return this._host;
+  }
+
+  get mode() {
+    return this._mode;
+  }
+
+  get host() {
+    return this._host;
+  }
+}
+
+mixin(ShadowRootImpl.prototype, DocumentOrShadowRootImpl.prototype);
+mixin(ShadowRootImpl.prototype, InnerHTMLImpl.prototype);
+
+module.exports = {
+  implementation: ShadowRootImpl
+};

package/lib/jsdom/living/nodes/Slotable-impl.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const { findSlot, assignSlot, assignSlotable } = require("../helpers/shadow-dom");
+
+// https://dom.spec.whatwg.org/#mixin-slotable
+// https://dom.spec.whatwg.org/#light-tree-slotables
+class SlotableMixinImpl {
+  _initSlotableMixin() {
+    this._slotableName = "";
+  }
+
+  _attrModifiedSlotableMixin(name, value, oldValue) {
+    if (name === "slot") {
+      if (value === oldValue) {
+        return;
+      }
+
+      if (value === null && oldValue === "") {
+        return;
+      }
+
+      if (value === "" && oldValue === null) {
+        return;
+      }
+
+      if (value === null || value === "") {
+        this._slotableName = "";
+      } else {
+        this._slotableName = value;
+      }
+
+
+      if (this._assignedSlot) {
+        assignSlotable(this._assignedSlot);
+      }
+
+      assignSlot(this);
+    }
+  }
+
+  get assignedSlot() {
+    return findSlot(this, "open");
+  }
+}
+
+module.exports = {
+  implementation: SlotableMixinImpl
+};

package/lib/jsdom/living/nodes/Text-impl.js

@@ -0,0 +1,96 @@
+"use strict";
+const SlotableMixinImpl = require("./Slotable-impl").implementation;
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+const idlUtils = require("../../../generated/idl/utils");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const DOMException = require("../../../generated/idl/DOMException");
+const NODE_TYPE = require("../node-type");
+const { mixin } = require("../../utils");
+
+// https://dom.spec.whatwg.org/#text
+class TextImpl extends CharacterDataImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, {
+      data: args[0],
+      ownerDocument: idlUtils.implForWrapper(globalObject._document),
+      ...privateData
+    });
+
+    this._initSlotableMixin();
+
+    this.nodeType = NODE_TYPE.TEXT_NODE;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-text-splittext
+  // https://dom.spec.whatwg.org/#concept-text-split
+  splitText(offset) {
+    const { length } = this;
+
+    if (offset > length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+
+    const count = length - offset;
+    const newData = this.substringData(offset, count);
+
+    const newNode = this._ownerDocument.createTextNode(newData);
+
+    const parent = domSymbolTree.parent(this);
+
+    if (parent !== null) {
+      parent._insert(newNode, this.nextSibling);
+
+      for (const range of this._liveRanges()) {
+        const { _start, _end } = range;
+
+        if (_start.node === this && _start.offset > offset) {
+          range._setLiveRangeStart(newNode, _start.offset - offset);
+        }
+
+        if (_end.node === this && _end.offset > offset) {
+          range._setLiveRangeEnd(newNode, _end.offset - offset);
+        }
+      }
+
+      const nodeIndex = domSymbolTree.index(this);
+      for (const range of parent._liveRanges()) {
+        const { _start, _end } = range;
+
+        if (_start.node === parent && _start.offset === nodeIndex + 1) {
+          range._setLiveRangeStart(parent, _start.offset + 1);
+        }
+
+        if (_end.node === parent && _end.offset === nodeIndex + 1) {
+          range._setLiveRangeEnd(parent, _end.offset + 1);
+        }
+      }
+    }
+
+    this.replaceData(offset, count, "");
+
+    return newNode;
+  }
+
+  // https://dom.spec.whatwg.org/#dom-text-wholetext
+  get wholeText() {
+    let wholeText = this.textContent;
+    let next;
+    let current = this;
+    while ((next = domSymbolTree.previousSibling(current)) && next.nodeType === NODE_TYPE.TEXT_NODE) {
+      wholeText = next.textContent + wholeText;
+      current = next;
+    }
+    current = this;
+    while ((next = domSymbolTree.nextSibling(current)) && next.nodeType === NODE_TYPE.TEXT_NODE) {
+      wholeText += next.textContent;
+      current = next;
+    }
+    return wholeText;
+  }
+}
+
+mixin(TextImpl.prototype, SlotableMixinImpl.prototype);
+
+module.exports = {
+  implementation: TextImpl
+};