Upload folder using huggingface_hub (part 8)

.gitattributes

@@ -52,3 +52,5 @@ node_modules/bcrypt/prebuilds/win32-arm64/bcrypt.node filter=lfs diff=lfs merge=
 node_modules/bcrypt/prebuilds/win32-x64/bcrypt.node filter=lfs diff=lfs merge=lfs -text
 node_modules/better-sqlite3/build/Release/better_sqlite3.node filter=lfs diff=lfs merge=lfs -text
 node_modules/esbuild/bin/esbuild filter=lfs diff=lfs merge=lfs -text
+node_modules/lightningcss-linux-x64-gnu/lightningcss.linux-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
+node_modules/lightningcss-linux-x64-musl/lightningcss.linux-x64-musl.node filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,56 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  function invokeTheCallbackFunction(...args) {
+    const thisArg = utils.tryWrapperForImpl(this);
+    let callResult;
+
+    if (typeof value === "function") {
+      for (let i = 0; i < Math.min(args.length, 5); i++) {
+        args[i] = utils.tryWrapperForImpl(args[i]);
+      }
+
+      if (args.length < 1) {
+        for (let i = args.length; i < 1; i++) {
+          args[i] = undefined;
+        }
+      } else if (args.length > 5) {
+        args.length = 5;
+      }
+
+      callResult = Reflect.apply(value, thisArg, args);
+    }
+
+    callResult = conversions["any"](callResult, { context: context, globals: globalObject });
+
+    return callResult;
+  }
+
+  invokeTheCallbackFunction.construct = (...args) => {
+    for (let i = 0; i < Math.min(args.length, 5); i++) {
+      args[i] = utils.tryWrapperForImpl(args[i]);
+    }
+
+    if (args.length < 1) {
+      for (let i = args.length; i < 1; i++) {
+        args[i] = undefined;
+      }
+    } else if (args.length > 5) {
+      args.length = 5;
+    }
+
+    let callResult = Reflect.construct(value, args);
+
+    callResult = conversions["any"](callResult, { context: context, globals: globalObject });
+
+    return callResult;
+  };
+
+  invokeTheCallbackFunction[utils.wrapperSymbol] = value;
+  invokeTheCallbackFunction.objectReference = value;
+
+  return invokeTheCallbackFunction;
+};

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

@@ -0,0 +1,144 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const PageTransitionEventInit = require("./PageTransitionEventInit.js");
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "PageTransitionEvent";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'PageTransitionEvent'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["PageTransitionEvent"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  Event._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class PageTransitionEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to construct 'PageTransitionEvent': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to construct 'PageTransitionEvent': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = PageTransitionEventInit.convert(globalObject, curArg, {
+          context: "Failed to construct 'PageTransitionEvent': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get persisted() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get persisted' called on an object that is not a valid instance of PageTransitionEvent."
+        );
+      }
+
+      return esValue[implSymbol]["persisted"];
+    }
+  }
+  Object.defineProperties(PageTransitionEvent.prototype, {
+    persisted: { enumerable: true },
+    [Symbol.toStringTag]: { value: "PageTransitionEvent", configurable: true }
+  });
+  ctorRegistry[interfaceName] = PageTransitionEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PageTransitionEvent
+  });
+};
+
+const Impl = require("../events/PageTransitionEvent-impl.js");

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

@@ -0,0 +1,35 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  EventInit._convertInherit(globalObject, obj, ret, { context });
+
+  {
+    const key = "persisted";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, {
+        context: context + " has member 'persisted' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,142 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const EventTarget = require("./EventTarget.js");
+
+const interfaceName = "Performance";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'Performance'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["Performance"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  EventTarget._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window", "Worker"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class Performance extends globalObject.EventTarget {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    now() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'now' called on an object that is not a valid instance of Performance.");
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol].now());
+    }
+
+    toJSON() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'toJSON' called on an object that is not a valid instance of Performance.");
+      }
+
+      return esValue[implSymbol].toJSON();
+    }
+
+    get timeOrigin() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get timeOrigin' called on an object that is not a valid instance of Performance."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["timeOrigin"]);
+    }
+  }
+  Object.defineProperties(Performance.prototype, {
+    now: { enumerable: true },
+    toJSON: { enumerable: true },
+    timeOrigin: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Performance", configurable: true }
+  });
+  ctorRegistry[interfaceName] = Performance;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Performance
+  });
+};
+
+const Impl = require("../hr-time/Performance-impl.js");

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

@@ -0,0 +1,359 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "Plugin";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'Plugin'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["Plugin"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+function makeProxy(wrapper, globalObject) {
+  let proxyHandler = proxyHandlerCache.get(globalObject);
+  if (proxyHandler === undefined) {
+    proxyHandler = new ProxyHandler(globalObject);
+    proxyHandlerCache.set(globalObject, proxyHandler);
+  }
+  return new Proxy(wrapper, proxyHandler);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  let wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class Plugin {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    item(index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'item' called on an object that is not a valid instance of Plugin.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'item' on 'Plugin': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'item' on 'Plugin': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].item(...args);
+    }
+
+    namedItem(name) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'namedItem' called on an object that is not a valid instance of Plugin.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'namedItem' on 'Plugin': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'namedItem' on 'Plugin': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].namedItem(...args);
+    }
+
+    get name() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get name' called on an object that is not a valid instance of Plugin.");
+      }
+
+      return esValue[implSymbol]["name"];
+    }
+
+    get description() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get description' called on an object that is not a valid instance of Plugin."
+        );
+      }
+
+      return esValue[implSymbol]["description"];
+    }
+
+    get filename() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get filename' called on an object that is not a valid instance of Plugin.");
+      }
+
+      return esValue[implSymbol]["filename"];
+    }
+
+    get length() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get length' called on an object that is not a valid instance of Plugin.");
+      }
+
+      return esValue[implSymbol]["length"];
+    }
+  }
+  Object.defineProperties(Plugin.prototype, {
+    item: { enumerable: true },
+    namedItem: { enumerable: true },
+    name: { enumerable: true },
+    description: { enumerable: true },
+    filename: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Plugin", configurable: true },
+    [Symbol.iterator]: { value: globalObject.Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  ctorRegistry[interfaceName] = Plugin;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Plugin
+  });
+};
+
+const proxyHandlerCache = new WeakMap();
+class ProxyHandler {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  get(target, P, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.get(target, P, receiver);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc === undefined) {
+      const parent = Object.getPrototypeOf(target);
+      if (parent === null) {
+        return undefined;
+      }
+      return Reflect.get(target, P, receiver);
+    }
+    if (!desc.get && !desc.set) {
+      return desc.value;
+    }
+    const getter = desc.get;
+    if (getter === undefined) {
+      return undefined;
+    }
+    return Reflect.apply(getter, receiver, []);
+  }
+
+  has(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.has(target, P);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc !== undefined) {
+      return true;
+    }
+    const parent = Object.getPrototypeOf(target);
+    if (parent !== null) {
+      return Reflect.has(parent, P);
+    }
+    return false;
+  }
+
+  ownKeys(target) {
+    const keys = new Set();
+
+    for (const key of target[implSymbol][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of Reflect.ownKeys(target)) {
+      keys.add(key);
+    }
+    return [...keys];
+  }
+
+  getOwnPropertyDescriptor(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    let ignoreNamedProps = false;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+
+      if (target[implSymbol][utils.supportsPropertyIndex](index)) {
+        const indexedValue = target[implSymbol].item(index);
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    return Reflect.getOwnPropertyDescriptor(target, P);
+  }
+
+  set(target, P, V, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.set(target, P, V, receiver);
+    }
+    // The `receiver` argument refers to the Proxy exotic object or an object
+    // that inherits from it, whereas `target` refers to the Proxy target:
+    if (target[implSymbol][utils.wrapperSymbol] === receiver) {
+      const globalObject = this._globalObject;
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+
+      if (target[implSymbol][utils.supportsPropertyIndex](index)) {
+        const indexedValue = target[implSymbol].item(index);
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    return utils.ordinarySetWithOwnDescriptor(target, P, V, receiver, ownDesc);
+  }
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  }
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !target[implSymbol][utils.supportsPropertyIndex](index);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../navigator/Plugin-impl.js");

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

@@ -0,0 +1,336 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "PluginArray";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'PluginArray'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["PluginArray"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+function makeProxy(wrapper, globalObject) {
+  let proxyHandler = proxyHandlerCache.get(globalObject);
+  if (proxyHandler === undefined) {
+    proxyHandler = new ProxyHandler(globalObject);
+    proxyHandlerCache.set(globalObject, proxyHandler);
+  }
+  return new Proxy(wrapper, proxyHandler);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  let wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class PluginArray {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    refresh() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'refresh' called on an object that is not a valid instance of PluginArray.");
+      }
+
+      return esValue[implSymbol].refresh();
+    }
+
+    item(index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'item' called on an object that is not a valid instance of PluginArray.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'item' on 'PluginArray': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'item' on 'PluginArray': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].item(...args);
+    }
+
+    namedItem(name) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'namedItem' called on an object that is not a valid instance of PluginArray."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'namedItem' on 'PluginArray': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'namedItem' on 'PluginArray': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].namedItem(...args);
+    }
+
+    get length() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get length' called on an object that is not a valid instance of PluginArray."
+        );
+      }
+
+      return esValue[implSymbol]["length"];
+    }
+  }
+  Object.defineProperties(PluginArray.prototype, {
+    refresh: { enumerable: true },
+    item: { enumerable: true },
+    namedItem: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "PluginArray", configurable: true },
+    [Symbol.iterator]: { value: globalObject.Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  ctorRegistry[interfaceName] = PluginArray;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PluginArray
+  });
+};
+
+const proxyHandlerCache = new WeakMap();
+class ProxyHandler {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  get(target, P, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.get(target, P, receiver);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc === undefined) {
+      const parent = Object.getPrototypeOf(target);
+      if (parent === null) {
+        return undefined;
+      }
+      return Reflect.get(target, P, receiver);
+    }
+    if (!desc.get && !desc.set) {
+      return desc.value;
+    }
+    const getter = desc.get;
+    if (getter === undefined) {
+      return undefined;
+    }
+    return Reflect.apply(getter, receiver, []);
+  }
+
+  has(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.has(target, P);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc !== undefined) {
+      return true;
+    }
+    const parent = Object.getPrototypeOf(target);
+    if (parent !== null) {
+      return Reflect.has(parent, P);
+    }
+    return false;
+  }
+
+  ownKeys(target) {
+    const keys = new Set();
+
+    for (const key of target[implSymbol][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of Reflect.ownKeys(target)) {
+      keys.add(key);
+    }
+    return [...keys];
+  }
+
+  getOwnPropertyDescriptor(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    let ignoreNamedProps = false;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[implSymbol].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    return Reflect.getOwnPropertyDescriptor(target, P);
+  }
+
+  set(target, P, V, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.set(target, P, V, receiver);
+    }
+    // The `receiver` argument refers to the Proxy exotic object or an object
+    // that inherits from it, whereas `target` refers to the Proxy target:
+    if (target[implSymbol][utils.wrapperSymbol] === receiver) {
+      const globalObject = this._globalObject;
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[implSymbol].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    return utils.ordinarySetWithOwnDescriptor(target, P, V, receiver, ownDesc);
+  }
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  }
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[implSymbol].item(index) !== null);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../navigator/PluginArray-impl.js");

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

@@ -0,0 +1,324 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const PointerEventInit = require("./PointerEventInit.js");
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const MouseEvent = require("./MouseEvent.js");
+
+const interfaceName = "PointerEvent";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'PointerEvent'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["PointerEvent"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  MouseEvent._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class PointerEvent extends globalObject.MouseEvent {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to construct 'PointerEvent': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to construct 'PointerEvent': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = PointerEventInit.convert(globalObject, curArg, {
+          context: "Failed to construct 'PointerEvent': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    getCoalescedEvents() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'getCoalescedEvents' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol].getCoalescedEvents());
+    }
+
+    getPredictedEvents() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'getPredictedEvents' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol].getPredictedEvents());
+    }
+
+    get pointerId() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get pointerId' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["pointerId"];
+    }
+
+    get width() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get width' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["width"];
+    }
+
+    get height() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get height' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["height"];
+    }
+
+    get pressure() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get pressure' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["pressure"];
+    }
+
+    get tangentialPressure() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get tangentialPressure' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["tangentialPressure"];
+    }
+
+    get tiltX() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get tiltX' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["tiltX"];
+    }
+
+    get tiltY() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get tiltY' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["tiltY"];
+    }
+
+    get twist() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get twist' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["twist"];
+    }
+
+    get altitudeAngle() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get altitudeAngle' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["altitudeAngle"];
+    }
+
+    get azimuthAngle() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get azimuthAngle' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["azimuthAngle"];
+    }
+
+    get pointerType() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get pointerType' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["pointerType"];
+    }
+
+    get isPrimary() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get isPrimary' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["isPrimary"];
+    }
+
+    get persistentDeviceId() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get persistentDeviceId' called on an object that is not a valid instance of PointerEvent."
+        );
+      }
+
+      return esValue[implSymbol]["persistentDeviceId"];
+    }
+  }
+  Object.defineProperties(PointerEvent.prototype, {
+    getCoalescedEvents: { enumerable: true },
+    getPredictedEvents: { enumerable: true },
+    pointerId: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    pressure: { enumerable: true },
+    tangentialPressure: { enumerable: true },
+    tiltX: { enumerable: true },
+    tiltY: { enumerable: true },
+    twist: { enumerable: true },
+    altitudeAngle: { enumerable: true },
+    azimuthAngle: { enumerable: true },
+    pointerType: { enumerable: true },
+    isPrimary: { enumerable: true },
+    persistentDeviceId: { enumerable: true },
+    [Symbol.toStringTag]: { value: "PointerEvent", configurable: true }
+  });
+  ctorRegistry[interfaceName] = PointerEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PointerEvent
+  });
+};
+
+const Impl = require("../events/PointerEvent-impl.js");

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

@@ -0,0 +1,241 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const PointerEvent = require("./PointerEvent.js");
+const MouseEventInit = require("./MouseEventInit.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  MouseEventInit._convertInherit(globalObject, obj, ret, { context });
+
+  {
+    const key = "altitudeAngle";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["double"](value, {
+        context: context + " has member 'altitudeAngle' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "azimuthAngle";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["double"](value, {
+        context: context + " has member 'azimuthAngle' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "coalescedEvents";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (!utils.isObject(value)) {
+        throw new globalObject.TypeError(
+          context + " has member 'coalescedEvents' that" + " is not an iterable object."
+        );
+      } else {
+        const V = [];
+        const tmp = value;
+        for (let nextItem of tmp) {
+          nextItem = PointerEvent.convert(globalObject, nextItem, {
+            context: context + " has member 'coalescedEvents' that" + "'s element"
+          });
+
+          V.push(nextItem);
+        }
+        value = V;
+      }
+
+      ret[key] = value;
+    } else {
+      ret[key] = [];
+    }
+  }
+
+  {
+    const key = "height";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["double"](value, { context: context + " has member 'height' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 1;
+    }
+  }
+
+  {
+    const key = "isPrimary";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, {
+        context: context + " has member 'isPrimary' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "persistentDeviceId";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, {
+        context: context + " has member 'persistentDeviceId' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "pointerId";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member 'pointerId' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "pointerType";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["DOMString"](value, {
+        context: context + " has member 'pointerType' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "";
+    }
+  }
+
+  {
+    const key = "predictedEvents";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      if (!utils.isObject(value)) {
+        throw new globalObject.TypeError(
+          context + " has member 'predictedEvents' that" + " is not an iterable object."
+        );
+      } else {
+        const V = [];
+        const tmp = value;
+        for (let nextItem of tmp) {
+          nextItem = PointerEvent.convert(globalObject, nextItem, {
+            context: context + " has member 'predictedEvents' that" + "'s element"
+          });
+
+          V.push(nextItem);
+        }
+        value = V;
+      }
+
+      ret[key] = value;
+    } else {
+      ret[key] = [];
+    }
+  }
+
+  {
+    const key = "pressure";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["float"](value, { context: context + " has member 'pressure' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "tangentialPressure";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["float"](value, {
+        context: context + " has member 'tangentialPressure' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "tiltX";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member 'tiltX' that", globals: globalObject });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "tiltY";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member 'tiltY' that", globals: globalObject });
+
+      ret[key] = value;
+    }
+  }
+
+  {
+    const key = "twist";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["long"](value, { context: context + " has member 'twist' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "width";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["double"](value, { context: context + " has member 'width' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 1;
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,144 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const PopStateEventInit = require("./PopStateEventInit.js");
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "PopStateEvent";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'PopStateEvent'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["PopStateEvent"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  Event._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class PopStateEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to construct 'PopStateEvent': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to construct 'PopStateEvent': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = PopStateEventInit.convert(globalObject, curArg, {
+          context: "Failed to construct 'PopStateEvent': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get state() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get state' called on an object that is not a valid instance of PopStateEvent."
+        );
+      }
+
+      return esValue[implSymbol]["state"];
+    }
+  }
+  Object.defineProperties(PopStateEvent.prototype, {
+    state: { enumerable: true },
+    [Symbol.toStringTag]: { value: "PopStateEvent", configurable: true }
+  });
+  ctorRegistry[interfaceName] = PopStateEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PopStateEvent
+  });
+};
+
+const Impl = require("../events/PopStateEvent-impl.js");

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

@@ -0,0 +1,32 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  EventInit._convertInherit(globalObject, obj, ret, { context });
+
+  {
+    const key = "state";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["any"](value, { context: context + " has member 'state' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = null;
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,122 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const CharacterData = require("./CharacterData.js");
+
+const interfaceName = "ProcessingInstruction";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'ProcessingInstruction'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["ProcessingInstruction"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  CharacterData._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class ProcessingInstruction extends globalObject.CharacterData {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get target() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get target' called on an object that is not a valid instance of ProcessingInstruction."
+        );
+      }
+
+      return esValue[implSymbol]["target"];
+    }
+  }
+  Object.defineProperties(ProcessingInstruction.prototype, {
+    target: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ProcessingInstruction", configurable: true }
+  });
+  ctorRegistry[interfaceName] = ProcessingInstruction;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ProcessingInstruction
+  });
+};
+
+const Impl = require("../nodes/ProcessingInstruction-impl.js");

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

@@ -0,0 +1,170 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const ProgressEventInit = require("./ProgressEventInit.js");
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "ProgressEvent";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'ProgressEvent'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["ProgressEvent"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  Event._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window", "DedicatedWorker", "SharedWorker"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class ProgressEvent extends globalObject.Event {
+    constructor(type) {
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to construct 'ProgressEvent': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to construct 'ProgressEvent': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = ProgressEventInit.convert(globalObject, curArg, {
+          context: "Failed to construct 'ProgressEvent': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get lengthComputable() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get lengthComputable' called on an object that is not a valid instance of ProgressEvent."
+        );
+      }
+
+      return esValue[implSymbol]["lengthComputable"];
+    }
+
+    get loaded() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get loaded' called on an object that is not a valid instance of ProgressEvent."
+        );
+      }
+
+      return esValue[implSymbol]["loaded"];
+    }
+
+    get total() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get total' called on an object that is not a valid instance of ProgressEvent."
+        );
+      }
+
+      return esValue[implSymbol]["total"];
+    }
+  }
+  Object.defineProperties(ProgressEvent.prototype, {
+    lengthComputable: { enumerable: true },
+    loaded: { enumerable: true },
+    total: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ProgressEvent", configurable: true }
+  });
+  ctorRegistry[interfaceName] = ProgressEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ProgressEvent
+  });
+};
+
+const Impl = require("../events/ProgressEvent-impl.js");

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

@@ -0,0 +1,65 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  EventInit._convertInherit(globalObject, obj, ret, { context });
+
+  {
+    const key = "lengthComputable";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, {
+        context: context + " has member 'lengthComputable' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "loaded";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long long"](value, {
+        context: context + " has member 'loaded' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+
+  {
+    const key = "total";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long long"](value, {
+        context: context + " has member 'total' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      ret[key] = 0;
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,157 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const PromiseRejectionEventInit = require("./PromiseRejectionEventInit.js");
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const Event = require("./Event.js");
+
+const interfaceName = "PromiseRejectionEvent";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'PromiseRejectionEvent'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["PromiseRejectionEvent"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  Event._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class PromiseRejectionEvent extends globalObject.Event {
+    constructor(type, eventInitDict) {
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to construct 'PromiseRejectionEvent': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to construct 'PromiseRejectionEvent': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = PromiseRejectionEventInit.convert(globalObject, curArg, {
+          context: "Failed to construct 'PromiseRejectionEvent': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get promise() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get promise' called on an object that is not a valid instance of PromiseRejectionEvent."
+        );
+      }
+
+      return esValue[implSymbol]["promise"];
+    }
+
+    get reason() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get reason' called on an object that is not a valid instance of PromiseRejectionEvent."
+        );
+      }
+
+      return esValue[implSymbol]["reason"];
+    }
+  }
+  Object.defineProperties(PromiseRejectionEvent.prototype, {
+    promise: { enumerable: true },
+    reason: { enumerable: true },
+    [Symbol.toStringTag]: { value: "PromiseRejectionEvent", configurable: true }
+  });
+  ctorRegistry[interfaceName] = PromiseRejectionEvent;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: PromiseRejectionEvent
+  });
+};
+
+const Impl = require("../events/PromiseRejectionEvent-impl.js");

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

@@ -0,0 +1,42 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const EventInit = require("./EventInit.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  EventInit._convertInherit(globalObject, obj, ret, { context });
+
+  {
+    const key = "promise";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["object"](value, { context: context + " has member 'promise' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      throw new globalObject.TypeError("promise is required in 'PromiseRejectionEventInit'");
+    }
+  }
+
+  {
+    const key = "reason";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["any"](value, { context: context + " has member 'reason' that", globals: globalObject });
+
+      ret[key] = value;
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,296 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const NodeList = require("./NodeList.js");
+
+const interfaceName = "RadioNodeList";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'RadioNodeList'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["RadioNodeList"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+function makeProxy(wrapper, globalObject) {
+  let proxyHandler = proxyHandlerCache.get(globalObject);
+  if (proxyHandler === undefined) {
+    proxyHandler = new ProxyHandler(globalObject);
+    proxyHandlerCache.set(globalObject, proxyHandler);
+  }
+  return new Proxy(wrapper, proxyHandler);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  NodeList._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  let wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class RadioNodeList extends globalObject.NodeList {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get value() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get value' called on an object that is not a valid instance of RadioNodeList."
+        );
+      }
+
+      return esValue[implSymbol]["value"];
+    }
+
+    set value(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set value' called on an object that is not a valid instance of RadioNodeList."
+        );
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'value' property on 'RadioNodeList': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["value"] = V;
+    }
+  }
+  Object.defineProperties(RadioNodeList.prototype, {
+    value: { enumerable: true },
+    [Symbol.toStringTag]: { value: "RadioNodeList", configurable: true },
+    [Symbol.iterator]: { value: globalObject.Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  ctorRegistry[interfaceName] = RadioNodeList;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: RadioNodeList
+  });
+};
+
+const proxyHandlerCache = new WeakMap();
+class ProxyHandler {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  get(target, P, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.get(target, P, receiver);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc === undefined) {
+      const parent = Object.getPrototypeOf(target);
+      if (parent === null) {
+        return undefined;
+      }
+      return Reflect.get(target, P, receiver);
+    }
+    if (!desc.get && !desc.set) {
+      return desc.value;
+    }
+    const getter = desc.get;
+    if (getter === undefined) {
+      return undefined;
+    }
+    return Reflect.apply(getter, receiver, []);
+  }
+
+  has(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.has(target, P);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc !== undefined) {
+      return true;
+    }
+    const parent = Object.getPrototypeOf(target);
+    if (parent !== null) {
+      return Reflect.has(parent, P);
+    }
+    return false;
+  }
+
+  ownKeys(target) {
+    const keys = new Set();
+
+    for (const key of target[implSymbol][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of Reflect.ownKeys(target)) {
+      keys.add(key);
+    }
+    return [...keys];
+  }
+
+  getOwnPropertyDescriptor(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    let ignoreNamedProps = false;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[implSymbol].item(index);
+      if (indexedValue !== null) {
+        return {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    return Reflect.getOwnPropertyDescriptor(target, P);
+  }
+
+  set(target, P, V, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.set(target, P, V, receiver);
+    }
+    // The `receiver` argument refers to the Proxy exotic object or an object
+    // that inherits from it, whereas `target` refers to the Proxy target:
+    if (target[implSymbol][utils.wrapperSymbol] === receiver) {
+      const globalObject = this._globalObject;
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      const indexedValue = target[implSymbol].item(index);
+      if (indexedValue !== null) {
+        ownDesc = {
+          writable: false,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    return utils.ordinarySetWithOwnDescriptor(target, P, V, receiver, ownDesc);
+  }
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      return false;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  }
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !(target[implSymbol].item(index) !== null);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../nodes/RadioNodeList-impl.js");

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

@@ -0,0 +1,641 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const Node = require("./Node.js");
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const AbstractRange = require("./AbstractRange.js");
+
+const interfaceName = "Range";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'Range'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["Range"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  AbstractRange._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class Range extends globalObject.AbstractRange {
+    constructor() {
+      return exports.setup(Object.create(new.target.prototype), globalObject, undefined);
+    }
+
+    setStart(node, offset) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'setStart' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setStart' on 'Range': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'setStart' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setStart' on 'Range': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setStart(...args);
+    }
+
+    setEnd(node, offset) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'setEnd' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setEnd' on 'Range': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, { context: "Failed to execute 'setEnd' on 'Range': parameter 1" });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setEnd' on 'Range': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setEnd(...args);
+    }
+
+    setStartBefore(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'setStartBefore' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setStartBefore' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'setStartBefore' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setStartBefore(...args);
+    }
+
+    setStartAfter(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'setStartAfter' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setStartAfter' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'setStartAfter' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setStartAfter(...args);
+    }
+
+    setEndBefore(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'setEndBefore' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setEndBefore' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'setEndBefore' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setEndBefore(...args);
+    }
+
+    setEndAfter(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'setEndAfter' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setEndAfter' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'setEndAfter' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setEndAfter(...args);
+    }
+
+    collapse() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'collapse' called on an object that is not a valid instance of Range.");
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'collapse' on 'Range': parameter 1",
+            globals: globalObject
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      return esValue[implSymbol].collapse(...args);
+    }
+
+    selectNode(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'selectNode' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'selectNode' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'selectNode' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].selectNode(...args);
+    }
+
+    selectNodeContents(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'selectNodeContents' called on an object that is not a valid instance of Range."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'selectNodeContents' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'selectNodeContents' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].selectNodeContents(...args);
+    }
+
+    compareBoundaryPoints(how, sourceRange) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'compareBoundaryPoints' called on an object that is not a valid instance of Range."
+        );
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'compareBoundaryPoints' on 'Range': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned short"](curArg, {
+          context: "Failed to execute 'compareBoundaryPoints' on 'Range': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = exports.convert(globalObject, curArg, {
+          context: "Failed to execute 'compareBoundaryPoints' on 'Range': parameter 2"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].compareBoundaryPoints(...args);
+    }
+
+    deleteContents() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'deleteContents' called on an object that is not a valid instance of Range.");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return esValue[implSymbol].deleteContents();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    extractContents() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'extractContents' called on an object that is not a valid instance of Range."
+        );
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(esValue[implSymbol].extractContents());
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    cloneContents() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'cloneContents' called on an object that is not a valid instance of Range.");
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(esValue[implSymbol].cloneContents());
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    insertNode(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'insertNode' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'insertNode' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'insertNode' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return esValue[implSymbol].insertNode(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    surroundContents(newParent) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'surroundContents' called on an object that is not a valid instance of Range."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'surroundContents' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'surroundContents' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return esValue[implSymbol].surroundContents(...args);
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    cloneRange() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'cloneRange' called on an object that is not a valid instance of Range.");
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol].cloneRange());
+    }
+
+    detach() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'detach' called on an object that is not a valid instance of Range.");
+      }
+
+      return esValue[implSymbol].detach();
+    }
+
+    isPointInRange(node, offset) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'isPointInRange' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'isPointInRange' on 'Range': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'isPointInRange' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'isPointInRange' on 'Range': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].isPointInRange(...args);
+    }
+
+    comparePoint(node, offset) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'comparePoint' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'comparePoint' on 'Range': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'comparePoint' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'comparePoint' on 'Range': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].comparePoint(...args);
+    }
+
+    intersectsNode(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'intersectsNode' called on an object that is not a valid instance of Range.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'intersectsNode' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'intersectsNode' on 'Range': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].intersectsNode(...args);
+    }
+
+    toString() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'toString' called on an object that is not a valid instance of Range.");
+      }
+
+      return esValue[implSymbol].toString();
+    }
+
+    createContextualFragment(fragment) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'createContextualFragment' called on an object that is not a valid instance of Range."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'createContextualFragment' on 'Range': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'createContextualFragment' on 'Range': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return utils.tryWrapperForImpl(esValue[implSymbol].createContextualFragment(...args));
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get commonAncestorContainer() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get commonAncestorContainer' called on an object that is not a valid instance of Range."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["commonAncestorContainer"]);
+    }
+  }
+  Object.defineProperties(Range.prototype, {
+    setStart: { enumerable: true },
+    setEnd: { enumerable: true },
+    setStartBefore: { enumerable: true },
+    setStartAfter: { enumerable: true },
+    setEndBefore: { enumerable: true },
+    setEndAfter: { enumerable: true },
+    collapse: { enumerable: true },
+    selectNode: { enumerable: true },
+    selectNodeContents: { enumerable: true },
+    compareBoundaryPoints: { enumerable: true },
+    deleteContents: { enumerable: true },
+    extractContents: { enumerable: true },
+    cloneContents: { enumerable: true },
+    insertNode: { enumerable: true },
+    surroundContents: { enumerable: true },
+    cloneRange: { enumerable: true },
+    detach: { enumerable: true },
+    isPointInRange: { enumerable: true },
+    comparePoint: { enumerable: true },
+    intersectsNode: { enumerable: true },
+    toString: { enumerable: true },
+    createContextualFragment: { enumerable: true },
+    commonAncestorContainer: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Range", configurable: true },
+    START_TO_START: { value: 0, enumerable: true },
+    START_TO_END: { value: 1, enumerable: true },
+    END_TO_END: { value: 2, enumerable: true },
+    END_TO_START: { value: 3, enumerable: true }
+  });
+  Object.defineProperties(Range, {
+    START_TO_START: { value: 0, enumerable: true },
+    START_TO_END: { value: 1, enumerable: true },
+    END_TO_END: { value: 2, enumerable: true },
+    END_TO_START: { value: 3, enumerable: true }
+  });
+  ctorRegistry[interfaceName] = Range;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Range
+  });
+};
+
+const Impl = require("../range/Range-impl.js");

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

@@ -0,0 +1,136 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGAnimatedPreserveAspectRatio";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGAnimatedPreserveAspectRatio'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGAnimatedPreserveAspectRatio"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGAnimatedPreserveAspectRatio {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get baseVal() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get baseVal' called on an object that is not a valid instance of SVGAnimatedPreserveAspectRatio."
+        );
+      }
+
+      return utils.getSameObject(this, "baseVal", () => {
+        return utils.tryWrapperForImpl(esValue[implSymbol]["baseVal"]);
+      });
+    }
+
+    get animVal() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get animVal' called on an object that is not a valid instance of SVGAnimatedPreserveAspectRatio."
+        );
+      }
+
+      return utils.getSameObject(this, "animVal", () => {
+        return utils.tryWrapperForImpl(esValue[implSymbol]["animVal"]);
+      });
+    }
+  }
+  Object.defineProperties(SVGAnimatedPreserveAspectRatio.prototype, {
+    baseVal: { enumerable: true },
+    animVal: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGAnimatedPreserveAspectRatio", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGAnimatedPreserveAspectRatio;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGAnimatedPreserveAspectRatio
+  });
+};
+
+const Impl = require("../svg/SVGAnimatedPreserveAspectRatio-impl.js");

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

@@ -0,0 +1,136 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGAnimatedRect";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGAnimatedRect'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGAnimatedRect"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGAnimatedRect {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get baseVal() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get baseVal' called on an object that is not a valid instance of SVGAnimatedRect."
+        );
+      }
+
+      return utils.getSameObject(this, "baseVal", () => {
+        return utils.tryWrapperForImpl(esValue[implSymbol]["baseVal"]);
+      });
+    }
+
+    get animVal() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get animVal' called on an object that is not a valid instance of SVGAnimatedRect."
+        );
+      }
+
+      return utils.getSameObject(this, "animVal", () => {
+        return utils.tryWrapperForImpl(esValue[implSymbol]["animVal"]);
+      });
+    }
+  }
+  Object.defineProperties(SVGAnimatedRect.prototype, {
+    baseVal: { enumerable: true },
+    animVal: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGAnimatedRect", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGAnimatedRect;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGAnimatedRect
+  });
+};
+
+const Impl = require("../svg/SVGAnimatedRect-impl.js");

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

@@ -0,0 +1,149 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGAnimatedString";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGAnimatedString'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGAnimatedString"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGAnimatedString {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get baseVal() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get baseVal' called on an object that is not a valid instance of SVGAnimatedString."
+        );
+      }
+
+      return esValue[implSymbol]["baseVal"];
+    }
+
+    set baseVal(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set baseVal' called on an object that is not a valid instance of SVGAnimatedString."
+        );
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'baseVal' property on 'SVGAnimatedString': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["baseVal"] = V;
+    }
+
+    get animVal() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get animVal' called on an object that is not a valid instance of SVGAnimatedString."
+        );
+      }
+
+      return esValue[implSymbol]["animVal"];
+    }
+  }
+  Object.defineProperties(SVGAnimatedString.prototype, {
+    baseVal: { enumerable: true },
+    animVal: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGAnimatedString", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGAnimatedString;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGAnimatedString
+  });
+};
+
+const Impl = require("../svg/SVGAnimatedString-impl.js");

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

@@ -0,0 +1,64 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  {
+    const key = "clipped";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member 'clipped' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "fill";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member 'fill' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = true;
+    }
+  }
+
+  {
+    const key = "markers";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member 'markers' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+
+  {
+    const key = "stroke";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["boolean"](value, { context: context + " has member 'stroke' that", globals: globalObject });
+
+      ret[key] = value;
+    } else {
+      ret[key] = false;
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,109 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGGraphicsElement = require("./SVGGraphicsElement.js");
+
+const interfaceName = "SVGDefsElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGDefsElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGDefsElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGGraphicsElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGDefsElement extends globalObject.SVGGraphicsElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(SVGDefsElement.prototype, {
+    [Symbol.toStringTag]: { value: "SVGDefsElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGDefsElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGDefsElement
+  });
+};
+
+const Impl = require("../nodes/SVGDefsElement-impl.js");

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

@@ -0,0 +1,109 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGElement = require("./SVGElement.js");
+
+const interfaceName = "SVGDescElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGDescElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGDescElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGDescElement extends globalObject.SVGElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(SVGDescElement.prototype, {
+    [Symbol.toStringTag]: { value: "SVGDescElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGDescElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGDescElement
+  });
+};
+
+const Impl = require("../nodes/SVGDescElement-impl.js");

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

@@ -0,0 +1,109 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGGraphicsElement = require("./SVGGraphicsElement.js");
+
+const interfaceName = "SVGGElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGGElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGGElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGGraphicsElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGGElement extends globalObject.SVGGraphicsElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(SVGGElement.prototype, {
+    [Symbol.toStringTag]: { value: "SVGGElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGGElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGGElement
+  });
+};
+
+const Impl = require("../nodes/SVGGElement-impl.js");

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

@@ -0,0 +1,139 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGElement = require("./SVGElement.js");
+
+const interfaceName = "SVGGraphicsElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGGraphicsElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGGraphicsElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGGraphicsElement extends globalObject.SVGElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get requiredExtensions() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get requiredExtensions' called on an object that is not a valid instance of SVGGraphicsElement."
+        );
+      }
+
+      return utils.getSameObject(this, "requiredExtensions", () => {
+        return utils.tryWrapperForImpl(esValue[implSymbol]["requiredExtensions"]);
+      });
+    }
+
+    get systemLanguage() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get systemLanguage' called on an object that is not a valid instance of SVGGraphicsElement."
+        );
+      }
+
+      return utils.getSameObject(this, "systemLanguage", () => {
+        return utils.tryWrapperForImpl(esValue[implSymbol]["systemLanguage"]);
+      });
+    }
+  }
+  Object.defineProperties(SVGGraphicsElement.prototype, {
+    requiredExtensions: { enumerable: true },
+    systemLanguage: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGGraphicsElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGGraphicsElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGGraphicsElement
+  });
+};
+
+const Impl = require("../nodes/SVGGraphicsElement-impl.js");

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

@@ -0,0 +1,109 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGElement = require("./SVGElement.js");
+
+const interfaceName = "SVGMetadataElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGMetadataElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGMetadataElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGMetadataElement extends globalObject.SVGElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(SVGMetadataElement.prototype, {
+    [Symbol.toStringTag]: { value: "SVGMetadataElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGMetadataElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGMetadataElement
+  });
+};
+
+const Impl = require("../nodes/SVGMetadataElement-impl.js");

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

@@ -0,0 +1,132 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGNumber";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGNumber'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGNumber"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGNumber {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get value() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get value' called on an object that is not a valid instance of SVGNumber.");
+      }
+
+      return esValue[implSymbol]["value"];
+    }
+
+    set value(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'set value' called on an object that is not a valid instance of SVGNumber.");
+      }
+
+      V = conversions["float"](V, {
+        context: "Failed to set the 'value' property on 'SVGNumber': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["value"] = V;
+    }
+  }
+  Object.defineProperties(SVGNumber.prototype, {
+    value: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGNumber", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGNumber;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGNumber
+  });
+};
+
+const Impl = require("../svg/SVGNumber-impl.js");

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

@@ -0,0 +1,196 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGPreserveAspectRatio";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGPreserveAspectRatio'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGPreserveAspectRatio"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGPreserveAspectRatio {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get align() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get align' called on an object that is not a valid instance of SVGPreserveAspectRatio."
+        );
+      }
+
+      return esValue[implSymbol]["align"];
+    }
+
+    set align(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set align' called on an object that is not a valid instance of SVGPreserveAspectRatio."
+        );
+      }
+
+      V = conversions["unsigned short"](V, {
+        context: "Failed to set the 'align' property on 'SVGPreserveAspectRatio': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["align"] = V;
+    }
+
+    get meetOrSlice() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get meetOrSlice' called on an object that is not a valid instance of SVGPreserveAspectRatio."
+        );
+      }
+
+      return esValue[implSymbol]["meetOrSlice"];
+    }
+
+    set meetOrSlice(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set meetOrSlice' called on an object that is not a valid instance of SVGPreserveAspectRatio."
+        );
+      }
+
+      V = conversions["unsigned short"](V, {
+        context: "Failed to set the 'meetOrSlice' property on 'SVGPreserveAspectRatio': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["meetOrSlice"] = V;
+    }
+  }
+  Object.defineProperties(SVGPreserveAspectRatio.prototype, {
+    align: { enumerable: true },
+    meetOrSlice: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGPreserveAspectRatio", configurable: true },
+    SVG_PRESERVEASPECTRATIO_UNKNOWN: { value: 0, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_NONE: { value: 1, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMINYMIN: { value: 2, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMIDYMIN: { value: 3, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMAXYMIN: { value: 4, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMINYMID: { value: 5, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMIDYMID: { value: 6, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMAXYMID: { value: 7, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMINYMAX: { value: 8, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMIDYMAX: { value: 9, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMAXYMAX: { value: 10, enumerable: true },
+    SVG_MEETORSLICE_UNKNOWN: { value: 0, enumerable: true },
+    SVG_MEETORSLICE_MEET: { value: 1, enumerable: true },
+    SVG_MEETORSLICE_SLICE: { value: 2, enumerable: true }
+  });
+  Object.defineProperties(SVGPreserveAspectRatio, {
+    SVG_PRESERVEASPECTRATIO_UNKNOWN: { value: 0, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_NONE: { value: 1, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMINYMIN: { value: 2, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMIDYMIN: { value: 3, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMAXYMIN: { value: 4, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMINYMID: { value: 5, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMIDYMID: { value: 6, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMAXYMID: { value: 7, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMINYMAX: { value: 8, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMIDYMAX: { value: 9, enumerable: true },
+    SVG_PRESERVEASPECTRATIO_XMAXYMAX: { value: 10, enumerable: true },
+    SVG_MEETORSLICE_UNKNOWN: { value: 0, enumerable: true },
+    SVG_MEETORSLICE_MEET: { value: 1, enumerable: true },
+    SVG_MEETORSLICE_SLICE: { value: 2, enumerable: true }
+  });
+  ctorRegistry[interfaceName] = SVGPreserveAspectRatio;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGPreserveAspectRatio
+  });
+};
+
+const Impl = require("../svg/SVGPreserveAspectRatio-impl.js");

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

@@ -0,0 +1,210 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGRect";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGRect'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGRect"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGRect {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get x() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get x' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      return esValue[implSymbol]["x"];
+    }
+
+    set x(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'set x' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      V = conversions["float"](V, {
+        context: "Failed to set the 'x' property on 'SVGRect': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["x"] = V;
+    }
+
+    get y() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get y' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      return esValue[implSymbol]["y"];
+    }
+
+    set y(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'set y' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      V = conversions["float"](V, {
+        context: "Failed to set the 'y' property on 'SVGRect': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["y"] = V;
+    }
+
+    get width() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get width' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      return esValue[implSymbol]["width"];
+    }
+
+    set width(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'set width' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      V = conversions["float"](V, {
+        context: "Failed to set the 'width' property on 'SVGRect': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["width"] = V;
+    }
+
+    get height() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get height' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      return esValue[implSymbol]["height"];
+    }
+
+    set height(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'set height' called on an object that is not a valid instance of SVGRect.");
+      }
+
+      V = conversions["float"](V, {
+        context: "Failed to set the 'height' property on 'SVGRect': The provided value",
+        globals: globalObject
+      });
+
+      esValue[implSymbol]["height"] = V;
+    }
+  }
+  Object.defineProperties(SVGRect.prototype, {
+    x: { enumerable: true },
+    y: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGRect", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGRect;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGRect
+  });
+};
+
+const Impl = require("../svg/SVGRect-impl.js");

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

@@ -0,0 +1,786 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const create_SVGAnimatedRect = require("./SVGAnimatedRect.js").create;
+const create_SVGAnimatedPreserveAspectRatio = require("./SVGAnimatedPreserveAspectRatio.js").create;
+const EventHandlerNonNull = require("./EventHandlerNonNull.js");
+const OnBeforeUnloadEventHandlerNonNull = require("./OnBeforeUnloadEventHandlerNonNull.js");
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGGraphicsElement = require("./SVGGraphicsElement.js");
+
+const interfaceName = "SVGSVGElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGSVGElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGSVGElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGGraphicsElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGSVGElement extends globalObject.SVGGraphicsElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    createSVGNumber() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'createSVGNumber' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol].createSVGNumber());
+    }
+
+    createSVGRect() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'createSVGRect' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol].createSVGRect());
+    }
+
+    getElementById(elementId) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'getElementById' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'getElementById' on 'SVGSVGElement': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getElementById' on 'SVGSVGElement': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(esValue[implSymbol].getElementById(...args));
+    }
+
+    suspendRedraw(maxWaitMilliseconds) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'suspendRedraw' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'suspendRedraw' on 'SVGSVGElement': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'suspendRedraw' on 'SVGSVGElement': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].suspendRedraw(...args);
+    }
+
+    unsuspendRedraw(suspendHandleID) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'unsuspendRedraw' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'unsuspendRedraw' on 'SVGSVGElement': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'unsuspendRedraw' on 'SVGSVGElement': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].unsuspendRedraw(...args);
+    }
+
+    unsuspendRedrawAll() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'unsuspendRedrawAll' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return esValue[implSymbol].unsuspendRedrawAll();
+    }
+
+    forceRedraw() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'forceRedraw' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return esValue[implSymbol].forceRedraw();
+    }
+
+    get viewBox() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get viewBox' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.getSameObject(this, "viewBox", () => {
+        return create_SVGAnimatedRect(globalObject, [], {
+          element: esValue[implSymbol],
+          attribute: "viewBox"
+        });
+      });
+    }
+
+    get preserveAspectRatio() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get preserveAspectRatio' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.getSameObject(this, "preserveAspectRatio", () => {
+        return create_SVGAnimatedPreserveAspectRatio(globalObject, [], {
+          element: esValue[implSymbol]
+        });
+      });
+    }
+
+    get onafterprint() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onafterprint' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onafterprint"]);
+    }
+
+    set onafterprint(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onafterprint' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onafterprint' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onafterprint"] = V;
+    }
+
+    get onbeforeprint() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onbeforeprint' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onbeforeprint"]);
+    }
+
+    set onbeforeprint(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onbeforeprint' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onbeforeprint' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onbeforeprint"] = V;
+    }
+
+    get onbeforeunload() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onbeforeunload' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onbeforeunload"]);
+    }
+
+    set onbeforeunload(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onbeforeunload' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = OnBeforeUnloadEventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onbeforeunload' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onbeforeunload"] = V;
+    }
+
+    get onhashchange() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onhashchange' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onhashchange"]);
+    }
+
+    set onhashchange(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onhashchange' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onhashchange' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onhashchange"] = V;
+    }
+
+    get onlanguagechange() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onlanguagechange' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onlanguagechange"]);
+    }
+
+    set onlanguagechange(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onlanguagechange' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onlanguagechange' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onlanguagechange"] = V;
+    }
+
+    get onmessage() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onmessage' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onmessage"]);
+    }
+
+    set onmessage(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onmessage' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onmessage' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onmessage"] = V;
+    }
+
+    get onmessageerror() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onmessageerror' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onmessageerror"]);
+    }
+
+    set onmessageerror(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onmessageerror' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onmessageerror' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onmessageerror"] = V;
+    }
+
+    get onoffline() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onoffline' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onoffline"]);
+    }
+
+    set onoffline(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onoffline' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onoffline' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onoffline"] = V;
+    }
+
+    get ononline() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get ononline' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["ononline"]);
+    }
+
+    set ononline(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set ononline' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'ononline' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["ononline"] = V;
+    }
+
+    get onpagehide() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onpagehide' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onpagehide"]);
+    }
+
+    set onpagehide(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onpagehide' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onpagehide' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onpagehide"] = V;
+    }
+
+    get onpageshow() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onpageshow' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onpageshow"]);
+    }
+
+    set onpageshow(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onpageshow' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onpageshow' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onpageshow"] = V;
+    }
+
+    get onpopstate() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onpopstate' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onpopstate"]);
+    }
+
+    set onpopstate(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onpopstate' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onpopstate' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onpopstate"] = V;
+    }
+
+    get onrejectionhandled() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onrejectionhandled' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onrejectionhandled"]);
+    }
+
+    set onrejectionhandled(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onrejectionhandled' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onrejectionhandled' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onrejectionhandled"] = V;
+    }
+
+    get onstorage() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onstorage' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onstorage"]);
+    }
+
+    set onstorage(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onstorage' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onstorage' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onstorage"] = V;
+    }
+
+    get onunhandledrejection() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onunhandledrejection' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onunhandledrejection"]);
+    }
+
+    set onunhandledrejection(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onunhandledrejection' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onunhandledrejection' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onunhandledrejection"] = V;
+    }
+
+    get onunload() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get onunload' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["onunload"]);
+    }
+
+    set onunload(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set onunload' called on an object that is not a valid instance of SVGSVGElement."
+        );
+      }
+
+      if (!utils.isObject(V)) {
+        V = null;
+      } else {
+        V = EventHandlerNonNull.convert(globalObject, V, {
+          context: "Failed to set the 'onunload' property on 'SVGSVGElement': The provided value"
+        });
+      }
+      esValue[implSymbol]["onunload"] = V;
+    }
+  }
+  Object.defineProperties(SVGSVGElement.prototype, {
+    createSVGNumber: { enumerable: true },
+    createSVGRect: { enumerable: true },
+    getElementById: { enumerable: true },
+    suspendRedraw: { enumerable: true },
+    unsuspendRedraw: { enumerable: true },
+    unsuspendRedrawAll: { enumerable: true },
+    forceRedraw: { enumerable: true },
+    viewBox: { enumerable: true },
+    preserveAspectRatio: { enumerable: true },
+    onafterprint: { enumerable: true },
+    onbeforeprint: { enumerable: true },
+    onbeforeunload: { enumerable: true },
+    onhashchange: { enumerable: true },
+    onlanguagechange: { enumerable: true },
+    onmessage: { enumerable: true },
+    onmessageerror: { enumerable: true },
+    onoffline: { enumerable: true },
+    ononline: { enumerable: true },
+    onpagehide: { enumerable: true },
+    onpageshow: { enumerable: true },
+    onpopstate: { enumerable: true },
+    onrejectionhandled: { enumerable: true },
+    onstorage: { enumerable: true },
+    onunhandledrejection: { enumerable: true },
+    onunload: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGSVGElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGSVGElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGSVGElement
+  });
+};
+
+const Impl = require("../nodes/SVGSVGElement-impl.js");

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

@@ -0,0 +1,511 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "SVGStringList";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGStringList'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGStringList"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+function makeProxy(wrapper, globalObject) {
+  let proxyHandler = proxyHandlerCache.get(globalObject);
+  if (proxyHandler === undefined) {
+    proxyHandler = new ProxyHandler(globalObject);
+    proxyHandlerCache.set(globalObject, proxyHandler);
+  }
+  return new Proxy(wrapper, proxyHandler);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  let wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGStringList {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    clear() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'clear' called on an object that is not a valid instance of SVGStringList.");
+      }
+
+      return esValue[implSymbol].clear();
+    }
+
+    initialize(newItem) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'initialize' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'initialize' on 'SVGStringList': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'initialize' on 'SVGStringList': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].initialize(...args);
+    }
+
+    getItem(index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'getItem' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'getItem' on 'SVGStringList': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'getItem' on 'SVGStringList': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].getItem(...args);
+    }
+
+    insertItemBefore(newItem, index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'insertItemBefore' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'insertItemBefore' on 'SVGStringList': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'insertItemBefore' on 'SVGStringList': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'insertItemBefore' on 'SVGStringList': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].insertItemBefore(...args);
+    }
+
+    replaceItem(newItem, index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'replaceItem' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'replaceItem' on 'SVGStringList': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'replaceItem' on 'SVGStringList': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'replaceItem' on 'SVGStringList': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].replaceItem(...args);
+    }
+
+    removeItem(index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'removeItem' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'removeItem' on 'SVGStringList': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'removeItem' on 'SVGStringList': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].removeItem(...args);
+    }
+
+    appendItem(newItem) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'appendItem' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'appendItem' on 'SVGStringList': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'appendItem' on 'SVGStringList': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].appendItem(...args);
+    }
+
+    get length() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get length' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      return esValue[implSymbol]["length"];
+    }
+
+    get numberOfItems() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get numberOfItems' called on an object that is not a valid instance of SVGStringList."
+        );
+      }
+
+      return esValue[implSymbol]["numberOfItems"];
+    }
+  }
+  Object.defineProperties(SVGStringList.prototype, {
+    clear: { enumerable: true },
+    initialize: { enumerable: true },
+    getItem: { enumerable: true },
+    insertItemBefore: { enumerable: true },
+    replaceItem: { enumerable: true },
+    removeItem: { enumerable: true },
+    appendItem: { enumerable: true },
+    length: { enumerable: true },
+    numberOfItems: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGStringList", configurable: true },
+    [Symbol.iterator]: { value: globalObject.Array.prototype[Symbol.iterator], configurable: true, writable: true }
+  });
+  ctorRegistry[interfaceName] = SVGStringList;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGStringList
+  });
+};
+
+const proxyHandlerCache = new WeakMap();
+class ProxyHandler {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  get(target, P, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.get(target, P, receiver);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc === undefined) {
+      const parent = Object.getPrototypeOf(target);
+      if (parent === null) {
+        return undefined;
+      }
+      return Reflect.get(target, P, receiver);
+    }
+    if (!desc.get && !desc.set) {
+      return desc.value;
+    }
+    const getter = desc.get;
+    if (getter === undefined) {
+      return undefined;
+    }
+    return Reflect.apply(getter, receiver, []);
+  }
+
+  has(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.has(target, P);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc !== undefined) {
+      return true;
+    }
+    const parent = Object.getPrototypeOf(target);
+    if (parent !== null) {
+      return Reflect.has(parent, P);
+    }
+    return false;
+  }
+
+  ownKeys(target) {
+    const keys = new Set();
+
+    for (const key of target[implSymbol][utils.supportedPropertyIndices]) {
+      keys.add(`${key}`);
+    }
+
+    for (const key of Reflect.ownKeys(target)) {
+      keys.add(key);
+    }
+    return [...keys];
+  }
+
+  getOwnPropertyDescriptor(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    let ignoreNamedProps = false;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+
+      if (target[implSymbol][utils.supportsPropertyIndex](index)) {
+        const indexedValue = target[implSymbol].getItem(index);
+        return {
+          writable: true,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+      ignoreNamedProps = true;
+    }
+
+    return Reflect.getOwnPropertyDescriptor(target, P);
+  }
+
+  set(target, P, V, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.set(target, P, V, receiver);
+    }
+    // The `receiver` argument refers to the Proxy exotic object or an object
+    // that inherits from it, whereas `target` refers to the Proxy target:
+    if (target[implSymbol][utils.wrapperSymbol] === receiver) {
+      const globalObject = this._globalObject;
+
+      if (utils.isArrayIndexPropName(P)) {
+        const index = P >>> 0;
+        let indexedValue = V;
+
+        indexedValue = conversions["DOMString"](indexedValue, {
+          context: "Failed to set the " + index + " property on 'SVGStringList': The provided value",
+          globals: globalObject
+        });
+
+        const creating = !target[implSymbol][utils.supportsPropertyIndex](index);
+        if (creating) {
+          target[implSymbol][utils.indexedSetNew](index, indexedValue);
+        } else {
+          target[implSymbol][utils.indexedSetExisting](index, indexedValue);
+        }
+
+        return true;
+      }
+    }
+    let ownDesc;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+
+      if (target[implSymbol][utils.supportsPropertyIndex](index)) {
+        const indexedValue = target[implSymbol].getItem(index);
+        ownDesc = {
+          writable: true,
+          enumerable: true,
+          configurable: true,
+          value: utils.tryWrapperForImpl(indexedValue)
+        };
+      }
+    }
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    return utils.ordinarySetWithOwnDescriptor(target, P, V, receiver, ownDesc);
+  }
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      if (desc.get || desc.set) {
+        return false;
+      }
+
+      const index = P >>> 0;
+      let indexedValue = desc.value;
+
+      indexedValue = conversions["DOMString"](indexedValue, {
+        context: "Failed to set the " + index + " property on 'SVGStringList': The provided value",
+        globals: globalObject
+      });
+
+      const creating = !target[implSymbol][utils.supportsPropertyIndex](index);
+      if (creating) {
+        target[implSymbol][utils.indexedSetNew](index, indexedValue);
+      } else {
+        target[implSymbol][utils.indexedSetExisting](index, indexedValue);
+      }
+
+      return true;
+    }
+
+    return Reflect.defineProperty(target, P, desc);
+  }
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (utils.isArrayIndexPropName(P)) {
+      const index = P >>> 0;
+      return !target[implSymbol][utils.supportsPropertyIndex](index);
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../svg/SVGStringList-impl.js");

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

@@ -0,0 +1,109 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGGraphicsElement = require("./SVGGraphicsElement.js");
+
+const interfaceName = "SVGSwitchElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGSwitchElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGSwitchElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGGraphicsElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGSwitchElement extends globalObject.SVGGraphicsElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(SVGSwitchElement.prototype, {
+    [Symbol.toStringTag]: { value: "SVGSwitchElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGSwitchElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGSwitchElement
+  });
+};
+
+const Impl = require("../nodes/SVGSwitchElement-impl.js");

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

@@ -0,0 +1,146 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const create_SVGAnimatedRect = require("./SVGAnimatedRect.js").create;
+const create_SVGAnimatedPreserveAspectRatio = require("./SVGAnimatedPreserveAspectRatio.js").create;
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGGraphicsElement = require("./SVGGraphicsElement.js");
+
+const interfaceName = "SVGSymbolElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGSymbolElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGSymbolElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGGraphicsElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGSymbolElement extends globalObject.SVGGraphicsElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get viewBox() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get viewBox' called on an object that is not a valid instance of SVGSymbolElement."
+        );
+      }
+
+      return utils.getSameObject(this, "viewBox", () => {
+        return create_SVGAnimatedRect(globalObject, [], {
+          element: esValue[implSymbol],
+          attribute: "viewBox"
+        });
+      });
+    }
+
+    get preserveAspectRatio() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get preserveAspectRatio' called on an object that is not a valid instance of SVGSymbolElement."
+        );
+      }
+
+      return utils.getSameObject(this, "preserveAspectRatio", () => {
+        return create_SVGAnimatedPreserveAspectRatio(globalObject, [], {
+          element: esValue[implSymbol]
+        });
+      });
+    }
+  }
+  Object.defineProperties(SVGSymbolElement.prototype, {
+    viewBox: { enumerable: true },
+    preserveAspectRatio: { enumerable: true },
+    [Symbol.toStringTag]: { value: "SVGSymbolElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGSymbolElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGSymbolElement
+  });
+};
+
+const Impl = require("../nodes/SVGSymbolElement-impl.js");

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

@@ -0,0 +1,109 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const SVGElement = require("./SVGElement.js");
+
+const interfaceName = "SVGTitleElement";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'SVGTitleElement'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["SVGTitleElement"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  SVGElement._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class SVGTitleElement extends globalObject.SVGElement {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+  }
+  Object.defineProperties(SVGTitleElement.prototype, {
+    [Symbol.toStringTag]: { value: "SVGTitleElement", configurable: true }
+  });
+  ctorRegistry[interfaceName] = SVGTitleElement;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: SVGTitleElement
+  });
+};
+
+const Impl = require("../nodes/SVGTitleElement-impl.js");

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

@@ -0,0 +1,180 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "Screen";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'Screen'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["Screen"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class Screen {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get availWidth() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get availWidth' called on an object that is not a valid instance of Screen."
+        );
+      }
+
+      return esValue[implSymbol]["availWidth"];
+    }
+
+    get availHeight() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get availHeight' called on an object that is not a valid instance of Screen."
+        );
+      }
+
+      return esValue[implSymbol]["availHeight"];
+    }
+
+    get width() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get width' called on an object that is not a valid instance of Screen.");
+      }
+
+      return esValue[implSymbol]["width"];
+    }
+
+    get height() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get height' called on an object that is not a valid instance of Screen.");
+      }
+
+      return esValue[implSymbol]["height"];
+    }
+
+    get colorDepth() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get colorDepth' called on an object that is not a valid instance of Screen."
+        );
+      }
+
+      return esValue[implSymbol]["colorDepth"];
+    }
+
+    get pixelDepth() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get pixelDepth' called on an object that is not a valid instance of Screen."
+        );
+      }
+
+      return esValue[implSymbol]["pixelDepth"];
+    }
+  }
+  Object.defineProperties(Screen.prototype, {
+    availWidth: { enumerable: true },
+    availHeight: { enumerable: true },
+    width: { enumerable: true },
+    height: { enumerable: true },
+    colorDepth: { enumerable: true },
+    pixelDepth: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Screen", configurable: true }
+  });
+  ctorRegistry[interfaceName] = Screen;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Screen
+  });
+};
+
+const Impl = require("../window/Screen-impl.js");

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

@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["auto", "instant", "smooth"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  const string = `${value}`;
+  if (!enumerationValues.has(string)) {
+    throw new globalObject.TypeError(`${context} '${string}' is not a valid enumeration value for ScrollBehavior`);
+  }
+  return string;
+};

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

@@ -0,0 +1,45 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const ScrollLogicalPosition = require("./ScrollLogicalPosition.js");
+const ScrollOptions = require("./ScrollOptions.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  ScrollOptions._convertInherit(globalObject, obj, ret, { context });
+
+  {
+    const key = "block";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = ScrollLogicalPosition.convert(globalObject, value, { context: context + " has member 'block' that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "start";
+    }
+  }
+
+  {
+    const key = "inline";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = ScrollLogicalPosition.convert(globalObject, value, { context: context + " has member 'inline' that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "nearest";
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+
+const enumerationValues = new Set(["start", "center", "end", "nearest"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  const string = `${value}`;
+  if (!enumerationValues.has(string)) {
+    throw new globalObject.TypeError(
+      `${context} '${string}' is not a valid enumeration value for ScrollLogicalPosition`
+    );
+  }
+  return string;
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const ScrollBehavior = require("./ScrollBehavior.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  {
+    const key = "behavior";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = ScrollBehavior.convert(globalObject, value, { context: context + " has member 'behavior' that" });
+
+      ret[key] = value;
+    } else {
+      ret[key] = "auto";
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["auto", "manual"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  const string = `${value}`;
+  if (!enumerationValues.has(string)) {
+    throw new globalObject.TypeError(`${context} '${string}' is not a valid enumeration value for ScrollRestoration`);
+  }
+  return string;
+};

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

@@ -0,0 +1,569 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const Range = require("./Range.js");
+const Node = require("./Node.js");
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "Selection";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'Selection'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["Selection"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class Selection {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    getRangeAt(index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'getRangeAt' called on an object that is not a valid instance of Selection.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'getRangeAt' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'getRangeAt' on 'Selection': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return utils.tryWrapperForImpl(esValue[implSymbol].getRangeAt(...args));
+    }
+
+    addRange(range) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'addRange' called on an object that is not a valid instance of Selection.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'addRange' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Range.convert(globalObject, curArg, {
+          context: "Failed to execute 'addRange' on 'Selection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].addRange(...args);
+    }
+
+    removeRange(range) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'removeRange' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'removeRange' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Range.convert(globalObject, curArg, {
+          context: "Failed to execute 'removeRange' on 'Selection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].removeRange(...args);
+    }
+
+    removeAllRanges() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'removeAllRanges' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return esValue[implSymbol].removeAllRanges();
+    }
+
+    empty() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'empty' called on an object that is not a valid instance of Selection.");
+      }
+
+      return esValue[implSymbol].empty();
+    }
+
+    collapse(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'collapse' called on an object that is not a valid instance of Selection.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'collapse' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = Node.convert(globalObject, curArg, {
+            context: "Failed to execute 'collapse' on 'Selection': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["unsigned long"](curArg, {
+            context: "Failed to execute 'collapse' on 'Selection': parameter 2",
+            globals: globalObject
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return esValue[implSymbol].collapse(...args);
+    }
+
+    setPosition(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'setPosition' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setPosition' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg === null || curArg === undefined) {
+          curArg = null;
+        } else {
+          curArg = Node.convert(globalObject, curArg, {
+            context: "Failed to execute 'setPosition' on 'Selection': parameter 1"
+          });
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["unsigned long"](curArg, {
+            context: "Failed to execute 'setPosition' on 'Selection': parameter 2",
+            globals: globalObject
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setPosition(...args);
+    }
+
+    collapseToStart() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'collapseToStart' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return esValue[implSymbol].collapseToStart();
+    }
+
+    collapseToEnd() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'collapseToEnd' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return esValue[implSymbol].collapseToEnd();
+    }
+
+    extend(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'extend' called on an object that is not a valid instance of Selection.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'extend' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'extend' on 'Selection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["unsigned long"](curArg, {
+            context: "Failed to execute 'extend' on 'Selection': parameter 2",
+            globals: globalObject
+          });
+        } else {
+          curArg = 0;
+        }
+        args.push(curArg);
+      }
+      return esValue[implSymbol].extend(...args);
+    }
+
+    setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'setBaseAndExtent' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      if (arguments.length < 4) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setBaseAndExtent' on 'Selection': 4 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'setBaseAndExtent' on 'Selection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setBaseAndExtent' on 'Selection': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[2];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'setBaseAndExtent' on 'Selection': parameter 3"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[3];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'setBaseAndExtent' on 'Selection': parameter 4",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setBaseAndExtent(...args);
+    }
+
+    selectAllChildren(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'selectAllChildren' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'selectAllChildren' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'selectAllChildren' on 'Selection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].selectAllChildren(...args);
+    }
+
+    deleteFromDocument() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'deleteFromDocument' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return esValue[implSymbol].deleteFromDocument();
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    containsNode(node) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'containsNode' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'containsNode' on 'Selection': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = Node.convert(globalObject, curArg, {
+          context: "Failed to execute 'containsNode' on 'Selection': parameter 1"
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["boolean"](curArg, {
+            context: "Failed to execute 'containsNode' on 'Selection': parameter 2",
+            globals: globalObject
+          });
+        } else {
+          curArg = false;
+        }
+        args.push(curArg);
+      }
+      return esValue[implSymbol].containsNode(...args);
+    }
+
+    toString() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'toString' called on an object that is not a valid instance of Selection.");
+      }
+
+      return esValue[implSymbol].toString();
+    }
+
+    get anchorNode() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get anchorNode' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["anchorNode"]);
+    }
+
+    get anchorOffset() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get anchorOffset' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return esValue[implSymbol]["anchorOffset"];
+    }
+
+    get focusNode() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get focusNode' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["focusNode"]);
+    }
+
+    get focusOffset() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get focusOffset' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return esValue[implSymbol]["focusOffset"];
+    }
+
+    get isCollapsed() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get isCollapsed' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return esValue[implSymbol]["isCollapsed"];
+    }
+
+    get rangeCount() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get rangeCount' called on an object that is not a valid instance of Selection."
+        );
+      }
+
+      return esValue[implSymbol]["rangeCount"];
+    }
+
+    get type() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get type' called on an object that is not a valid instance of Selection.");
+      }
+
+      return esValue[implSymbol]["type"];
+    }
+  }
+  Object.defineProperties(Selection.prototype, {
+    getRangeAt: { enumerable: true },
+    addRange: { enumerable: true },
+    removeRange: { enumerable: true },
+    removeAllRanges: { enumerable: true },
+    empty: { enumerable: true },
+    collapse: { enumerable: true },
+    setPosition: { enumerable: true },
+    collapseToStart: { enumerable: true },
+    collapseToEnd: { enumerable: true },
+    extend: { enumerable: true },
+    setBaseAndExtent: { enumerable: true },
+    selectAllChildren: { enumerable: true },
+    deleteFromDocument: { enumerable: true },
+    containsNode: { enumerable: true },
+    toString: { enumerable: true },
+    anchorNode: { enumerable: true },
+    anchorOffset: { enumerable: true },
+    focusNode: { enumerable: true },
+    focusOffset: { enumerable: true },
+    isCollapsed: { enumerable: true },
+    rangeCount: { enumerable: true },
+    type: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Selection", configurable: true }
+  });
+  ctorRegistry[interfaceName] = Selection;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Selection
+  });
+};
+
+const Impl = require("../selection/Selection-impl.js");

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

@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["select", "start", "end", "preserve"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  const string = `${value}`;
+  if (!enumerationValues.has(string)) {
+    throw new globalObject.TypeError(`${context} '${string}' is not a valid enumeration value for SelectionMode`);
+  }
+  return string;
+};

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

@@ -0,0 +1,187 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const ceReactionsPreSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPreSteps;
+const ceReactionsPostSteps_helpers_custom_elements = require("../helpers/custom-elements.js").ceReactionsPostSteps;
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const DocumentFragment = require("./DocumentFragment.js");
+
+const interfaceName = "ShadowRoot";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'ShadowRoot'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["ShadowRoot"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  DocumentFragment._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class ShadowRoot extends globalObject.DocumentFragment {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    get mode() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get mode' called on an object that is not a valid instance of ShadowRoot.");
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["mode"]);
+    }
+
+    get host() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get host' called on an object that is not a valid instance of ShadowRoot.");
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["host"]);
+    }
+
+    get innerHTML() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get innerHTML' called on an object that is not a valid instance of ShadowRoot."
+        );
+      }
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        return esValue[implSymbol]["innerHTML"];
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    set innerHTML(V) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'set innerHTML' called on an object that is not a valid instance of ShadowRoot."
+        );
+      }
+
+      V = conversions["DOMString"](V, {
+        context: "Failed to set the 'innerHTML' property on 'ShadowRoot': The provided value",
+        globals: globalObject,
+        treatNullAsEmptyString: true
+      });
+
+      ceReactionsPreSteps_helpers_custom_elements(globalObject);
+      try {
+        esValue[implSymbol]["innerHTML"] = V;
+      } finally {
+        ceReactionsPostSteps_helpers_custom_elements(globalObject);
+      }
+    }
+
+    get activeElement() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get activeElement' called on an object that is not a valid instance of ShadowRoot."
+        );
+      }
+
+      return utils.tryWrapperForImpl(esValue[implSymbol]["activeElement"]);
+    }
+  }
+  Object.defineProperties(ShadowRoot.prototype, {
+    mode: { enumerable: true },
+    host: { enumerable: true },
+    innerHTML: { enumerable: true },
+    activeElement: { enumerable: true },
+    [Symbol.toStringTag]: { value: "ShadowRoot", configurable: true }
+  });
+  ctorRegistry[interfaceName] = ShadowRoot;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: ShadowRoot
+  });
+};
+
+const Impl = require("../nodes/ShadowRoot-impl.js");

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

@@ -0,0 +1,30 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const ShadowRootMode = require("./ShadowRootMode.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  {
+    const key = "mode";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = ShadowRootMode.convert(globalObject, value, { context: context + " has member 'mode' that" });
+
+      ret[key] = value;
+    } else {
+      throw new globalObject.TypeError("mode is required in 'ShadowRootInit'");
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+
+const enumerationValues = new Set(["open", "closed"]);
+exports.enumerationValues = enumerationValues;
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  const string = `${value}`;
+  if (!enumerationValues.has(string)) {
+    throw new globalObject.TypeError(`${context} '${string}' is not a valid enumeration value for ShadowRootMode`);
+  }
+  return string;
+};

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

@@ -0,0 +1,123 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const StaticRangeInit = require("./StaticRangeInit.js");
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+const AbstractRange = require("./AbstractRange.js");
+
+const interfaceName = "StaticRange";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'StaticRange'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["StaticRange"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {
+  AbstractRange._internalSetup(wrapper, globalObject);
+};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class StaticRange extends globalObject.AbstractRange {
+    constructor(init) {
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to construct 'StaticRange': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = StaticRangeInit.convert(globalObject, curArg, {
+          context: "Failed to construct 'StaticRange': parameter 1"
+        });
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+  }
+  Object.defineProperties(StaticRange.prototype, {
+    [Symbol.toStringTag]: { value: "StaticRange", configurable: true }
+  });
+  ctorRegistry[interfaceName] = StaticRange;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: StaticRange
+  });
+};
+
+const Impl = require("../range/StaticRange-impl.js");

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

@@ -0,0 +1,72 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const Node = require("./Node.js");
+
+exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
+  {
+    const key = "endContainer";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = Node.convert(globalObject, value, { context: context + " has member 'endContainer' that" });
+
+      ret[key] = value;
+    } else {
+      throw new globalObject.TypeError("endContainer is required in 'StaticRangeInit'");
+    }
+  }
+
+  {
+    const key = "endOffset";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, {
+        context: context + " has member 'endOffset' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      throw new globalObject.TypeError("endOffset is required in 'StaticRangeInit'");
+    }
+  }
+
+  {
+    const key = "startContainer";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = Node.convert(globalObject, value, { context: context + " has member 'startContainer' that" });
+
+      ret[key] = value;
+    } else {
+      throw new globalObject.TypeError("startContainer is required in 'StaticRangeInit'");
+    }
+  }
+
+  {
+    const key = "startOffset";
+    let value = obj === undefined || obj === null ? undefined : obj[key];
+    if (value !== undefined) {
+      value = conversions["unsigned long"](value, {
+        context: context + " has member 'startOffset' that",
+        globals: globalObject
+      });
+
+      ret[key] = value;
+    } else {
+      throw new globalObject.TypeError("startOffset is required in 'StaticRangeInit'");
+    }
+  }
+};
+
+exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
+  if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
+    throw new globalObject.TypeError(`${context} is not an object.`);
+  }
+
+  const ret = Object.create(null);
+  exports._convertInherit(globalObject, obj, ret, { context });
+  return ret;
+};

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

@@ -0,0 +1,397 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
+
+const interfaceName = "Storage";
+
+exports.is = value => {
+  return utils.isObject(value) && Object.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
+  }
+  throw new globalObject.TypeError(`${context} is not of type 'Storage'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["Storage"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+function makeProxy(wrapper, globalObject) {
+  let proxyHandler = proxyHandlerCache.get(globalObject);
+  if (proxyHandler === undefined) {
+    proxyHandler = new ProxyHandler(globalObject);
+    proxyHandlerCache.set(globalObject, proxyHandler);
+  }
+  return new Proxy(wrapper, proxyHandler);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  let wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper = makeProxy(wrapper, globalObject);
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class Storage {
+    constructor() {
+      throw new globalObject.TypeError("Illegal constructor");
+    }
+
+    key(index) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'key' called on an object that is not a valid instance of Storage.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'key' on 'Storage': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["unsigned long"](curArg, {
+          context: "Failed to execute 'key' on 'Storage': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].key(...args);
+    }
+
+    getItem(key) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'getItem' called on an object that is not a valid instance of Storage.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'getItem' on 'Storage': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'getItem' on 'Storage': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].getItem(...args);
+    }
+
+    setItem(key, value) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'setItem' called on an object that is not a valid instance of Storage.");
+      }
+
+      if (arguments.length < 2) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'setItem' on 'Storage': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setItem' on 'Storage': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'setItem' on 'Storage': parameter 2",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].setItem(...args);
+    }
+
+    removeItem(key) {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'removeItem' called on an object that is not a valid instance of Storage.");
+      }
+
+      if (arguments.length < 1) {
+        throw new globalObject.TypeError(
+          `Failed to execute 'removeItem' on 'Storage': 1 argument required, but only ${arguments.length} present.`
+        );
+      }
+      const args = [];
+      {
+        let curArg = arguments[0];
+        curArg = conversions["DOMString"](curArg, {
+          context: "Failed to execute 'removeItem' on 'Storage': parameter 1",
+          globals: globalObject
+        });
+        args.push(curArg);
+      }
+      return esValue[implSymbol].removeItem(...args);
+    }
+
+    clear() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'clear' called on an object that is not a valid instance of Storage.");
+      }
+
+      return esValue[implSymbol].clear();
+    }
+
+    get length() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError("'get length' called on an object that is not a valid instance of Storage.");
+      }
+
+      return esValue[implSymbol]["length"];
+    }
+  }
+  Object.defineProperties(Storage.prototype, {
+    key: { enumerable: true },
+    getItem: { enumerable: true },
+    setItem: { enumerable: true },
+    removeItem: { enumerable: true },
+    clear: { enumerable: true },
+    length: { enumerable: true },
+    [Symbol.toStringTag]: { value: "Storage", configurable: true }
+  });
+  ctorRegistry[interfaceName] = Storage;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Storage
+  });
+};
+
+const proxyHandlerCache = new WeakMap();
+class ProxyHandler {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  get(target, P, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.get(target, P, receiver);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc === undefined) {
+      const parent = Object.getPrototypeOf(target);
+      if (parent === null) {
+        return undefined;
+      }
+      return Reflect.get(target, P, receiver);
+    }
+    if (!desc.get && !desc.set) {
+      return desc.value;
+    }
+    const getter = desc.get;
+    if (getter === undefined) {
+      return undefined;
+    }
+    return Reflect.apply(getter, receiver, []);
+  }
+
+  has(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.has(target, P);
+    }
+    const desc = this.getOwnPropertyDescriptor(target, P);
+    if (desc !== undefined) {
+      return true;
+    }
+    const parent = Object.getPrototypeOf(target);
+    if (parent !== null) {
+      return Reflect.has(parent, P);
+    }
+    return false;
+  }
+
+  ownKeys(target) {
+    const keys = new Set();
+
+    for (const key of target[implSymbol][utils.supportedPropertyNames]) {
+      if (!(key in target)) {
+        keys.add(`${key}`);
+      }
+    }
+
+    for (const key of Reflect.ownKeys(target)) {
+      keys.add(key);
+    }
+    return [...keys];
+  }
+
+  getOwnPropertyDescriptor(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    let ignoreNamedProps = false;
+
+    const namedValue = target[implSymbol].getItem(P);
+
+    if (namedValue !== null && !(P in target) && !ignoreNamedProps) {
+      return {
+        writable: true,
+        enumerable: true,
+        configurable: true,
+        value: utils.tryWrapperForImpl(namedValue)
+      };
+    }
+
+    return Reflect.getOwnPropertyDescriptor(target, P);
+  }
+
+  set(target, P, V, receiver) {
+    if (typeof P === "symbol") {
+      return Reflect.set(target, P, V, receiver);
+    }
+    // The `receiver` argument refers to the Proxy exotic object or an object
+    // that inherits from it, whereas `target` refers to the Proxy target:
+    if (target[implSymbol][utils.wrapperSymbol] === receiver) {
+      const globalObject = this._globalObject;
+
+      if (typeof P === "string") {
+        let namedValue = V;
+
+        namedValue = conversions["DOMString"](namedValue, {
+          context: "Failed to set the '" + P + "' property on 'Storage': The provided value",
+          globals: globalObject
+        });
+
+        target[implSymbol].setItem(P, namedValue);
+
+        return true;
+      }
+    }
+    let ownDesc;
+
+    if (ownDesc === undefined) {
+      ownDesc = Reflect.getOwnPropertyDescriptor(target, P);
+    }
+    return utils.ordinarySetWithOwnDescriptor(target, P, V, receiver, ownDesc);
+  }
+
+  defineProperty(target, P, desc) {
+    if (typeof P === "symbol") {
+      return Reflect.defineProperty(target, P, desc);
+    }
+
+    const globalObject = this._globalObject;
+    if (!Object.hasOwn(target, P)) {
+      if (desc.get || desc.set) {
+        return false;
+      }
+
+      let namedValue = desc.value;
+
+      namedValue = conversions["DOMString"](namedValue, {
+        context: "Failed to set the '" + P + "' property on 'Storage': The provided value",
+        globals: globalObject
+      });
+
+      target[implSymbol].setItem(P, namedValue);
+
+      return true;
+    }
+    return Reflect.defineProperty(target, P, desc);
+  }
+
+  deleteProperty(target, P) {
+    if (typeof P === "symbol") {
+      return Reflect.deleteProperty(target, P);
+    }
+
+    const globalObject = this._globalObject;
+
+    if (target[implSymbol].getItem(P) !== null && !(P in target)) {
+      target[implSymbol].removeItem(P);
+      return true;
+    }
+
+    return Reflect.deleteProperty(target, P);
+  }
+
+  preventExtensions() {
+    return false;
+  }
+}
+
+const Impl = require("../webstorage/Storage-impl.js");