@depup/jsdom 28.1.0-depup.1

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

@@ -0,0 +1,255 @@
+"use strict";
+const vm = require("vm");
+const { getBOMEncoding, labelToName, legacyHookDecode } = require("@exodus/bytes/encoding.js");
+const { MIMEType } = require("whatwg-mimetype");
+const { serializeURL } = require("whatwg-url");
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const reportException = require("../helpers/runtime-script-errors");
+const { domSymbolTree, cloningSteps } = require("../helpers/internal-constants");
+const { asciiLowercase } = require("../helpers/strings");
+const { childTextContent } = require("../helpers/text");
+const nodeTypes = require("../node-type");
+
+const jsMIMETypes = new Set([
+  "application/ecmascript",
+  "application/javascript",
+  "application/x-ecmascript",
+  "application/x-javascript",
+  "text/ecmascript",
+  "text/javascript",
+  "text/javascript1.0",
+  "text/javascript1.1",
+  "text/javascript1.2",
+  "text/javascript1.3",
+  "text/javascript1.4",
+  "text/javascript1.5",
+  "text/jscript",
+  "text/livescript",
+  "text/x-ecmascript",
+  "text/x-javascript"
+]);
+
+class HTMLScriptElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._alreadyStarted = false;
+    this._parserInserted = false; // set by the parser
+  }
+
+  _attach() {
+    super._attach();
+
+
+    // In our current terribly-hacky document.write() implementation, we parse in a div them move elements into the main
+    // document. Thus _eval() will bail early when it gets in _poppedOffStackOfOpenElements(), since we're not attached
+    // then. Instead, we'll let it eval here.
+    if (!this._parserInserted || this._isMovingDueToDocumentWrite) {
+      this._eval();
+    }
+  }
+
+  _canRunScript() {
+    const document = this._ownerDocument;
+    // Equivalent to the spec's "scripting is disabled" check.
+    if (!document._defaultView || document._defaultView._runScripts !== "dangerously" || document._scriptingDisabled) {
+      return false;
+    }
+
+    return true;
+  }
+
+  _fetchExternalScript() {
+    const document = this._ownerDocument;
+    const resourceLoader = document._resourceLoader;
+    const defaultEncoding = labelToName(this.getAttributeNS(null, "charset")) || document._encoding;
+
+    if (!this._canRunScript()) {
+      return;
+    }
+
+    const src = this.getAttributeNS(null, "src");
+    const url = this._ownerDocument.encodingParseAURL(src);
+    if (url === null) {
+      return;
+    }
+    const urlString = serializeURL(url);
+
+    const onLoadExternalScript = (data, response) => {
+      if (!response.ok) {
+        throw new Error("Status code: " + response.status);
+      }
+
+      const contentType = MIMEType.parse(response.headers.get("content-type")) || new MIMEType("text/plain");
+
+      const encoding = labelToName(getBOMEncoding(data)) ||
+        labelToName(contentType.parameters.get("charset")) ||
+        defaultEncoding;
+      const script = legacyHookDecode(data, encoding);
+
+      this._innerEval(script, urlString);
+    };
+
+    resourceLoader.fetch(urlString, {
+      element: this,
+      onLoad: onLoadExternalScript
+    });
+  }
+
+  _fetchInternalScript() {
+    const document = this._ownerDocument;
+
+    if (!this._canRunScript()) {
+      return;
+    }
+
+    document._queue.push(null, () => {
+      this._innerEval(this.text, document.URL);
+    }, null, false, this);
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    if (this._attached && !this._startedEval && name === "src" && oldValue === null && value !== null) {
+      this._fetchExternalScript();
+    }
+  }
+
+  _poppedOffStackOfOpenElements() {
+    // This seems to roughly correspond to
+    // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incdata:prepare-a-script, although we certainly
+    // don't implement the full semantics.
+    this._eval();
+  }
+
+  // Vaguely similar to https://html.spec.whatwg.org/multipage/scripting.html#prepare-a-script, but we have a long way
+  // to go before it's aligned.
+  _eval() {
+    if (this._alreadyStarted) {
+      return;
+    }
+
+    // TODO: this text check doesn't seem completely the same as the spec, which e.g. will try to execute scripts with
+    // child element nodes. Spec bug? https://github.com/whatwg/html/issues/3419
+    if (!this.hasAttributeNS(null, "src") && this.text.length === 0) {
+      return;
+    }
+
+    if (!this._attached) {
+      return;
+    }
+
+    const scriptBlocksTypeString = this._getTypeString();
+    const type = getType(scriptBlocksTypeString);
+
+    if (type !== "classic") {
+      // TODO: implement modules, and then change the check to `type === null`.
+      return;
+    }
+
+    this._alreadyStarted = true;
+
+    // TODO: implement nomodule here, **but only after we support modules**.
+
+    // At this point we completely depart from the spec.
+
+    if (this.hasAttributeNS(null, "src")) {
+      this._fetchExternalScript();
+    } else {
+      this._fetchInternalScript();
+    }
+  }
+
+  _innerEval(text, filename) {
+    this._ownerDocument._writeAfterElement = this;
+    processJavaScript(this, text, filename);
+    delete this._ownerDocument._writeAfterElement;
+  }
+
+  _getTypeString() {
+    const typeAttr = this.getAttributeNS(null, "type");
+    const langAttr = this.getAttributeNS(null, "language");
+
+    if (typeAttr === "") {
+      return "text/javascript";
+    }
+
+    if (typeAttr === null && langAttr === "") {
+      return "text/javascript";
+    }
+
+    if (typeAttr === null && langAttr === null) {
+      return "text/javascript";
+    }
+
+    if (typeAttr !== null) {
+      return typeAttr.trim();
+    }
+
+    if (langAttr !== null) {
+      return "text/" + langAttr;
+    }
+
+    return null;
+  }
+
+  get text() {
+    return childTextContent(this);
+  }
+
+  set text(text) {
+    this.textContent = text;
+  }
+
+  // https://html.spec.whatwg.org/multipage/scripting.html#script-processing-model
+  [cloningSteps](copy, node) {
+    copy._alreadyStarted = node._alreadyStarted;
+  }
+}
+
+function processJavaScript(element, code, filename) {
+  const document = element.ownerDocument;
+  const window = document && document._global;
+
+  if (window) {
+    document._currentScript = element;
+
+    let lineOffset = 0;
+    if (!element.hasAttributeNS(null, "src")) {
+      for (const child of domSymbolTree.childrenIterator(element)) {
+        if (child.nodeType === nodeTypes.TEXT_NODE) {
+          if (child.sourceCodeLocation) {
+            lineOffset = child.sourceCodeLocation.startLine - 1;
+          }
+          break;
+        }
+      }
+    }
+
+    try {
+      vm.runInContext(code, window, { filename, lineOffset, displayErrors: false });
+    } catch (e) {
+      reportException(window, e, filename);
+    } finally {
+      document._currentScript = null;
+    }
+  }
+}
+
+function getType(typeString) {
+  const lowercased = asciiLowercase(typeString);
+  // Cannot use whatwg-mimetype parsing because that strips whitespace. The spec demands a strict string comparison.
+  // That is, the type="" attribute is not really related to MIME types at all.
+  if (jsMIMETypes.has(lowercased)) {
+    return "classic";
+  }
+  if (lowercased === "module") {
+    return "module";
+  }
+  return null;
+}
+
+module.exports = {
+  implementation: HTMLScriptElementImpl
+};

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

@@ -0,0 +1,283 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+
+const idlUtils = require("../../../generated/idl/utils.js");
+const ValidityState = require("../../../generated/idl/ValidityState");
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { mixin } = require("../../utils");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const NODE_TYPE = require("../node-type");
+const HTMLCollection = require("../../../generated/idl/HTMLCollection");
+const HTMLOptionsCollection = require("../../../generated/idl/HTMLOptionsCollection");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { getLabelsForLabelable, formOwner, isDisabled } = require("../helpers/form-controls");
+const { parseNonNegativeInteger } = require("../helpers/strings");
+
+class HTMLSelectElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._options = HTMLOptionsCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => {
+        // Customized domSymbolTree.treeToArray() clone.
+        const array = [];
+        for (const child of domSymbolTree.childrenIterator(this)) {
+          if (child._localName === "option") {
+            array.push(child);
+          } else if (child._localName === "optgroup") {
+            for (const childOfGroup of domSymbolTree.childrenIterator(child)) {
+              if (childOfGroup._localName === "option") {
+                array.push(childOfGroup);
+              }
+            }
+          }
+        }
+        return array;
+      }
+    });
+    this._selectedOptions = null; // lazy
+
+    this._customValidityErrorMessage = "";
+
+    this._labels = null;
+  }
+
+  _formReset() {
+    for (const option of this.options) {
+      option._selectedness = option.hasAttributeNS(null, "selected");
+      option._dirtyness = false;
+    }
+    this._askedForAReset();
+  }
+
+  _askedForAReset() {
+    if (this.hasAttributeNS(null, "multiple")) {
+      return;
+    }
+
+    const selected = this.options.filter(opt => opt._selectedness);
+
+    const size = this._displaySize;
+    if (size === 1 && !selected.length) {
+      // select the first option that is not disabled
+      for (const option of this.options) {
+        let disabled = option.hasAttributeNS(null, "disabled");
+        const parentNode = domSymbolTree.parent(option);
+        if (parentNode &&
+          parentNode._localName === "optgroup" &&
+          parentNode.hasAttributeNS(null, "disabled")) {
+          disabled = true;
+        }
+
+        if (!disabled) {
+          // (do not set dirty)
+          option._selectedness = true;
+          break;
+        }
+      }
+    } else if (selected.length >= 2) {
+      // select the last selected option
+      selected.forEach((option, index) => {
+        option._selectedness = index === selected.length - 1;
+      });
+    }
+  }
+
+  _descendantAdded(parent, child) {
+    if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+      this._askedForAReset();
+    }
+
+    super._descendantAdded(parent, child);
+  }
+
+  _descendantRemoved(parent, child) {
+    if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+      this._askedForAReset();
+    }
+
+    super._descendantRemoved(parent, child);
+  }
+
+  _attrModified(name, value, oldValue) {
+    if (name === "multiple" || name === "size") {
+      this._askedForAReset();
+    }
+    super._attrModified(name, value, oldValue);
+  }
+
+  get _displaySize() {
+    if (this.hasAttributeNS(null, "size")) {
+      const size = parseNonNegativeInteger(this.getAttributeNS(null, "size"));
+      if (size !== null) {
+        return size;
+      }
+    }
+    return this.hasAttributeNS(null, "multiple") ? 4 : 1;
+  }
+
+  get _mutable() {
+    return !isDisabled(this);
+  }
+
+  get options() {
+    return this._options;
+  }
+
+  get selectedOptions() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => domSymbolTree.treeToArray(this, {
+        filter: node => node._localName === "option" && node._selectedness === true
+      })
+    });
+  }
+
+  get selectedIndex() {
+    for (let i = 0; i < this.options.length; i++) {
+      if (this.options.item(i)._selectedness) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  set selectedIndex(index) {
+    for (let i = 0; i < this.options.length; i++) {
+      this.options.item(i)._selectedness = false;
+    }
+
+    const selectedOption = this.options.item(index);
+    if (selectedOption) {
+      selectedOption._selectedness = true;
+      selectedOption._dirtyness = true;
+    }
+  }
+
+  get labels() {
+    return getLabelsForLabelable(this);
+  }
+
+  get value() {
+    for (const option of this.options) {
+      if (option._selectedness) {
+        return option.value;
+      }
+    }
+
+    return "";
+  }
+
+  set value(val) {
+    for (const option of this.options) {
+      if (option.value === val) {
+        option._selectedness = true;
+        option._dirtyness = true;
+      } else {
+        option._selectedness = false;
+      }
+
+      option._modified();
+    }
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get type() {
+    return this.hasAttributeNS(null, "multiple") ? "select-multiple" : "select-one";
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return this.options[idlUtils.supportedPropertyIndices];
+  }
+
+  get length() {
+    return this.options.length;
+  }
+
+  set length(value) {
+    this.options.length = value;
+  }
+
+  item(index) {
+    return this.options.item(index);
+  }
+
+  namedItem(name) {
+    return this.options.namedItem(name);
+  }
+
+  [idlUtils.indexedSetNew](index, value) {
+    return this.options[idlUtils.indexedSetNew](index, value);
+  }
+
+  [idlUtils.indexedSetExisting](index, value) {
+    return this.options[idlUtils.indexedSetExisting](index, value);
+  }
+
+  add(opt, before) {
+    this.options.add(opt, before);
+  }
+
+  remove(index) {
+    if (arguments.length > 0) {
+      index = conversions.long(index, {
+        context: "Failed to execute 'remove' on 'HTMLSelectElement': parameter 1"
+      });
+      this.options.remove(index);
+    } else {
+      super.remove();
+    }
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return this.hasAttributeNS(null, "readonly");
+  }
+
+  // Constraint validation: If the element has its required attribute specified,
+  // and either none of the option elements in the select element's list of options
+  // have their selectedness set to true, or the only option element in the select
+  // element's list of options with its selectedness set to true is the placeholder
+  // label option, then the element is suffering from being missing.
+  get validity() {
+    if (!this._validity) {
+      const state = {
+        valueMissing: () => {
+          if (!this.hasAttributeNS(null, "required")) {
+            return false;
+          }
+          const selectedOptionIndex = this.selectedIndex;
+          return selectedOptionIndex < 0 || (selectedOptionIndex === 0 && this._hasPlaceholderOption);
+        }
+      };
+
+      this._validity = ValidityState.createImpl(this._globalObject, [], {
+        element: this,
+        state
+      });
+    }
+    return this._validity;
+  }
+
+  // If a select element has a required attribute specified, does not have a multiple attribute
+  // specified, and has a display size of 1; and if the value of the first option element in the
+  // select element's list of options (if any) is the empty string, and that option element's parent
+  // node is the select element(and not an optgroup element), then that option is the select
+  // element's placeholder label option.
+  // https://html.spec.whatwg.org/multipage/form-elements.html#placeholder-label-option
+  get _hasPlaceholderOption() {
+    return this.hasAttributeNS(null, "required") && !this.hasAttributeNS(null, "multiple") &&
+      this._displaySize === 1 && this.options.length > 0 && this.options.item(0).value === "" &&
+      this.options.item(0).parentNode._localName !== "optgroup";
+  }
+}
+
+mixin(HTMLSelectElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLSelectElementImpl
+};

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

@@ -0,0 +1,59 @@
+"use strict";
+
+const idlUtils = require("../../../generated/idl/utils");
+const HTMLElement = require("../../../generated/idl/HTMLElement");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const { nodeRoot } = require("../helpers/node");
+const { assignSlotableForTree, findFlattenedSlotables } = require("../helpers/shadow-dom");
+
+class HTMLSlotElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._assignedNodes = [];
+  }
+
+  // https://dom.spec.whatwg.org/#slot-name
+  get name() {
+    return this.getAttributeNS(null, "name") || "";
+  }
+
+  _attrModified(name, value, oldValue) {
+    super._attrModified(name, value, oldValue);
+
+    // https://dom.spec.whatwg.org/#slot-name
+    if (name === "name") {
+      if (value === oldValue) {
+        return;
+      }
+
+      if (value === null && oldValue === "") {
+        return;
+      }
+
+      if (value === "" && oldValue === null) {
+        return;
+      }
+
+      assignSlotableForTree(nodeRoot(this));
+    }
+  }
+
+  // https://html.spec.whatwg.org/#dom-slot-assignednodes
+  assignedNodes(options) {
+    if (!options || !options.flatten) {
+      return this._assignedNodes.map(idlUtils.wrapperForImpl);
+    }
+
+    return findFlattenedSlotables(this).map(idlUtils.wrapperForImpl);
+  }
+
+  // https://html.spec.whatwg.org/#dom-slot-assignedelements
+  assignedElements(options) {
+    return this.assignedNodes(options).filter(HTMLElement.is);
+  }
+}
+
+module.exports = {
+  implementation: HTMLSlotElementImpl
+};

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

@@ -0,0 +1,8 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLSourceElementImpl extends HTMLElementImpl {}
+
+module.exports = {
+  implementation: HTMLSourceElementImpl
+};

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

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

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

@@ -0,0 +1,76 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { addStylesheet, removeStylesheet, createStylesheet } = require("../helpers/stylesheets");
+const { childTextContent } = require("../helpers/text");
+const { asciiCaseInsensitiveMatch } = require("../helpers/strings");
+
+class HTMLStyleElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.sheet = null;
+    this._isOnStackOfOpenElements = false;
+  }
+
+  _attach() {
+    super._attach();
+    if (!this._isOnStackOfOpenElements) {
+      this._updateAStyleBlock();
+    }
+  }
+
+  _detach() {
+    super._detach();
+    if (!this._isOnStackOfOpenElements) {
+      this._updateAStyleBlock();
+    }
+  }
+
+  _childTextContentChangeSteps() {
+    super._childTextContentChangeSteps();
+
+    // This guard is not required by the spec, but should be unobservable (since you can't run script during the middle
+    // of parsing a <style> element) and saves a bunch of unnecessary work.
+    if (!this._isOnStackOfOpenElements) {
+      this._updateAStyleBlock();
+    }
+  }
+
+  _poppedOffStackOfOpenElements() {
+    this._isOnStackOfOpenElements = false;
+    this._updateAStyleBlock();
+  }
+
+  _pushedOnStackOfOpenElements() {
+    this._isOnStackOfOpenElements = true;
+  }
+
+  _updateAStyleBlock() {
+    if (this.sheet) {
+      removeStylesheet(this.sheet, this);
+    }
+
+    // Browsing-context connected, per https://github.com/whatwg/html/issues/4547
+    if (!this.isConnected || !this._ownerDocument._defaultView) {
+      return;
+    }
+
+    const type = this.getAttributeNS(null, "type");
+    if (type !== null && type !== "" && !asciiCaseInsensitiveMatch(type, "text/css")) {
+      return;
+    }
+
+    // Not implemented: CSP
+
+    const content = childTextContent(this);
+    // Not implemented: a bunch of other state, e.g. title/media attributes
+    const createdSheet = createStylesheet(content, this, this._ownerDocument.baseURLSerialized(), {
+      ownerNode: this
+    });
+    addStylesheet(createdSheet, this);
+  }
+}
+
+module.exports = {
+  implementation: HTMLStyleElementImpl
+};

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

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