@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/constraint-validation/ValidityState-impl.js

@@ -0,0 +1,66 @@
+"use strict";
+
+exports.implementation = class ValidityStateImpl {
+  constructor(globalObject, args, privateData) {
+    const { element, state = {} } = privateData;
+
+    this._element = element;
+    this._state = state;
+  }
+
+  get badInput() {
+    return this._failsConstraint("badInput");
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-a-custom-error
+  get customError() {
+    return this._element._customValidityErrorMessage !== "";
+  }
+
+  get patternMismatch() {
+    return this._failsConstraint("patternMismatch");
+  }
+
+  get rangeOverflow() {
+    return this._failsConstraint("rangeOverflow");
+  }
+
+  get rangeUnderflow() {
+    return this._failsConstraint("rangeUnderflow");
+  }
+
+  get stepMismatch() {
+    return this._failsConstraint("stepMismatch");
+  }
+
+  get tooLong() {
+    return this._failsConstraint("tooLong");
+  }
+
+  get tooShort() {
+    return this._failsConstraint("tooShort");
+  }
+
+  get typeMismatch() {
+    return this._failsConstraint("typeMismatch");
+  }
+
+  get valueMissing() {
+    return this._failsConstraint("valueMissing");
+  }
+
+  _failsConstraint(method) {
+    const validationMethod = this._state[method];
+    if (validationMethod) {
+      return validationMethod();
+    }
+
+    return false;
+  }
+
+  get valid() {
+    return !(this.badInput || this.valueMissing || this.customError ||
+            this.patternMismatch || this.rangeOverflow || this.rangeUnderflow ||
+            this.stepMismatch || this.tooLong || this.tooShort || this.typeMismatch);
+  }
+};

package/lib/jsdom/living/crypto/Crypto-impl.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const nodeCrypto = require("crypto");
+const DOMException = require("../../../generated/idl/DOMException");
+
+// https://w3c.github.io/webcrypto/#crypto-interface
+class CryptoImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  // https://w3c.github.io/webcrypto/#Crypto-method-getRandomValues
+  getRandomValues(array) {
+    const typeName = getTypedArrayTypeName(array);
+    if (!(typeName === "Int8Array" ||
+        typeName === "Uint8Array" ||
+        typeName === "Uint8ClampedArray" ||
+        typeName === "Int16Array" ||
+        typeName === "Uint16Array" ||
+        typeName === "Int32Array" ||
+        typeName === "Uint32Array" ||
+        typeName === "BigInt64Array" ||
+        typeName === "BigUint64Array")) {
+      throw DOMException.create(this._globalObject, [
+        `getRandomValues() only accepts integer typed arrays`,
+        "TypeMismatchError"
+      ]);
+    }
+
+    if (array.byteLength > 65536) {
+      throw DOMException.create(this._globalObject, [
+        `getRandomValues() cannot generate more than 65536 bytes of random values; ` +
+        `${array.byteLength} bytes were requested`,
+        "QuotaExceededError"
+      ]);
+    }
+    nodeCrypto.randomFillSync(array);
+    return array;
+  }
+
+  // https://w3c.github.io/webcrypto/#Crypto-method-randomUUID
+  randomUUID() {
+    return nodeCrypto.randomUUID();
+  }
+}
+
+exports.implementation = CryptoImpl;
+
+// See #3395. Subclasses of TypedArrays should properly work, but we can't rely
+// on instanceof because Uint8Array may be different across different windows -
+// which can happen in JSDOM when running { runScripts: "dangerously" }. As a
+// solution, we imitate the behavior of instanceof by walking the proottype
+// chain.
+function getTypedArrayTypeName(array) {
+  const target = array.constructor;
+  const chain = [target.name];
+  let proto = Object.getPrototypeOf(target);
+  while (proto) {
+    chain.push(proto.name);
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  while (chain.length > 0 && chain[chain.length - 1] !== "TypedArray") {
+    chain.pop();
+  }
+  chain.reverse();
+  return chain[1];
+}

package/lib/jsdom/living/cssom/StyleSheetList-impl.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const idlUtils = require("../../../generated/idl/utils.js");
+
+exports.implementation = class StyleSheetList {
+  constructor() {
+    this._list = [];
+  }
+
+  get length() {
+    return this._list.length;
+  }
+
+  item(index) {
+    const result = this._list[index];
+    return result !== undefined ? result : null;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return this._list.keys();
+  }
+
+  _add(sheet) {
+    const { _list } = this;
+    if (!_list.includes(sheet)) {
+      _list.push(sheet);
+    }
+  }
+
+  _remove(sheet) {
+    const { _list } = this;
+
+    const index = _list.indexOf(sheet);
+    if (index >= 0) {
+      _list.splice(index, 1);
+    }
+  }
+};

package/lib/jsdom/living/custom-elements/CustomElementRegistry-impl.js

@@ -0,0 +1,279 @@
+"use strict";
+
+const webIDLConversions = require("webidl-conversions");
+const DOMException = require("../../../generated/idl/DOMException");
+
+const NODE_TYPE = require("../node-type");
+
+const { HTML_NS } = require("../helpers/namespaces");
+const { getHTMLElementInterface } = require("../helpers/create-element");
+const { shadowIncludingInclusiveDescendantsIterator } = require("../helpers/shadow-dom");
+const { isValidCustomElementName, tryUpgradeElement, enqueueCEUpgradeReaction } = require("../helpers/custom-elements");
+
+const idlUtils = require("../../../generated/idl/utils");
+const IDLFunction = require("../../../generated/idl/Function.js");
+const HTMLUnknownElement = require("../../../generated/idl/HTMLUnknownElement");
+
+const LIFECYCLE_CALLBACKS = [
+  "connectedCallback",
+  "disconnectedCallback",
+  "adoptedCallback",
+  "attributeChangedCallback"
+];
+
+function convertToSequenceDOMString(obj) {
+  if (!obj || !obj[Symbol.iterator]) {
+    throw new TypeError("Invalid Sequence");
+  }
+
+  return Array.from(obj, webIDLConversions.DOMString);
+}
+
+// Returns true is the passed value is a valid constructor.
+// Borrowed from: https://stackoverflow.com/a/39336206/3832710
+function isConstructor(value) {
+  if (typeof value !== "function") {
+    return false;
+  }
+
+  try {
+    const P = new Proxy(value, {
+      construct() {
+        return {};
+      }
+    });
+
+    // eslint-disable-next-line no-new
+    new P();
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// https://html.spec.whatwg.org/#customelementregistry
+class CustomElementRegistryImpl {
+  constructor(globalObject) {
+    this._customElementDefinitions = [];
+    this._elementDefinitionIsRunning = false;
+    this._whenDefinedPromiseMap = Object.create(null);
+
+    this._globalObject = globalObject;
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-define
+  define(name, constructor, options) {
+    const { _globalObject } = this;
+    const ctor = constructor.objectReference;
+
+    if (!isConstructor(ctor)) {
+      throw new TypeError("Constructor argument is not a constructor.");
+    }
+
+    if (!isValidCustomElementName(name)) {
+      throw DOMException.create(_globalObject, ["Name argument is not a valid custom element name.", "SyntaxError"]);
+    }
+
+    const nameAlreadyRegistered = this._customElementDefinitions.some(entry => entry.name === name);
+    if (nameAlreadyRegistered) {
+      throw DOMException.create(_globalObject, [
+        "This name has already been registered in the registry.",
+        "NotSupportedError"
+      ]);
+    }
+
+    const ctorAlreadyRegistered = this._customElementDefinitions.some(entry => entry.objectReference === ctor);
+    if (ctorAlreadyRegistered) {
+      throw DOMException.create(_globalObject, [
+        "This constructor has already been registered in the registry.",
+        "NotSupportedError"
+      ]);
+    }
+
+    let localName = name;
+
+    let extendsOption = null;
+    if (options !== undefined && options.extends) {
+      extendsOption = options.extends;
+    }
+
+    if (extendsOption !== null) {
+      if (isValidCustomElementName(extendsOption)) {
+        throw DOMException.create(_globalObject, [
+          "Option extends value can't be a valid custom element name.",
+          "NotSupportedError"
+        ]);
+      }
+
+      const extendsInterface = getHTMLElementInterface(extendsOption);
+      if (extendsInterface === HTMLUnknownElement) {
+        throw DOMException.create(_globalObject, [
+          `${extendsOption} is an HTMLUnknownElement.`,
+          "NotSupportedError"
+        ]);
+      }
+
+      localName = extendsOption;
+    }
+
+    if (this._elementDefinitionIsRunning) {
+      throw DOMException.create(_globalObject, [
+        "Invalid nested custom element definition.",
+        "NotSupportedError"
+      ]);
+    }
+
+    this._elementDefinitionIsRunning = true;
+
+    let disableInternals = false;
+    let disableShadow = false;
+    let observedAttributes = [];
+    let formAssociated = false;
+    const lifecycleCallbacks = {
+      connectedCallback: null,
+      disconnectedCallback: null,
+      adoptedCallback: null,
+      attributeChangedCallback: null
+    };
+
+    let caughtError;
+    try {
+      const { prototype } = ctor;
+
+      if (typeof prototype !== "object") {
+        throw new TypeError("Invalid constructor prototype.");
+      }
+
+      for (const callbackName of LIFECYCLE_CALLBACKS) {
+        const callbackValue = prototype[callbackName];
+
+        if (callbackValue !== undefined) {
+          lifecycleCallbacks[callbackName] = IDLFunction.convert(_globalObject, callbackValue, {
+            context: `The lifecycle callback "${callbackName}"`
+          });
+        }
+      }
+
+      if (lifecycleCallbacks.attributeChangedCallback !== null) {
+        const observedAttributesIterable = ctor.observedAttributes;
+
+        if (observedAttributesIterable !== undefined) {
+          observedAttributes = convertToSequenceDOMString(observedAttributesIterable);
+        }
+      }
+
+      let disabledFeatures = [];
+      const disabledFeaturesIterable = ctor.disabledFeatures;
+      if (disabledFeaturesIterable) {
+        disabledFeatures = convertToSequenceDOMString(disabledFeaturesIterable);
+      }
+
+      const formAssociatedValue = ctor.formAssociated;
+
+      disableInternals = disabledFeatures.includes("internals");
+      disableShadow = disabledFeatures.includes("shadow");
+      formAssociated = webIDLConversions.boolean(formAssociatedValue);
+    } catch (err) {
+      caughtError = err;
+    } finally {
+      this._elementDefinitionIsRunning = false;
+    }
+
+    if (caughtError !== undefined) {
+      throw caughtError;
+    }
+
+    const definition = {
+      name,
+      localName,
+      constructor,
+      objectReference: ctor,
+      formAssociated,
+      observedAttributes,
+      lifecycleCallbacks,
+      disableShadow,
+      disableInternals,
+      constructionStack: []
+    };
+
+    this._customElementDefinitions.push(definition);
+
+    const document = idlUtils.implForWrapper(this._globalObject._document);
+
+    const upgradeCandidates = [];
+    for (const candidate of shadowIncludingInclusiveDescendantsIterator(document)) {
+      if (
+        (candidate._namespaceURI === HTML_NS && candidate._localName === localName) &&
+        (extendsOption === null || candidate._isValue === name)
+      ) {
+        upgradeCandidates.push(candidate);
+      }
+    }
+
+    for (const upgradeCandidate of upgradeCandidates) {
+      enqueueCEUpgradeReaction(upgradeCandidate, definition);
+    }
+
+    if (this._whenDefinedPromiseMap[name] !== undefined) {
+      this._whenDefinedPromiseMap[name].resolve(ctor);
+      delete this._whenDefinedPromiseMap[name];
+    }
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-get
+  get(name) {
+    const definition = this._customElementDefinitions.find(entry => entry.name === name);
+    return definition && definition.objectReference;
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-getname
+  getName(constructor) {
+    const found = this._customElementDefinitions.find(entry => entry.objectReference === constructor.objectReference);
+    return found ? found.name : null;
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-whendefined
+  whenDefined(name) {
+    if (!isValidCustomElementName(name)) {
+      return Promise.reject(DOMException.create(
+        this._globalObject,
+        ["Name argument is not a valid custom element name.", "SyntaxError"]
+      ));
+    }
+
+    const alreadyRegistered = this._customElementDefinitions.find(entry => entry.name === name);
+    if (alreadyRegistered) {
+      return Promise.resolve(alreadyRegistered.objectReference);
+    }
+
+    if (this._whenDefinedPromiseMap[name] === undefined) {
+      let resolve;
+      const promise = new Promise(r => {
+        resolve = r;
+      });
+
+      // Store the pending Promise along with the extracted resolve callback to actually resolve the returned Promise,
+      // once the custom element is registered.
+      this._whenDefinedPromiseMap[name] = {
+        promise,
+        resolve
+      };
+    }
+
+    return this._whenDefinedPromiseMap[name].promise;
+  }
+
+  // https://html.spec.whatwg.org/#dom-customelementregistry-upgrade
+  upgrade(root) {
+    for (const candidate of shadowIncludingInclusiveDescendantsIterator(root)) {
+      if (candidate.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        tryUpgradeElement(candidate);
+      }
+    }
+  }
+}
+
+module.exports = {
+  implementation: CustomElementRegistryImpl
+};

package/lib/jsdom/living/custom-elements/ElementInternals-impl.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const DOMException = require("../../../generated/idl/DOMException");
+const { getLabelsForLabelable } = require("../helpers/form-controls");
+
+class ElementInternalsImpl {
+  constructor(globalObject, args, { targetElement }) {
+    this._targetElement = targetElement;
+  }
+
+  get shadowRoot() {
+    const shadow = this._targetElement._shadowRoot;
+
+    if (!shadow || !shadow._availableToElementInternals) {
+      return null;
+    }
+
+    return shadow;
+  }
+
+  get labels() {
+    if (!this._targetElement._ceDefinition.formAssociated) {
+      throw DOMException.create(this._targetElement._globalObject, [
+        "Accesing an ElementInternal's labels property is only supported for form-associated custom elements",
+        "NotSupportedError"
+      ]);
+    }
+
+    return getLabelsForLabelable(this._targetElement);
+  }
+
+  // https://html.spec.whatwg.org/#reflecting-content-attributes-in-idl-attributes
+  _reflectGetTheElement() {
+    return this._targetElement;
+  }
+
+  _reflectGetTheContentAttribute(reflectedContentAttributeName) {
+    return this._targetElement._internalContentAttributeMap?.get(reflectedContentAttributeName) ?? null;
+  }
+
+  _reflectSetTheContentAttribute(reflectedContentAttributeName, value) {
+    if (!this._targetElement._internalContentAttributeMap) {
+      this._targetElement._internalContentAttributeMap = new Map();
+    }
+
+    this._targetElement._internalContentAttributeMap.set(reflectedContentAttributeName, value);
+  }
+
+  _reflectDeleteTheContentAttribute(reflectedContentAttributeName) {
+    this._targetElement._internalContentAttributeMap?.delete(reflectedContentAttributeName);
+  }
+}
+
+module.exports = {
+  implementation: ElementInternalsImpl
+};

package/lib/jsdom/living/deviceorientation/DeviceMotionEventAcceleration-impl.js

@@ -0,0 +1,7 @@
+"use strict";
+
+class DeviceMotionEventAccelerationImpl {}
+
+module.exports = {
+  implementation: DeviceMotionEventAccelerationImpl
+};

package/lib/jsdom/living/deviceorientation/DeviceMotionEventRotationRate-impl.js

@@ -0,0 +1,7 @@
+"use strict";
+
+class DeviceMotionEventRotationRateImpl {}
+
+module.exports = {
+  implementation: DeviceMotionEventRotationRateImpl
+};

package/lib/jsdom/living/documents.js

@@ -0,0 +1,15 @@
+"use strict";
+const XMLDocument = require("../../generated/idl/XMLDocument.js");
+const Document = require("../../generated/idl/Document.js");
+const { wrapperForImpl } = require("../../generated/idl/utils.js");
+
+exports.createImpl = (globalObject, options, { alwaysUseDocumentClass = false } = {}) => {
+  if (options.parsingMode === "xml" && !alwaysUseDocumentClass) {
+    return XMLDocument.createImpl(globalObject, [], { options });
+  }
+  return Document.createImpl(globalObject, [], { options });
+};
+
+exports.createWrapper = (...args) => {
+  return wrapperForImpl(exports.createImpl(...args));
+};

package/lib/jsdom/living/domparsing/DOMParser-impl.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const { parseIntoDocument } = require("../../browser/parser");
+
+const idlUtils = require("../../../generated/idl/utils");
+const Document = require("../../../generated/idl/Document");
+
+exports.implementation = class DOMParserImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  parseFromString(string, contentType) {
+    switch (String(contentType)) {
+      case "text/html": {
+        return this.createScriptingDisabledDocument("html", contentType, string);
+      }
+
+      case "text/xml":
+      case "application/xml":
+      case "application/xhtml+xml":
+      case "image/svg+xml": {
+        try {
+          return this.createScriptingDisabledDocument("xml", contentType, string);
+        } catch (error) {
+          const document = this.createScriptingDisabledDocument("xml", contentType);
+          const element = document.createElementNS("http://www.mozilla.org/newlayout/xml/parsererror.xml", "parsererror");
+
+          element.textContent = error.message;
+
+          document.appendChild(element);
+          return document;
+        }
+      }
+
+      default:
+        throw new TypeError("Invalid contentType");
+    }
+  }
+
+  createScriptingDisabledDocument(parsingMode, contentType, string) {
+    const document = Document.createImpl(this._globalObject, [], {
+      options: {
+        parsingMode,
+        encoding: "UTF-8",
+        contentType,
+        readyState: "complete",
+        scriptingDisabled: true,
+        url: idlUtils.implForWrapper(this._globalObject._document).URL
+      }
+    });
+
+    if (string !== undefined) {
+      parseIntoDocument(string, document);
+    }
+
+    return document;
+  }
+};

package/lib/jsdom/living/domparsing/InnerHTML-impl.js

@@ -0,0 +1,30 @@
+"use strict";
+
+const { parseFragment } = require("../../browser/parser");
+const { HTML_NS } = require("../helpers/namespaces.js");
+const { isShadowRoot } = require("../helpers/shadow-dom.js");
+const NODE_TYPE = require("../node-type.js");
+const { fragmentSerialization } = require("./serialization.js");
+
+// https://w3c.github.io/DOM-Parsing/#the-innerhtml-mixin
+exports.implementation = class InnerHTMLImpl {
+  // https://w3c.github.io/DOM-Parsing/#dom-innerhtml-innerhtml
+  get innerHTML() {
+    return fragmentSerialization(this, {
+      outer: false,
+      requireWellFormed: true,
+      globalObject: this._globalObject
+    });
+  }
+  set innerHTML(markup) {
+    const contextElement = isShadowRoot(this) ? this.host : this;
+    const fragment = parseFragment(markup, contextElement);
+
+    let contextObject = this;
+    if (this.nodeType === NODE_TYPE.ELEMENT_NODE && this.localName === "template" && this.namespaceURI === HTML_NS) {
+      contextObject = this._templateContents;
+    }
+
+    contextObject._replaceAll(fragment);
+  }
+};

package/lib/jsdom/living/domparsing/XMLSerializer-impl.js

@@ -0,0 +1,18 @@
+"use strict";
+const serialize = require("w3c-xmlserializer");
+const DOMException = require("../../../generated/idl/DOMException");
+const utils = require("../../../generated/idl/utils");
+
+exports.implementation = class XMLSerializerImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  serializeToString(root) {
+    try {
+      return serialize(utils.wrapperForImpl(root), { requireWellFormed: false });
+    } catch (e) {
+      throw DOMException.create(this._globalObject, [e.message, "InvalidStateError"]);
+    }
+  }
+};