update node modules

node_modules/jsdom/lib/jsdom/living/generated/HTMLOutputElement.js

@@ -6,70 +6,86 @@ const utils = require("./utils.js");
 const impl = utils.implSymbol;
 const HTMLElement = require("./HTMLElement.js");
 
-function HTMLOutputElement() {
-  throw new TypeError("Illegal constructor");
-}
-
-Object.setPrototypeOf(HTMLOutputElement.prototype, HTMLElement.interface.prototype);
-Object.setPrototypeOf(HTMLOutputElement, HTMLElement.interface);
-
-Object.defineProperty(HTMLOutputElement, "prototype", {
-  value: HTMLOutputElement.prototype,
-  writable: false,
-  enumerable: false,
-  configurable: false
-});
-
-HTMLOutputElement.prototype.checkValidity = function checkValidity() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+class HTMLOutputElement extends HTMLElement.interface {
+  constructor() {
+    throw new TypeError("Illegal constructor");
   }
 
-  return this[impl].checkValidity();
-};
+  checkValidity() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-HTMLOutputElement.prototype.reportValidity = function reportValidity() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+    return this[impl].checkValidity();
   }
 
-  return this[impl].reportValidity();
-};
+  reportValidity() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-HTMLOutputElement.prototype.setCustomValidity = function setCustomValidity(error) {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+    return this[impl].reportValidity();
   }
 
-  if (arguments.length < 1) {
-    throw new TypeError(
-      "Failed to execute 'setCustomValidity' on 'HTMLOutputElement': 1 argument required, but only " +
-        arguments.length +
-        " present."
-    );
+  setCustomValidity(error) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    if (arguments.length < 1) {
+      throw new TypeError(
+        "Failed to execute 'setCustomValidity' on 'HTMLOutputElement': 1 argument required, but only " +
+          arguments.length +
+          " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["DOMString"](curArg, {
+        context: "Failed to execute 'setCustomValidity' on 'HTMLOutputElement': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return this[impl].setCustomValidity(...args);
   }
-  const args = [];
-  {
-    let curArg = arguments[0];
-    curArg = conversions["DOMString"](curArg, {
-      context: "Failed to execute 'setCustomValidity' on 'HTMLOutputElement': parameter 1"
+
+  get htmlFor() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return utils.getSameObject(this, "htmlFor", () => {
+      return utils.tryWrapperForImpl(this[impl]["htmlFor"]);
     });
-    args.push(curArg);
   }
-  return this[impl].setCustomValidity(...args);
-};
 
-Object.defineProperty(HTMLOutputElement.prototype, "name", {
-  get() {
+  set htmlFor(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    this.htmlFor.value = V;
+  }
+
+  get form() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return utils.tryWrapperForImpl(this[impl]["form"]);
+  }
+
+  get name() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     const value = this.getAttribute("name");
     return value === null ? "" : value;
-  },
+  }
 
-  set(V) {
+  set name(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -79,58 +95,104 @@ Object.defineProperty(HTMLOutputElement.prototype, "name", {
     });
 
     this.setAttribute("name", V);
-  },
+  }
 
-  enumerable: true,
-  configurable: true
-});
+  get type() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-Object.defineProperty(HTMLOutputElement.prototype, "willValidate", {
-  get() {
+    return this[impl]["type"];
+  }
+
+  get defaultValue() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["defaultValue"];
+  }
+
+  set defaultValue(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["DOMString"](V, {
+      context: "Failed to set the 'defaultValue' property on 'HTMLOutputElement': The provided value"
+    });
+
+    this[impl]["defaultValue"] = V;
+  }
+
+  get value() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["value"];
+  }
+
+  set value(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    V = conversions["DOMString"](V, {
+      context: "Failed to set the 'value' property on 'HTMLOutputElement': The provided value"
+    });
+
+    this[impl]["value"] = V;
+  }
+
+  get willValidate() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["willValidate"];
-  },
+  }
 
-  enumerable: true,
-  configurable: true
-});
-
-Object.defineProperty(HTMLOutputElement.prototype, "validity", {
-  get() {
+  get validity() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return utils.tryWrapperForImpl(this[impl]["validity"]);
-  },
+  }
 
-  enumerable: true,
-  configurable: true
-});
-
-Object.defineProperty(HTMLOutputElement.prototype, "validationMessage", {
-  get() {
+  get validationMessage() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["validationMessage"];
-  },
+  }
 
-  enumerable: true,
-  configurable: true
+  get labels() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return utils.tryWrapperForImpl(this[impl]["labels"]);
+  }
+}
+Object.defineProperties(HTMLOutputElement.prototype, {
+  checkValidity: { enumerable: true },
+  reportValidity: { enumerable: true },
+  setCustomValidity: { enumerable: true },
+  htmlFor: { enumerable: true },
+  form: { enumerable: true },
+  name: { enumerable: true },
+  type: { enumerable: true },
+  defaultValue: { enumerable: true },
+  value: { enumerable: true },
+  willValidate: { enumerable: true },
+  validity: { enumerable: true },
+  validationMessage: { enumerable: true },
+  labels: { enumerable: true },
+  [Symbol.toStringTag]: { value: "HTMLOutputElement", configurable: true }
 });
-
-Object.defineProperty(HTMLOutputElement.prototype, Symbol.toStringTag, {
-  value: "HTMLOutputElement",
-  writable: false,
-  enumerable: false,
-  configurable: true
-});
-
 const iface = {
   // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
   // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
@@ -192,8 +254,6 @@ const iface = {
     this._internalSetup(obj);
     Object.defineProperty(obj, impl, {
       value: new Impl.implementation(constructorArgs, privateData),
-      writable: false,
-      enumerable: false,
       configurable: true
     });